Right now this is the approach that I am adopting for storing the entities, using just IfcDirection as example but can be applied for all entities.

Instead of a generic struct, I'm defining the data as a HashMap with the data index as the key and a Box<dyn trait> as the value. This allows us to store any kind of Struct that has this trait.

use log::debug;
use std::collections::HashMap;

#[derive(Debug, PartialEq, Eq, Clone)]
pub struct ParseError;

pub trait IfcDataOps {
    fn parse(s: &str) -> Result<Self, ParseError>
    where
        Self: Sized;
}

#[derive(Default)]
pub struct Model {
    data: HashMap<usize, Box<dyn IfcDataOps>>,
}

impl Model {
    pub fn open(file_path: &str) -> Model {
        let mut model = Model {
            data: HashMap::new(),
        };

        let contents = std::fs::read_to_string(file_path)
            .expect(format!("File path, {}, not available.", file_path).as_str());

        let lines: Vec<&str> = contents.split("\n").collect();

        for line in lines.iter() {
            if line.contains("=IFCDIRECTION(") {
                if let Ok(direction) = IfcDirection::parse(line) {
                    debug!("Parsed {:?}", direction);
                    model.data.insert(direction.id, Box::new(direction));
                }
            }
        }

        return model;
    }
}

#[derive(Debug)]
pub struct IfcDirection {
    id: usize,
    x: f32,
    y: f32,
    z: Option<f32>,
}

impl IfcDataOps for IfcDirection {
    fn parse(s: &str) -> Result<Self, ParseError> {
        let id = s[1..s.find("=").unwrap_or(s.len())]
            .parse::<usize>()
            .unwrap();

        let s = &s[s.find("((").unwrap_or(s.len()) + 2..s.len()];
        let s = &s[0..s.find("));").unwrap_or(s.len())];
        let mut coordinates = Vec::new();
        for (_, value) in s.split(",").enumerate() {
            coordinates.push(value.parse::<f32>().unwrap());
        }
        if coordinates.len() == 2 {
            return Ok(IfcDirection {
                id,
                x: coordinates[0],
                y: coordinates[1],
                z: None,
            });
        } else {
            return Ok(IfcDirection {
                id,
                x: coordinates[0],
                y: coordinates[1],
                z: Some(coordinates[2]),
            });
        }
    }
}

While programming, I want to make good use of some of the functions in Rust, such as using Option<> to define optional attributes and clever use of Results<> to control the workflow.

Sunbelt Computer Software

PL/B Language Development and Support

Uh oh!

Uh oh!

Rust support #4266

Description

Metadata

Metadata

Assignees

Labels

Type

Fields

Projects

Milestone

Relationships

Development

Issue actions