Example #1
0
        protected virtual ARCHETYPE_ONTOLOGY CloneOntology(openehr.openehr.am.archetype.ontology.ARCHETYPE_ONTOLOGY o)
        {
            ARCHETYPE_ONTOLOGY result = new ARCHETYPE_ONTOLOGY();

            result.term_definitions       = CloneCodeDefinitions(o.term_definitions());
            result.term_bindings          = CloneTermBindingSet(o.term_bindings());
            result.constraint_definitions = CloneCodeDefinitions(o.constraint_definitions());
            result.constraint_bindings    = CloneConstraintBindingSet(o.constraint_bindings());

            return(result);
        }
Example #2
0
        ARCHETYPE_ONTOLOGY VisitOntology(ARCHETYPE_ONTOLOGY ontology)
        {
            ARCHETYPE_ONTOLOGY result = new ARCHETYPE_ONTOLOGY();

            // canonicalise ontology term_definitions
            result.term_definitions = VisitCodeDefinitions(ontology.term_definitions);

            // canonicalise ontology constraint_definitions
            result.constraint_definitions = VisitCodeDefinitions(ontology.constraint_definitions);

            // canonicalise ontology term_bindings
            result.term_bindings = VisitTermBindings(ontology.term_bindings);

            // canonicalise ontology constraint_bindings
            result.constraint_bindings = VisitConstraintBindings(ontology.constraint_bindings);

            return(result);
        }
Example #3
0
        public static ArchetypeOntology Map(this ARCHETYPE_ONTOLOGY model)
        {
            var ontology = new ArchetypeOntology();

            //TermDefinitions
            if (model.term_definitions != null)
            {
                foreach (CodeDefinitionSet definition in model.term_definitions)
                {
                    var itemlist = new List <ArchetypeTerminology>();
                    foreach (ARCHETYPE_TERM item in definition.items)
                    {
                        var archetypeTerminology = new ArchetypeTerminology
                        {
                            Code = item.code
                        };
                        foreach (StringDictionaryItem item2 in item.items)
                        {
                            archetypeTerminology.Items.Add(item2.id, item2.TypedValue);
                        }
                        itemlist.Add(archetypeTerminology);
                    }
                    ontology.TerminologyDefinitions.Add(definition.language, itemlist);
                }
            }

            //TermBindings
            if (model.term_bindings != null)
            {
                foreach (TermBindingSet bindingSet in model.term_bindings)
                {
                    Dictionary <string, CodePhrase> items = bindingSet.items.ToDictionary(item => item.code,
                                                                                          item => item.value.Map());
                    ontology.TerminologyBindings.Add(bindingSet.terminology, items);
                }
            }

            //ConstraintDefinitions
            if (model.constraint_definitions != null)
            {
                foreach (CodeDefinitionSet definition in model.constraint_definitions)
                {
                    var itemlist = new List <ArchetypeTerminology>();
                    foreach (ARCHETYPE_TERM item in definition.items)
                    {
                        var archetypeTerminology = new ArchetypeTerminology
                        {
                            Code = item.code
                        };
                        foreach (StringDictionaryItem item2 in item.items)
                        {
                            archetypeTerminology.Items.Add(item2.id, item2.TypedValue);
                        }
                        itemlist.Add(archetypeTerminology);
                    }
                    ontology.ConstraintDefinitions.Add(definition.language, itemlist);
                }
            }

            //ConstraintBindings
            if (model.constraint_bindings != null && model.constraint_bindings.Count > 0)
            {
                throw new NotImplementedException();
            }

            return(ontology);
        }