RustXMLParseTest/src/oop.rs

use phf::phf_ordered_map;
use crate::roxmltree::Node;

const MESSAGETYPE: phf::OrderedMap<&'static str, &'static str> = phf_ordered_map! {
    "Request" => "requests",
    "Response" => "responses",
    "Command" => "commands",
    "Status" => "statuses",
    "Stream" => "streams",
};

#[derive(Debug, Clone)]
pub struct Family {
    name: String,
    genera: Vec<Genus>,
    messages: Vec<Vec<String>>,
}

impl Family {
    pub fn new(name: String, genera: Vec<Genus>, messages: Vec<Vec<String>>) -> Self {
        Self { name, genera, messages }
    }

    pub fn get_name(&self) -> String{
        return self.name.clone()
    }

    /*pub fn set_name(&mut self, name: String){
        if self.name.len() == 0 {
            self.name = name
        }
    }*/

    pub fn get_genera(&mut self) -> &mut Vec<Genus>{
        return &mut self.genera
    }

    #[allow(unused)]
    pub fn get_messages(&self) -> Vec<Vec<String>>{
        return self.messages.clone()
    }

    pub fn push_genus(&mut self, genus: Genus) {
        self.genera.push(genus);
    }

    pub fn push_messages(&mut self, messages: Messages) {
        self.messages.push(messages.requests);
        self.messages.push(messages.responses);
        self.messages.push(messages.commands);
        self.messages.push(messages.statuses);
        self.messages.push(messages.streams);
    }
}

#[derive(Debug, Clone)]
pub struct Genus {
    name: String,
    species: Vec<Species>,
}

impl Genus {
    pub fn new(name: String, species: Vec<Species>) -> Self {
        Self { name, species }
    }

    pub fn get_name(&self) -> String{
        return self.name.clone()
    }

    pub fn get_species(&mut self) -> &mut Vec<Species>{
        return &mut self.species
    }

    pub fn push_species(&mut self, species: Species) {
        self.species.push(species);    
    }
}

#[derive(Debug, Clone)]
pub struct Species {
    name: String,
    default_value: String,
    objects: Vec<Object>,
}

impl Species {
    pub fn new(name: String, default_value: String, objects: Vec<Object>) -> Self {
        Self { name, default_value, objects }
    }

    pub fn get_name(&self) -> String{
        return self.name.clone()
    }

    #[allow(unused)]
    pub fn get_default_value(&self) -> String{
        return self.default_value.clone()
    }

    pub fn get_objects(&mut self) -> &mut Vec<Object>{
        return &mut self.objects
    }

    pub fn push_object(&mut self, object: Object) {
        self.objects.push(object);
    }
}

#[derive(Debug, Clone)]
pub struct Object {
    name: String,
    abrv: String,
    version: String,
    members: Vec<ObjectMember>,
}

impl Object {
    pub fn new(name: String, abrv: String, version: String, members: Vec<ObjectMember>) -> Self {
        Self { name, abrv, version, members }
    }

    #[allow(unused)]
    pub fn get_name(&self) -> String{
        return self.name.clone()
    }

    #[allow(unused)]
    pub fn get_abrv(&self) -> String{
        return self.abrv.clone()
    }

    #[allow(unused)]
    pub fn get_version(&self) -> String{
        return self.version.clone()
    }

    #[allow(unused)]
    pub fn get_members(&mut self) -> &mut Vec<ObjectMember>{
        return &mut self.members
    }

    pub fn push_object_member(&mut self, member: ObjectMember) {
        self.members.push(member);
    }
}

#[derive(Debug, Clone)]
pub struct ObjectMember {
    member_type: String,
    name: String,
    minversion: String,
    maxversion: String,
    enumerations: Vec<MemberEnumeration>,
}

impl ObjectMember {
    pub fn new(member_type: String, name: String, minversion: String, maxversion: String, enumerations: Vec<MemberEnumeration>) -> Self {
        Self { member_type, name, minversion, maxversion, enumerations }
    }

    pub fn get_name(&self) -> String{
        return self.name.clone()
    }

    #[allow(unused)]
    pub fn get_member_type(&self) -> String{
        return self.member_type.clone()
    }

    #[allow(unused)]
    pub fn get_minversion(&self) -> String{
        return self.minversion.clone()
    }

    #[allow(unused)]
    pub fn get_maxversion(&self) -> String{
        return self.maxversion.clone()
    }

    #[allow(unused)]
    pub fn get_enumerations(&mut self) -> &mut Vec<MemberEnumeration>{
        return &mut self.enumerations
    }

    #[allow(unused)]
    pub fn push_member_enumeration(&mut self, enumeration: MemberEnumeration) {
        self.enumerations.push(enumeration);
    }
}

#[derive(Debug, Clone)]
pub struct MemberEnumeration {
    name: String,
    default_value: String,
}

impl MemberEnumeration {
    pub fn new(name: String, default_value: String) -> Self {
        Self { name, default_value }
    }

    #[allow(unused)]
    pub fn get_name(&self) -> String{
        return self.name.clone()
    }

    #[allow(unused)]
    pub fn get_default_value(&self) -> String{
        return self.default_value.clone()
    }
}

#[derive(Debug)]
pub struct Messages {
    requests: Vec<String>,
    responses: Vec<String>,
    commands: Vec<String>,
    statuses: Vec<String>,
    streams: Vec<String>,
    error: String,
}

impl Messages {
    pub fn new(requests: Vec<String>, responses: Vec<String>, commands: Vec<String>, statuses: Vec<String>, streams: Vec<String>) -> Self {
        Self { requests, responses, commands, statuses, streams, error: String::from("") }
    }

    #[allow(unused)]
    pub fn get_requests(&self) -> Vec<String>{
        return self.requests.clone()
    }

    #[allow(unused)]
    pub fn get_responses(&self) -> Vec<String>{
        return self.responses.clone()
    }

    #[allow(unused)]
    pub fn get_commands(&self) -> Vec<String>{
        return self.commands.clone()
    }

    #[allow(unused)]
    pub fn get_statuses(&self) -> Vec<String>{
        return self.statuses.clone()
    }

    #[allow(unused)]
    pub fn get_streams(&self) -> Vec<String>{
        return self.streams.clone()
    }

    pub fn push(&mut self, message: Node<'_, '_>) {
        if let Some(t) = message.attribute_node("type") {
            let message_type = t.value();
            if MESSAGETYPE.contains_key(message_type) {
                if let Some(n) = message.attribute_node("name") {
                    let message_name = n.value();
                    match MESSAGETYPE.get_index(message_type).unwrap().to_string().as_str() {
                        "0" => self.requests.push(message_name.to_string()),
                        "1" => self.responses.push(message_name.to_string()),
                        "2" => self.commands.push(message_name.to_string()),
                        "3" => self.statuses.push(message_name.to_string()),
                        "4" => self.streams.push(message_name.to_string()),
                        _ => {
                            let error_position = format!("{}{}", "Error: Unrecognized message type at position ", n.position().to_string().as_str());
                            self.error.insert_str(0, error_position.as_str())
                        }
                    };
                }
                
            }
        }
    }
}