Esempio n. 1
0
        /// <summary>
        /// Checks if the skos:narrower/skos:narrowerTransitive/skos:narrowMatch relation can be added to the given aConcept with the given bConcept
        /// </summary>
        internal static Boolean CheckNarrowerRelation(RDFSKOSConceptScheme conceptScheme,
                                                      RDFSKOSConcept aConcept,
                                                      RDFSKOSConcept bConcept)
        {
            var canAddNarrowerRel = false;

            //Avoid clash with hierarchical relations
            canAddNarrowerRel = !conceptScheme.CheckHasBroaderConcept(aConcept, bConcept);

            //Avoid clash with associative relations
            if (canAddNarrowerRel)
            {
                canAddNarrowerRel = !conceptScheme.CheckHasRelatedConcept(aConcept, bConcept);
            }

            //Avoid clash with mapping relations
            if (canAddNarrowerRel)
            {
                canAddNarrowerRel = (!conceptScheme.CheckHasBroadMatchConcept(aConcept, bConcept) &&
                                     !conceptScheme.CheckHasCloseMatchConcept(aConcept, bConcept) &&
                                     !conceptScheme.CheckHasExactMatchConcept(aConcept, bConcept) &&
                                     !conceptScheme.CheckHasRelatedMatchConcept(aConcept, bConcept));
            }

            return(canAddNarrowerRel);
        }
Esempio n. 2
0
        /// <summary>
        /// Checks if the skos:hiddenLabel/skosxl:hiddenLabel informations can be added to the given concept
        /// </summary>
        internal static Boolean CheckHiddenLabel(RDFSKOSConceptScheme conceptScheme,
                                                 RDFOntologyFact concept,
                                                 RDFOntologyLiteral literal)
        {
            var canAddHiddenLabelInfo = false;

            //Pairwise disjointness with skos:prefLabel/skosxl:prefLabel must be preserved
            canAddHiddenLabelInfo = !(conceptScheme.Annotations.PrefLabel.SelectEntriesBySubject(concept)
                                      .Any(x => x.TaxonomyObject.Equals(literal)));

            if (canAddHiddenLabelInfo)
            {
                canAddHiddenLabelInfo = !(conceptScheme.Relations.PrefLabel.SelectEntriesBySubject(concept)
                                          .Any(x => conceptScheme.Relations.LiteralForm.SelectEntriesBySubject(x.TaxonomyObject)
                                               .Any(y => y.TaxonomyObject.Equals(literal))));
            }

            //Pairwise disjointness with skos:altLabel/skosxl:altLabel must be preserved
            if (canAddHiddenLabelInfo)
            {
                canAddHiddenLabelInfo = !(conceptScheme.Annotations.AltLabel.SelectEntriesBySubject(concept)
                                          .Any(x => x.TaxonomyObject.Equals(literal)));
            }

            if (canAddHiddenLabelInfo)
            {
                canAddHiddenLabelInfo = !(conceptScheme.Relations.AltLabel.SelectEntriesBySubject(concept)
                                          .Any(x => conceptScheme.Relations.LiteralForm.SelectEntriesBySubject(x.TaxonomyObject)
                                               .Any(y => y.TaxonomyObject.Equals(literal))));
            }

            return(canAddHiddenLabelInfo);
        }
        /// <summary>
        /// Builds a new difference scheme from this scheme and a given one
        /// </summary>
        public RDFSKOSConceptScheme DifferenceWith(RDFSKOSConceptScheme conceptScheme)
        {
            var result = new RDFSKOSConceptScheme(new RDFResource());

            if (conceptScheme != null)
            {
                //Add difference concepts
                foreach (var c in this)
                {
                    if (!conceptScheme.Concepts.ContainsKey(c.PatternMemberID))
                    {
                        result.AddConcept(c);
                    }
                }

                //Add difference collections
                foreach (var c in this.Collections.Values)
                {
                    if (!conceptScheme.Collections.ContainsKey(c.PatternMemberID))
                    {
                        result.AddCollection(c);
                    }
                }

                //Add difference ordered collections
                foreach (var o in this.OrderedCollections.Values)
                {
                    if (!conceptScheme.OrderedCollections.ContainsKey(o.PatternMemberID))
                    {
                        result.AddOrderedCollection(o);
                    }
                }

                //Add difference labels
                foreach (var l in this.Labels.Values)
                {
                    if (!conceptScheme.Labels.ContainsKey(l.PatternMemberID))
                    {
                        result.AddLabel(l);
                    }
                }

                //Add difference relations
                result.Relations.TopConcept         = this.Relations.TopConcept.DifferenceWith(conceptScheme.Relations.TopConcept);
                result.Relations.Broader            = this.Relations.Broader.DifferenceWith(conceptScheme.Relations.Broader);
                result.Relations.BroaderTransitive  = this.Relations.BroaderTransitive.DifferenceWith(conceptScheme.Relations.BroaderTransitive);
                result.Relations.BroadMatch         = this.Relations.BroadMatch.DifferenceWith(conceptScheme.Relations.BroadMatch);
                result.Relations.Narrower           = this.Relations.Narrower.DifferenceWith(conceptScheme.Relations.Narrower);
                result.Relations.NarrowerTransitive = this.Relations.NarrowerTransitive.DifferenceWith(conceptScheme.Relations.NarrowerTransitive);
                result.Relations.NarrowMatch        = this.Relations.NarrowMatch.DifferenceWith(conceptScheme.Relations.NarrowMatch);
                result.Relations.Related            = this.Relations.Related.DifferenceWith(conceptScheme.Relations.Related);
                result.Relations.RelatedMatch       = this.Relations.RelatedMatch.DifferenceWith(conceptScheme.Relations.RelatedMatch);
                result.Relations.SemanticRelation   = this.Relations.SemanticRelation.DifferenceWith(conceptScheme.Relations.SemanticRelation);
                result.Relations.MappingRelation    = this.Relations.MappingRelation.DifferenceWith(conceptScheme.Relations.MappingRelation);
                result.Relations.CloseMatch         = this.Relations.CloseMatch.DifferenceWith(conceptScheme.Relations.CloseMatch);
                result.Relations.ExactMatch         = this.Relations.ExactMatch.DifferenceWith(conceptScheme.Relations.ExactMatch);
                result.Relations.Notation           = this.Relations.Notation.DifferenceWith(conceptScheme.Relations.Notation);
                result.Relations.PrefLabel          = this.Relations.PrefLabel.DifferenceWith(conceptScheme.Relations.PrefLabel);
                result.Relations.AltLabel           = this.Relations.AltLabel.DifferenceWith(conceptScheme.Relations.AltLabel);
                result.Relations.HiddenLabel        = this.Relations.HiddenLabel.DifferenceWith(conceptScheme.Relations.HiddenLabel);
                result.Relations.LiteralForm        = this.Relations.LiteralForm.DifferenceWith(conceptScheme.Relations.LiteralForm);
                result.Relations.LabelRelation      = this.Relations.LabelRelation.DifferenceWith(conceptScheme.Relations.LabelRelation);

                //Add difference annotations
                result.Annotations.PrefLabel     = this.Annotations.PrefLabel.DifferenceWith(conceptScheme.Annotations.PrefLabel);
                result.Annotations.AltLabel      = this.Annotations.AltLabel.DifferenceWith(conceptScheme.Annotations.AltLabel);
                result.Annotations.HiddenLabel   = this.Annotations.HiddenLabel.DifferenceWith(conceptScheme.Annotations.HiddenLabel);
                result.Annotations.Note          = this.Annotations.Note.DifferenceWith(conceptScheme.Annotations.Note);
                result.Annotations.ChangeNote    = this.Annotations.ChangeNote.DifferenceWith(conceptScheme.Annotations.ChangeNote);
                result.Annotations.EditorialNote = this.Annotations.EditorialNote.DifferenceWith(conceptScheme.Annotations.EditorialNote);
                result.Annotations.HistoryNote   = this.Annotations.HistoryNote.DifferenceWith(conceptScheme.Annotations.HistoryNote);
                result.Annotations.ScopeNote     = this.Annotations.ScopeNote.DifferenceWith(conceptScheme.Annotations.ScopeNote);
                result.Annotations.Definition    = this.Annotations.Definition.DifferenceWith(conceptScheme.Annotations.Definition);
                result.Annotations.Example       = this.Annotations.Example.DifferenceWith(conceptScheme.Annotations.Example);
            }
            else
            {
                //Add concepts from this scheme
                foreach (var c in this)
                {
                    result.AddConcept(c);
                }

                //Add collections from this scheme
                foreach (var c in this.Collections.Values)
                {
                    result.AddCollection(c);
                }

                //Add ordered collections from this scheme
                foreach (var o in this.OrderedCollections.Values)
                {
                    result.AddOrderedCollection(o);
                }

                //Add labels from this scheme
                foreach (var l in this.Labels.Values)
                {
                    result.AddLabel(l);
                }

                //Add relations from this scheme
                result.Relations.TopConcept         = result.Relations.TopConcept.UnionWith(this.Relations.TopConcept);
                result.Relations.Broader            = result.Relations.Broader.UnionWith(this.Relations.Broader);
                result.Relations.BroaderTransitive  = result.Relations.BroaderTransitive.UnionWith(this.Relations.BroaderTransitive);
                result.Relations.BroadMatch         = result.Relations.BroadMatch.UnionWith(this.Relations.BroadMatch);
                result.Relations.Narrower           = result.Relations.Narrower.UnionWith(this.Relations.Narrower);
                result.Relations.NarrowerTransitive = result.Relations.NarrowerTransitive.UnionWith(this.Relations.NarrowerTransitive);
                result.Relations.NarrowMatch        = result.Relations.NarrowMatch.UnionWith(this.Relations.NarrowMatch);
                result.Relations.Related            = result.Relations.Related.UnionWith(this.Relations.Related);
                result.Relations.RelatedMatch       = result.Relations.RelatedMatch.UnionWith(this.Relations.RelatedMatch);
                result.Relations.SemanticRelation   = result.Relations.SemanticRelation.UnionWith(this.Relations.SemanticRelation);
                result.Relations.MappingRelation    = result.Relations.MappingRelation.UnionWith(this.Relations.MappingRelation);
                result.Relations.CloseMatch         = result.Relations.CloseMatch.UnionWith(this.Relations.CloseMatch);
                result.Relations.ExactMatch         = result.Relations.ExactMatch.UnionWith(this.Relations.ExactMatch);
                result.Relations.Notation           = result.Relations.Notation.UnionWith(this.Relations.Notation);
                result.Relations.PrefLabel          = result.Relations.PrefLabel.UnionWith(this.Relations.PrefLabel);
                result.Relations.AltLabel           = result.Relations.AltLabel.UnionWith(this.Relations.AltLabel);
                result.Relations.HiddenLabel        = result.Relations.HiddenLabel.UnionWith(this.Relations.HiddenLabel);
                result.Relations.LiteralForm        = result.Relations.LiteralForm.UnionWith(this.Relations.LiteralForm);
                result.Relations.LabelRelation      = result.Relations.LabelRelation.UnionWith(this.Relations.LabelRelation);

                //Add annotations from this scheme
                result.Annotations.PrefLabel     = result.Annotations.PrefLabel.UnionWith(this.Annotations.PrefLabel);
                result.Annotations.AltLabel      = result.Annotations.AltLabel.UnionWith(this.Annotations.AltLabel);
                result.Annotations.HiddenLabel   = result.Annotations.HiddenLabel.UnionWith(this.Annotations.HiddenLabel);
                result.Annotations.Note          = result.Annotations.Note.UnionWith(this.Annotations.Note);
                result.Annotations.ChangeNote    = result.Annotations.ChangeNote.UnionWith(this.Annotations.ChangeNote);
                result.Annotations.EditorialNote = result.Annotations.EditorialNote.UnionWith(this.Annotations.EditorialNote);
                result.Annotations.HistoryNote   = result.Annotations.HistoryNote.UnionWith(this.Annotations.HistoryNote);
                result.Annotations.ScopeNote     = result.Annotations.ScopeNote.UnionWith(this.Annotations.ScopeNote);
                result.Annotations.Definition    = result.Annotations.Definition.UnionWith(this.Annotations.Definition);
                result.Annotations.Example       = result.Annotations.Example.UnionWith(this.Annotations.Example);
            }
            return(result);
        }
Esempio n. 4
0
        /// <summary>
        /// Checks if the skos:prefLabel/skosxl:prefLabel informations can be added to the given concept
        /// </summary>
        internal static Boolean CheckPrefLabel(RDFSKOSConceptScheme conceptScheme,
                                               RDFOntologyFact concept,
                                               RDFOntologyLiteral literal)
        {
            var canAddPrefLabelInfo  = false;
            var prefLabelLiteralLang = ((RDFPlainLiteral)literal.Value).Language;

            //Plain literal without language tag: only one occurrence of this information is allowed
            if (String.IsNullOrEmpty(prefLabelLiteralLang))
            {
                //Check skos:prefLabel annotation
                canAddPrefLabelInfo = !(conceptScheme.Annotations.PrefLabel.SelectEntriesBySubject(concept)
                                        .Any(x => x.TaxonomyObject.Value is RDFPlainLiteral &&
                                             String.IsNullOrEmpty(((RDFPlainLiteral)x.TaxonomyObject.Value).Language)));
                //Check skosxl:prefLabel relation
                if (canAddPrefLabelInfo)
                {
                    canAddPrefLabelInfo = !(conceptScheme.Relations.PrefLabel.SelectEntriesBySubject(concept)
                                            .Any(x => conceptScheme.Relations.LiteralForm.SelectEntriesBySubject(x.TaxonomyObject)
                                                 .Any(y => y.TaxonomyObject.Value is RDFPlainLiteral &&
                                                      String.IsNullOrEmpty(((RDFPlainLiteral)y.TaxonomyObject.Value).Language))));
                }
            }

            //Plain literal with language tag: only one occurrence of this information per language tag is allowed
            else
            {
                //Check skos:prefLabel annotation
                canAddPrefLabelInfo = !(conceptScheme.Annotations.PrefLabel.SelectEntriesBySubject(concept)
                                        .Any(x => x.TaxonomyObject.Value is RDFPlainLiteral &&
                                             !String.IsNullOrEmpty(((RDFPlainLiteral)x.TaxonomyObject.Value).Language) &&
                                             (((RDFPlainLiteral)x.TaxonomyObject.Value).Language).Equals(prefLabelLiteralLang, StringComparison.OrdinalIgnoreCase)));

                //Check skosxl:prefLabel relation
                if (canAddPrefLabelInfo)
                {
                    canAddPrefLabelInfo = !(conceptScheme.Relations.PrefLabel.SelectEntriesBySubject(concept)
                                            .Any(x => conceptScheme.Relations.LiteralForm.SelectEntriesBySubject(x.TaxonomyObject)
                                                 .Any(y => y.TaxonomyObject.Value is RDFPlainLiteral &&
                                                      !String.IsNullOrEmpty(((RDFPlainLiteral)x.TaxonomyObject.Value).Language) &&
                                                      (((RDFPlainLiteral)x.TaxonomyObject.Value).Language).Equals(prefLabelLiteralLang, StringComparison.OrdinalIgnoreCase))));
                }
            }

            //Pairwise disjointness with skos:altLabel/skosxl:altLabel must be preserved
            if (canAddPrefLabelInfo)
            {
                //Check skos:altLabel annotation
                canAddPrefLabelInfo = !(conceptScheme.Annotations.AltLabel.SelectEntriesBySubject(concept)
                                        .Any(x => x.TaxonomyObject.Equals(literal)));

                //Check skosxl:altLabel relation
                if (canAddPrefLabelInfo)
                {
                    canAddPrefLabelInfo = !(conceptScheme.Relations.AltLabel.SelectEntriesBySubject(concept)
                                            .Any(x => conceptScheme.Relations.LiteralForm.SelectEntriesBySubject(x.TaxonomyObject)
                                                 .Any(y => y.TaxonomyObject.Equals(literal))));
                }
            }

            //Pairwise disjointness with skos:hiddenLabel/skosxl:hiddenLabel must be preserved
            if (canAddPrefLabelInfo)
            {
                //Check skos:hiddenLabel annotation
                canAddPrefLabelInfo = !(conceptScheme.Annotations.HiddenLabel.SelectEntriesBySubject(concept)
                                        .Any(x => x.TaxonomyObject.Equals(literal)));

                //Check skosxl:hiddenLabel assertion
                if (canAddPrefLabelInfo)
                {
                    canAddPrefLabelInfo = !(conceptScheme.Relations.HiddenLabel.SelectEntriesBySubject(concept)
                                            .Any(x => conceptScheme.Relations.LiteralForm.SelectEntriesBySubject(x.TaxonomyObject)
                                                 .Any(y => y.TaxonomyObject.Equals(literal))));
                }
            }

            return(canAddPrefLabelInfo);
        }
        /// <summary>
        /// Builds a new union scheme from this scheme and a given one
        /// </summary>
        public RDFSKOSConceptScheme UnionWith(RDFSKOSConceptScheme conceptScheme)
        {
            var result = new RDFSKOSConceptScheme(new RDFResource());

            //Add concepts from this scheme
            foreach (var c    in this)
            {
                result.AddConcept(c);
            }

            //Add collections from this scheme
            foreach (var c    in this.Collections.Values)
            {
                result.AddCollection(c);
            }

            //Add ordered collections from this scheme
            foreach (var o    in this.OrderedCollections.Values)
            {
                result.AddOrderedCollection(o);
            }

            //Add labels from this scheme
            foreach (var l    in this.Labels.Values)
            {
                result.AddLabel(l);
            }

            //Add relations from this scheme
            result.Relations.TopConcept         = result.Relations.TopConcept.UnionWith(this.Relations.TopConcept);
            result.Relations.Broader            = result.Relations.Broader.UnionWith(this.Relations.Broader);
            result.Relations.BroaderTransitive  = result.Relations.BroaderTransitive.UnionWith(this.Relations.BroaderTransitive);
            result.Relations.BroadMatch         = result.Relations.BroadMatch.UnionWith(this.Relations.BroadMatch);
            result.Relations.Narrower           = result.Relations.Narrower.UnionWith(this.Relations.Narrower);
            result.Relations.NarrowerTransitive = result.Relations.NarrowerTransitive.UnionWith(this.Relations.NarrowerTransitive);
            result.Relations.NarrowMatch        = result.Relations.NarrowMatch.UnionWith(this.Relations.NarrowMatch);
            result.Relations.Related            = result.Relations.Related.UnionWith(this.Relations.Related);
            result.Relations.RelatedMatch       = result.Relations.RelatedMatch.UnionWith(this.Relations.RelatedMatch);
            result.Relations.SemanticRelation   = result.Relations.SemanticRelation.UnionWith(this.Relations.SemanticRelation);
            result.Relations.MappingRelation    = result.Relations.MappingRelation.UnionWith(this.Relations.MappingRelation);
            result.Relations.CloseMatch         = result.Relations.CloseMatch.UnionWith(this.Relations.CloseMatch);
            result.Relations.ExactMatch         = result.Relations.ExactMatch.UnionWith(this.Relations.ExactMatch);
            result.Relations.Notation           = result.Relations.Notation.UnionWith(this.Relations.Notation);
            result.Relations.PrefLabel          = result.Relations.PrefLabel.UnionWith(this.Relations.PrefLabel);
            result.Relations.AltLabel           = result.Relations.AltLabel.UnionWith(this.Relations.AltLabel);
            result.Relations.HiddenLabel        = result.Relations.HiddenLabel.UnionWith(this.Relations.HiddenLabel);
            result.Relations.LiteralForm        = result.Relations.LiteralForm.UnionWith(this.Relations.LiteralForm);
            result.Relations.LabelRelation      = result.Relations.LabelRelation.UnionWith(this.Relations.LabelRelation);

            //Add annotations from this scheme
            result.Annotations.PrefLabel     = result.Annotations.PrefLabel.UnionWith(this.Annotations.PrefLabel);
            result.Annotations.AltLabel      = result.Annotations.AltLabel.UnionWith(this.Annotations.AltLabel);
            result.Annotations.HiddenLabel   = result.Annotations.HiddenLabel.UnionWith(this.Annotations.HiddenLabel);
            result.Annotations.Note          = result.Annotations.Note.UnionWith(this.Annotations.Note);
            result.Annotations.ChangeNote    = result.Annotations.ChangeNote.UnionWith(this.Annotations.ChangeNote);
            result.Annotations.EditorialNote = result.Annotations.EditorialNote.UnionWith(this.Annotations.EditorialNote);
            result.Annotations.HistoryNote   = result.Annotations.HistoryNote.UnionWith(this.Annotations.HistoryNote);
            result.Annotations.ScopeNote     = result.Annotations.ScopeNote.UnionWith(this.Annotations.ScopeNote);
            result.Annotations.Definition    = result.Annotations.Definition.UnionWith(this.Annotations.Definition);
            result.Annotations.Example       = result.Annotations.Example.UnionWith(this.Annotations.Example);

            //Manage the given scheme
            if (conceptScheme != null)
            {
                //Add concepts from the given scheme
                foreach (var c in conceptScheme)
                {
                    result.AddConcept(c);
                }

                //Add collections from the given scheme
                foreach (var c in conceptScheme.Collections.Values)
                {
                    result.AddCollection(c);
                }

                //Add ordered collections from the given scheme
                foreach (var o in conceptScheme.OrderedCollections.Values)
                {
                    result.AddOrderedCollection(o);
                }

                //Add labels from the given scheme
                foreach (var l in conceptScheme.Labels.Values)
                {
                    result.AddLabel(l);
                }

                //Add relations from the given scheme
                result.Relations.TopConcept         = result.Relations.TopConcept.UnionWith(conceptScheme.Relations.TopConcept);
                result.Relations.Broader            = result.Relations.Broader.UnionWith(conceptScheme.Relations.Broader);
                result.Relations.BroaderTransitive  = result.Relations.BroaderTransitive.UnionWith(conceptScheme.Relations.BroaderTransitive);
                result.Relations.BroadMatch         = result.Relations.BroadMatch.UnionWith(conceptScheme.Relations.BroadMatch);
                result.Relations.Narrower           = result.Relations.Narrower.UnionWith(conceptScheme.Relations.Narrower);
                result.Relations.NarrowerTransitive = result.Relations.NarrowerTransitive.UnionWith(conceptScheme.Relations.NarrowerTransitive);
                result.Relations.NarrowMatch        = result.Relations.NarrowMatch.UnionWith(conceptScheme.Relations.NarrowMatch);
                result.Relations.Related            = result.Relations.Related.UnionWith(conceptScheme.Relations.Related);
                result.Relations.RelatedMatch       = result.Relations.RelatedMatch.UnionWith(conceptScheme.Relations.RelatedMatch);
                result.Relations.SemanticRelation   = result.Relations.SemanticRelation.UnionWith(conceptScheme.Relations.SemanticRelation);
                result.Relations.MappingRelation    = result.Relations.MappingRelation.UnionWith(conceptScheme.Relations.MappingRelation);
                result.Relations.CloseMatch         = result.Relations.CloseMatch.UnionWith(conceptScheme.Relations.CloseMatch);
                result.Relations.ExactMatch         = result.Relations.ExactMatch.UnionWith(conceptScheme.Relations.ExactMatch);
                result.Relations.Notation           = result.Relations.Notation.UnionWith(conceptScheme.Relations.Notation);
                result.Relations.PrefLabel          = result.Relations.PrefLabel.UnionWith(conceptScheme.Relations.PrefLabel);
                result.Relations.AltLabel           = result.Relations.AltLabel.UnionWith(conceptScheme.Relations.AltLabel);
                result.Relations.HiddenLabel        = result.Relations.HiddenLabel.UnionWith(conceptScheme.Relations.HiddenLabel);
                result.Relations.LiteralForm        = result.Relations.LiteralForm.UnionWith(conceptScheme.Relations.LiteralForm);
                result.Relations.LabelRelation      = result.Relations.LabelRelation.UnionWith(conceptScheme.Relations.LabelRelation);

                //Add annotations from the given scheme
                result.Annotations.PrefLabel     = result.Annotations.PrefLabel.UnionWith(conceptScheme.Annotations.PrefLabel);
                result.Annotations.AltLabel      = result.Annotations.AltLabel.UnionWith(conceptScheme.Annotations.AltLabel);
                result.Annotations.HiddenLabel   = result.Annotations.HiddenLabel.UnionWith(conceptScheme.Annotations.HiddenLabel);
                result.Annotations.Note          = result.Annotations.Note.UnionWith(conceptScheme.Annotations.Note);
                result.Annotations.ChangeNote    = result.Annotations.ChangeNote.UnionWith(conceptScheme.Annotations.ChangeNote);
                result.Annotations.EditorialNote = result.Annotations.EditorialNote.UnionWith(conceptScheme.Annotations.EditorialNote);
                result.Annotations.HistoryNote   = result.Annotations.HistoryNote.UnionWith(conceptScheme.Annotations.HistoryNote);
                result.Annotations.ScopeNote     = result.Annotations.ScopeNote.UnionWith(conceptScheme.Annotations.ScopeNote);
                result.Annotations.Definition    = result.Annotations.Definition.UnionWith(conceptScheme.Annotations.Definition);
                result.Annotations.Example       = result.Annotations.Example.UnionWith(conceptScheme.Annotations.Example);
            }
            return(result);
        }