oca-bundle 2.0.0

Rust implementation of Overlays Capture Architecture bundle
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

use isolang::Language;
pub use oca_ast::ast::AttributeType;
use oca_ast::ast::{NestedAttrType, NestedValue};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

pub type OverlayName = String;
// use crate::state::{encoding::Encoding, entries::EntriesElement, entry_codes::EntryCodes};
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Attribute {
    pub name: String,
    #[serde(rename = "type")]
    pub attribute_type: Option<NestedAttrType>,
    pub properties: Option<HashMap<OverlayName, NestedValue>>,
}

impl Default for Attribute {
    fn default() -> Self {
        Self::new("".to_string())
    }
}

impl Attribute {
    pub fn new(name: String) -> Attribute {
        Attribute {
            name,
            attribute_type: None,
            properties: None,
        }
    }

    pub fn set_attribute_type(&mut self, attribute_type: NestedAttrType) {
        self.attribute_type = Some(attribute_type);
    }

    // Merge assumption is that if `other` is not None then it would overwrite `self` or would be concatenated with `self`
    pub fn merge(&mut self, other: &Attribute) {
        if self.name != other.name {
            panic!("Cannot merge attributes with different names");
        } else if other.attribute_type.is_some() {
            self.attribute_type.clone_from(&other.attribute_type);
        }
    }

    // fn merge_entries(&mut self, other: &Attribute) {
    //     if self.entries.is_none() {
    //         self.entries.clone_from(&other.entries);
    //     } else if let Some(entries) = &other.entries {
    //         for (lang, entry) in entries {
    //             self.entries.as_mut().unwrap().insert(*lang, entry.clone());
    //         }
    //     }
    // }
    //
    // fn merge_labels(&mut self, other: &Attribute) {
    //     if self.labels.is_none() {
    //         self.labels.clone_from(&other.labels)
    //     } else if let Some(labels) = &other.labels {
    //         for (lang, label) in labels {
    //             self.labels.as_mut().unwrap().insert(*lang, label.clone());
    //         }
    //     }
    // }

    // pub fn add_mapping(mut self, mapping: String) -> AttributeBuilder {
    //     self.attribute.mapping = Some(mapping);
    //     self
    // }

    // pub fn add_entry_codes_mapping(mut self, mapping: Vec<String>) -> AttributeBuilder {
    //     self.attribute.entry_codes_mapping = Some(mapping);
    //     self
    // }
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Entry {
    pub id: String,
    pub translations: HashMap<Language, String>,
}

impl Entry {
    pub fn new(id: String, translations: HashMap<Language, String>) -> Entry {
        Entry { id, translations }
    }
}

/*
#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum Entries {
    Sai(HashMap<Language, String>),
    Object(Vec<Entry>),
}
*/