Struct oca_rust::state::oca::overlay::entry_code_mapping::EntryCodeMappingOverlay

source ·

pub struct EntryCodeMappingOverlay {
    pub attribute_entry_codes_mapping: BTreeMap<String, Vec<String>>,
    /* private fields */
}

Fields§

§attribute_entry_codes_mapping: BTreeMap<String, Vec<String>>

Implementations§

source §

impl EntryCodeMappingOverlay

source

pub fn new() -> Box<EntryCodeMappingOverlay>

Examples found in repository ?

src/state/oca.rs (line 626)

    pub fn add_attribute(mut self, attr: Attribute) -> OCABuilder {
        self.oca.capture_base.add(&attr);

        if attr.mapping.is_some() {
            let mut attribute_mapping_ov = self
                .oca
                .overlays
                .iter_mut()
                .find(|x| x.overlay_type().contains("/mapping/"));
            if attribute_mapping_ov.is_none() {
                self.oca.overlays.push(overlay::AttributeMapping::new());
                attribute_mapping_ov = self.oca.overlays.last_mut();
            }

            if let Some(ov) = attribute_mapping_ov {
                ov.add(&attr)
            }
        }

        if attr.condition.is_some() {
            let mut conditional_ov = self
                .oca
                .overlays
                .iter_mut()
                .find(|x| x.overlay_type().contains("/conditional/"));
            if conditional_ov.is_none() {
                self.oca.overlays.push(overlay::Conditional::new());
                conditional_ov = self.oca.overlays.last_mut();
            }
            if let Some(ov) = conditional_ov {
                ov.add(&attr);
            }
        }

        if attr.cardinality.is_some() {
            let mut cardinality_ov = self
                .oca
                .overlays
                .iter_mut()
                .find(|x| x.overlay_type().contains("/cardinality/"));
            if cardinality_ov.is_none() {
                self.oca.overlays.push(overlay::Cardinality::new());
                cardinality_ov = self.oca.overlays.last_mut();
            }

            if let Some(ov) = cardinality_ov {
                ov.add(&attr)
            }
        }

        if attr.conformance.is_some() {
            let mut conformance_ov = self
                .oca
                .overlays
                .iter_mut()
                .find(|x| x.overlay_type().contains("/conformance/"));
            if conformance_ov.is_none() {
                self.oca.overlays.push(overlay::Conformance::new());
                conformance_ov = self.oca.overlays.last_mut();
            }

            if let Some(ov) = conformance_ov {
                ov.add(&attr)
            }
        }

        if attr.encoding.is_some() {
            let encoding_ov = self
                .oca
                .overlays
                .iter_mut()
                .find(|x| x.overlay_type().contains("/character_encoding/"));
            if let Some(ov) = encoding_ov {
                ov.add(&attr);
            }
        }

        if attr.format.is_some() {
            let mut format_ov = self
                .oca
                .overlays
                .iter_mut()
                .find(|x| x.overlay_type().contains("/format/"));
            if format_ov.is_none() {
                self.oca.overlays.push(overlay::Format::new());
                format_ov = self.oca.overlays.last_mut();
            }

            if let Some(ov) = format_ov {
                ov.add(&attr)
            }
        }

        if attr.unit.is_some() {
            let mut unit_ov = self.oca.overlays.iter_mut().find(|x| {
                if let Some(o_metric_system) = x.metric_system() {
                    return o_metric_system == attr.metric_system.as_ref().unwrap()
                        && x.overlay_type().contains("/unit/");
                }
                false
            });
            if unit_ov.is_none() {
                self.oca.overlays.push(overlay::Unit::new(
                    attr.metric_system.as_ref().unwrap().clone(),
                ));
                unit_ov = self.oca.overlays.last_mut();
            }

            if let Some(ov) = unit_ov {
                ov.add(&attr)
            }
        }

        if attr.entry_codes.is_some() {
            let mut entry_code_ov = self
                .oca
                .overlays
                .iter_mut()
                .find(|x| x.overlay_type().contains("/entry_code/"));
            if entry_code_ov.is_none() {
                self.oca.overlays.push(overlay::EntryCode::new());
                entry_code_ov = self.oca.overlays.last_mut();
            }

            if let Some(ov) = entry_code_ov {
                ov.add(&attr)
            }
        }

        if attr.entry_codes_mapping.is_some() {
            let mut entry_code_mapping_ov = self
                .oca
                .overlays
                .iter_mut()
                .find(|x| x.overlay_type().contains("/entry_code_mapping/"));
            if entry_code_mapping_ov.is_none() {
                self.oca.overlays.push(overlay::EntryCodeMapping::new());
                entry_code_mapping_ov = self.oca.overlays.last_mut();
            }

            if let Some(ov) = entry_code_mapping_ov {
                ov.add(&attr)
            }
        }

        if !attr.translations.is_empty() {
            if self.cat_attributes.lang.is_empty() {
                self.cat_attributes.lang = attr.translations.keys().next().unwrap().clone();
            }
            let attr_tr = attr.translations.get(&self.cat_attributes.lang).unwrap();
            if let Some(value) = &attr_tr.label {
                let mut splitted = value.split('|').collect::<Vec<&str>>();
                splitted.pop();
                self.cat_attributes
                    .add_to_category(splitted, attr.name.clone(), attr.sai.clone());
            }
            for (lang, attr_tr) in attr.translations.iter() {
                let mut label_ov = self.oca.overlays.iter_mut().find(|x| {
                    if let Some(o_lang) = x.language() {
                        return o_lang == lang && x.overlay_type().contains("/label/");
                    }
                    false
                });
                if label_ov.is_none() {
                    self.oca
                        .overlays
                        .push(overlay::Label::new(lang.to_string()));
                    label_ov = self.oca.overlays.last_mut();
                }
                if let Some(ov) = label_ov {
                    ov.add(&attr);
                }

                if attr_tr.information.is_some() {
                    let mut information_ov = self.oca.overlays.iter_mut().find(|x| {
                        if let Some(o_lang) = x.language() {
                            return o_lang == lang && x.overlay_type().contains("/information/");
                        }
                        false
                    });
                    if information_ov.is_none() {
                        self.oca
                            .overlays
                            .push(overlay::Information::new(lang.to_string()));
                        information_ov = self.oca.overlays.last_mut();
                    }
                    if let Some(ov) = information_ov {
                        ov.add(&attr);
                    }
                }

                if attr_tr.entries.is_some() {
                    let mut entry_ov = self.oca.overlays.iter_mut().find(|x| {
                        if let Some(o_lang) = x.language() {
                            return o_lang == lang && x.overlay_type().contains("/entry/");
                        }
                        false
                    });
                    if entry_ov.is_none() {
                        self.oca
                            .overlays
                            .push(overlay::Entry::new(lang.to_string()));
                        entry_ov = self.oca.overlays.last_mut();
                    }
                    if let Some(ov) = entry_ov {
                        ov.add(&attr);
                    }
                }
            }
        }
        self
    }