Пример #1
0
        /// <summary>
        /// Get all embedded proto elements for the given element.
        /// </summary>
        /// <param name="partition">Partition.</param>
        /// <param name="protoElement">Proto element to get all embedded elements for.</param>
        /// <returns>List of embedded proto elements.</returns>
        public List <ModelProtoElement> GetEmbeddedElements(Partition partition, ModelProtoElement protoElement)
        {
            List <ModelProtoElement> elements;

            this.embeddingMapping.TryGetValue(protoElement.ElementId, out elements);
            return(elements);
        }
Пример #2
0
        public List <ModelProtoLink> GetReferenceLinksTarget(Partition partition, ModelProtoElement protoElement)
        {
            List <ModelProtoLink> elements;

            this.referencingMappingTarget.TryGetValue(protoElement.ElementId, out elements);
            return(elements);
        }
Пример #3
0
 /// <summary>
 /// Adds a proto element to the proto elements collection.
 /// </summary>
 /// <param name="protoElement">Proto element to add to the collection.</param>
 public void AddNewElement(ModelProtoElement protoElement)
 {
     if (!protoElements.Contains(protoElement))
     {
         protoElements.Add(protoElement);
     }
 }
Пример #4
0
 /// <summary>
 /// Adds a proto element to the proto elements collection.
 /// </summary>
 /// <param name="protoElement">Proto element to add to the collection.</param>
 public void AddNewRootElement(ModelProtoElement protoElement)
 {
     if (!this.protoRootElements.Contains(protoElement))
     {
         protoRootElements.Add(protoElement);
     }
 }
Пример #5
0
 /// <summary>
 /// Adds a proto element to the proto elements collection.
 /// </summary>
 /// <param name="protoElement">Proto element to add to the collection.</param>
 /// <param name="index">Index.</param>
 public void InsertNewRootElement(ModelProtoElement protoElement, int index)
 {
     if (!this.protoRootElements.Contains(protoElement))
     {
         protoRootElements.Insert(index, protoElement);
     }
 }
        public override void ModelFinalize(CopyPaste.ModelProtoElement protoElement, CopyPaste.ModelProtoGroupMerger groupMerger)
        {
            base.ModelFinalize(protoElement, groupMerger);

            RootDiagramNode node = new RootDiagramNode(this.Store);

            node.PresentationElementClass = this;

            this.DiagramClass.DiagramClassView.RootDiagramNodes.Add(node);
        }
Пример #7
0
        /// <summary>
        /// Get all embedded proto elements for the given element.
        /// </summary>
        /// <param name="partition">Partition.</param>
        /// <param name="protoElement">Proto element to get all embedded elements for.</param>
        /// <returns>List of embedded proto elements.</returns>
        public List <ModelProtoElement> GetEmbeddedElements(Partition partition, ModelProtoElement protoElement)
        {
            if (bNeedsInitialization)
            {
                InitDictionaries(partition);
            }

            List <ModelProtoElement> elements;

            this.embeddingMapping.TryGetValue(protoElement.ElementId, out elements);
            return(elements);
        }
Пример #8
0
        public List <ModelProtoLink> GetReferenceLinksTarget(Partition partition, ModelProtoElement protoElement)
        {
            if (bNeedsInitialization)
            {
                InitDictionaries(partition);
            }

            List <ModelProtoLink> elements;

            this.referencingMappingTarget.TryGetValue(protoElement.ElementId, out elements);
            return(elements);
        }
Пример #9
0
        public override void ModelFinalize(CopyPaste.ModelProtoElement protoElement, CopyPaste.ModelProtoGroupMerger groupMerger)
        {
            base.ModelFinalize(protoElement, groupMerger);

            if (protoElement.Name == "ReferenceRelationship")
            {
                FinalizeReferenceRelationshipMerge(protoElement, groupMerger, true);
            }
            else if (protoElement.Name == "EmbeddingRelationship")
            {
                FinalizeEmbeddingRelationshipsMerge(protoElement, groupMerger, true);
            }

            FinalizeRelationshipMerge(protoElement, groupMerger);
        }
Пример #10
0
        private void InitDictionaries(Partition partition)
        {
            bNeedsInitialization = false;

            this.embeddingMapping         = new Dictionary <Guid, List <ModelProtoElement> >();
            this.referencingMapping       = new Dictionary <Guid, List <ModelProtoLink> >();
            this.referencingMappingTarget = new Dictionary <Guid, List <ModelProtoLink> >();
            this.elementMapping           = new Dictionary <Guid, ModelProtoElement>();

            foreach (ModelProtoElement element in this.ProtoElements)
            {
                embeddingMapping.Add(element.ElementId, new List <ModelProtoElement>());
                referencingMapping.Add(element.ElementId, new List <ModelProtoLink>());
                referencingMappingTarget.Add(element.ElementId, new List <ModelProtoLink>());
                elementMapping.Add(element.ElementId, element);
            }
            foreach (ModelProtoLink link in this.ProtoEmbeddingLinks)
            {
                ModelProtoRolePlayer rolePlayer = link.GetSourceRolePlayer(partition);
                ModelProtoElement    p          = GetElementById(rolePlayer.RolePlayerId);
                if (p != null)
                {
                    embeddingMapping[p.ElementId].Add(
                        GetElementById(link.GetTargetRolePlayer(partition).RolePlayerId));
                }
            }

            foreach (ModelProtoLink link in this.ProtoReferenceLinks)
            {
                ModelProtoRolePlayer sourceRP = link.GetSourceRolePlayer(partition);
                ModelProtoElement    p        = GetElementById(sourceRP.RolePlayerId);
                if (p != null)
                {
                    referencingMapping[p.ElementId].Add(link);
                }

                ModelProtoRolePlayer targetRP = link.GetTargetRolePlayer(partition);
                p = GetElementById(targetRP.RolePlayerId);
                if (p != null)
                {
                    referencingMappingTarget[p.ElementId].Add(link);
                }
            }
        }
Пример #11
0
        public override void ModelFinalize(CopyPaste.ModelProtoElement protoElement, CopyPaste.ModelProtoGroupMerger groupMerger)
        {
            base.ModelFinalize(protoElement, groupMerger);

            DomainClass domainClass = this.Store.ElementDirectory.FindElement(groupMerger.GetIdMapping(protoElement.ElementId)) as DomainClass;

            if (domainClass == null)
            {
                return;
            }

            if (domainClass.IsDomainModel)
            {
                domainClass.IsDomainModel = false;
            }

            if (domainClass.BaseClass != null)
            {
                ReadOnlyCollection <DomainClassReferencesBaseClass> col = DomainRoleInfo.GetElementLinks <DomainClassReferencesBaseClass>(domainClass, DomainClassReferencesBaseClass.DerivedClassDomainRoleId);
                if (col.Count != 1)
                {
                    throw new ArgumentNullException("Domain class can only reference one base class");
                }

                DomainClassReferencesBaseClass r = col[0];
                r.InhNodeId = Guid.Empty;     // otherwise node id of the source element would be used
            }

            if (domainClass.DomainModelTreeNodes.Count == 0)
            {
                RootNode node = new RootNode(domainClass.Store);
                node.DomainElement   = domainClass;
                node.IsElementHolder = true;

                // add to the domain model diagram tree
                domainClass.ModelContext.ViewContext.DomainModelTreeView.ModelTreeNodes.Add(node);
                domainClass.ModelContext.ViewContext.DomainModelTreeView.RootNodes.Add(node);
            }

            SerializationDomainClassAddRule.OnDomainClassAdded(domainClass);
            SerializationHelper.UpdateDerivedElementsSerializationProperties(domainClass);
        }
Пример #12
0
        private static int SortProtoElements(ModelProtoElement x, ModelProtoElement y)
        {
            if (x.Name == "DomainClass" && y.Name != "DomainClass")
                return -1;
            else if (x.Name != "DomainClass" && y.Name == "DomainClass")
                return 1;

            return 0;
        }
 /// <summary>
 /// Get all embedded proto elements for the given element.
 /// </summary>
 /// <param name="partition">Partition.</param>
 /// <param name="protoElement">Proto element to get all embedded elements for.</param>
 /// <returns>List of embedded proto elements.</returns>
 public List<ModelProtoElement> GetEmbeddedElements(Partition partition, ModelProtoElement protoElement)
 {
     List<ModelProtoElement> elements;
     this.embeddingMapping.TryGetValue(protoElement.ElementId, out elements);
     return elements;
 }
        /// <summary>
        /// Get all embedded proto elements for the given element.
        /// </summary>
        /// <param name="partition">Partition.</param>
        /// <param name="protoElement">Proto element to get all embedded elements for.</param>
        /// <returns>List of embedded proto elements.</returns>
        public List<ModelProtoElement> GetEmbeddedElements(Partition partition, ModelProtoElement protoElement)
        {
            if (bNeedsInitialization)
                InitDictionaries(partition);

            List<ModelProtoElement> elements;
            this.embeddingMapping.TryGetValue(protoElement.ElementId, out elements);
            return elements;
        }
Пример #15
0
        public override bool ModelCanMerge(CopyPaste.ModelProtoElement protoElement, CopyPaste.ModelProtoGroup protoGroup)
        {
            if (protoElement != null)
            {
                DomainClassInfo elementDomainInfo = this.Partition.DomainDataDirectory.GetDomainClass(protoElement.DomainClassId);
                if (elementDomainInfo.IsDerivedFrom(global::Tum.PDE.LanguageDSL.DomainClass.DomainClassId))
                {
                    if (protoGroup.Operation == ModelProtoGroupOperation.Move)
                    {
                        foreach (global::Tum.PDE.LanguageDSL.LibraryModelContextHasClasses link in DomainRoleInfo.GetElementLinks <global::Tum.PDE.LanguageDSL.LibraryModelContextHasClasses>(this, global::Tum.PDE.LanguageDSL.LibraryModelContextHasClasses.LibraryModelContextDomainRoleId))
                        {
                            if (link.DomainClass.Id == protoElement.ElementId)
                            {
                                return(false);
                            }
                        }
                    }
                    return(true);
                }
                else if (elementDomainInfo.IsDerivedFrom(global::Tum.PDE.LanguageDSL.DomainRelationship.DomainClassId))
                {
                    if (protoGroup.Operation == ModelProtoGroupOperation.Move)
                    {
                        foreach (global::Tum.PDE.LanguageDSL.LibraryModelContextHasRelationships link in DomainRoleInfo.GetElementLinks <global::Tum.PDE.LanguageDSL.LibraryModelContextHasRelationships>(this, global::Tum.PDE.LanguageDSL.LibraryModelContextHasRelationships.LibraryModelContextDomainRoleId))
                        {
                            if (link.DomainRelationship.Id == protoElement.ElementId)
                            {
                                return(false);
                            }
                        }
                    }

                    // see if source and target domain classes are copied here
                    List <ModelProtoElement> elements = protoGroup.GetEmbeddedElements(this.Partition, protoElement);
                    for (int i = 0; i < elements.Count; i++)
                    {
                        if (elements[i].Name == "DomainRole")
                        {
                            List <ModelProtoLink> links = protoGroup.GetReferenceLinks(this.Partition, elements[i]);
                            foreach (ModelProtoLink link in links)
                            {
                                if (link.Name == "DomainRoleReferencesRolePlayer")
                                {
                                    ModelProtoRolePlayer rP = link.GetTargetRolePlayer(this.Partition);
                                    // see if the target element is beeing copied or is already in the model
                                    if (!protoGroup.HasProtoElementFor(rP.RolePlayerId, this.Partition))
                                    {
                                        ModelElement m = this.Store.ElementDirectory.FindElement(rP.RolePlayerId);
                                        if (m == null)
                                        {
                                            if (!this.MetaModel.HasElement(rP.ElementName))
                                            {
                                                return(false);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }

                    return(true);
                }
            }
            return(false);
        }
 /// <summary>
 /// Adds a proto element to the proto elements collection.
 /// </summary>
 /// <param name="protoElement">Proto element to add to the collection.</param>
 public void AddNewElement(ModelProtoElement protoElement)
 {
     if (!protoElements.Contains(protoElement))
         protoElements.Add(protoElement);
 }
        public List<ModelProtoLink> GetReferenceLinksTarget(Partition partition, ModelProtoElement protoElement)
        {
            if (bNeedsInitialization)
                InitDictionaries(partition);

            List<ModelProtoLink> elements;
            this.referencingMappingTarget.TryGetValue(protoElement.ElementId, out elements);
            return elements;
        }
 /// <summary>
 /// Adds a proto element to the proto elements collection.
 /// </summary>
 /// <param name="protoElement">Proto element to add to the collection.</param>
 public void AddNewRootElement(ModelProtoElement protoElement)
 {
     if( !this.protoRootElements.Contains(protoElement))
         protoRootElements.Add(protoElement);
 }
Пример #19
0
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="protoGroup">Proto group to paste/move.</param>
        /// <param name="rootElement">Element to execute paste/move on.</param>
        public ModelProtoGroupMerger(ModelProtoGroup protoGroup, ModelElement rootElement)
        {
            this.protoGroup       = protoGroup;
            this.validationResult = new ValidationResult();

            this.idMapping                = new Dictionary <Guid, Guid>();
            this.embeddingMapping         = new Dictionary <Guid, List <ModelProtoElement> >();
            this.referencingMapping       = new Dictionary <Guid, List <ModelProtoLink> >();
            this.referencingMappingTarget = new Dictionary <Guid, List <ModelProtoLink> >();
            this.elementMapping           = new Dictionary <Guid, ModelProtoElement>();

            if (protoGroup.Operation == ModelProtoGroupOperation.Move)
            {
                // move element
                foreach (ModelProtoElement protoElement in protoGroup.ProtoRootElements)
                {
                    (rootElement as IModelMergeElements).ModelMove(protoElement, this);
                }
                return;
            }

            foreach (ModelProtoElement element in protoGroup.ProtoElements)
            {
                idMapping.Add(element.ElementId, Guid.Empty);
                embeddingMapping.Add(element.ElementId, new List <ModelProtoElement>());
                referencingMapping.Add(element.ElementId, new List <ModelProtoLink>());
                referencingMappingTarget.Add(element.ElementId, new List <ModelProtoLink>());
                elementMapping.Add(element.ElementId, element);
            }
            foreach (ModelProtoLink link in protoGroup.ProtoEmbeddingLinks)
            {
                ModelProtoRolePlayer rolePlayer = link.GetSourceRolePlayer(rootElement.Store.DefaultPartition);
                ModelProtoElement    p          = GetElementById(rolePlayer.RolePlayerId);
                if (p != null)
                {
                    embeddingMapping[p.ElementId].Add(
                        GetElementById(link.GetTargetRolePlayer(rootElement.Store.DefaultPartition).RolePlayerId));
                }
            }

            foreach (ModelProtoLink link in protoGroup.ProtoReferenceLinks)
            {
                ModelProtoRolePlayer sourceRP = link.GetSourceRolePlayer(rootElement.Store.DefaultPartition);
                ModelProtoElement    p        = GetElementById(sourceRP.RolePlayerId);
                if (p != null)
                {
                    referencingMapping[p.ElementId].Add(link);
                }

                ModelProtoRolePlayer targetRP = link.GetTargetRolePlayer(rootElement.Store.DefaultPartition);
                p = GetElementById(targetRP.RolePlayerId);
                if (p != null)
                {
                    referencingMappingTarget[p.ElementId].Add(link);
                }
            }

            // start merging
            foreach (ModelProtoElement protoElement in protoGroup.ProtoRootElements)
            {
                (rootElement as IModelMergeElements).ModelMerge(protoElement, this, true);
            }

            // process reference relationships
            foreach (ModelProtoLink link in protoGroup.ProtoReferenceLinks)
            {
                ModelProtoRolePlayer sourceRP = link.GetSourceRolePlayer(rootElement.Store.DefaultPartition);
                if (this.idMapping.ContainsKey(sourceRP.RolePlayerId))
                {
                    System.Guid id = this.idMapping[sourceRP.RolePlayerId];
                    if (id != Guid.Empty)
                    {
                        ModelElement copiedModelElement = rootElement.Store.ElementDirectory.FindElement(id);
                        if (copiedModelElement != null)
                        {
                            if (copiedModelElement is IModelMergeElements)
                            {
                                (copiedModelElement as IModelMergeElements).ModelMerge(link, this);
                            }
                        }
                        continue;
                    }
                }

                System.Guid  elementId    = sourceRP.RolePlayerId;
                ModelElement modelElement = rootElement.Store.ElementDirectory.FindElement(elementId);
                if (modelElement != null)
                {
                    if (modelElement is IModelMergeElements)
                    {
                        (modelElement as IModelMergeElements).ModelMerge(link, this);
                    }
                }
            }

            // finalize merging
            foreach (ModelProtoElement protoElement in protoGroup.ProtoElements)
            {
                Guid id = Guid.Empty;
                try
                {
                    id = GetIdMapping(protoElement.ElementId);
                }
                catch
                {
                    id = Guid.Empty;
                    continue;
                }

                /*
                 * if (id == Guid.Empty)
                 * {
                 *  ModelElement m = rootElement.Store.ElementDirectory.FindElement(id);
                 *  if (m != null)
                 *      id = m.Id;
                 *  else
                 *      continue;
                 * }*/

                ModelElement m = rootElement.Store.ElementDirectory.FindElement(id);
                if (m != null)
                {
                    (m as IModelMergeElements).ModelFinalize(protoElement, this);
                }
            }

            // finalize merging
            foreach (ModelProtoElement protoElement in protoGroup.ProtoRootElements)
            {
                (rootElement as IModelMergeElements).ModelFinalizeMerge(protoElement, this);
            }
        }
        private void FinalizeRelationshipMerge(ModelProtoElement protoElement, ModelProtoGroupMerger groupMerger)
        {
            SerializationClass sClass;
            if (this is ReferenceRelationship)
            {
                sClass = (this as ReferenceRelationship).SerializedReferenceRelationship;
            }
            else
            {
                sClass = (this as EmbeddingRelationship).SerializedEmbeddingRelationship;
            }

            if (protoElement.CustomArguments != null)
                if (protoElement.CustomArguments is DomainRelationshipSerializationInfo)
                {
                    DomainRelationshipSerializationInfo info = (DomainRelationshipSerializationInfo)protoElement.CustomArguments;
                    if (this is ReferenceRelationship)
                    {
                        (this as ReferenceRelationship).SerializedReferenceRelationship.IsInFullSerialization = info.IsInFullSerialization;
                    }
                    else
                    {
                        (this as EmbeddingRelationship).SerializedEmbeddingRelationship.IsInFullSerialization = info.IsInFullSerialization;
                        (this as EmbeddingRelationship).SerializedEmbeddingRelationship.IsTargetIncludedSubmodel = info.IsTargetIncludedSubmodel;
                    }   
                    if (info != null)
                    {
                        for (int i = 0; i < info.AttributesOrder.Count; i++)
                        {
                            #region Attributes
                            ElementSerializationInfo eInfo = info.AttributesOrder[i] as ElementSerializationInfo;
                            Guid newId = Guid.Empty;
                            if (eInfo.ElementName != "SerializedIdProperty")
                            {
                                try
                                {
                                    newId = groupMerger.GetIdMapping(eInfo.ElementId);
                                }
                                catch
                                {
                                    newId = Guid.Empty;
                                }

                                if (newId == Guid.Empty)
                                {
                                    ModelElement m = this.Store.ElementDirectory.FindElement(eInfo.ElementId);
                                    if (m != null)
                                        newId = m.Id;
                                }
                            }
                            for (int y = 0; y < sClass.Attributes.Count; y++)
                            {
                                if (sClass.Attributes[y] is SerializedIdProperty && eInfo.ElementName == "SerializedIdProperty")
                                {
                                    (sClass.Attributes[y] as SerializedIdProperty).OmitIdProperty = eInfo.OmitElement;
                                    if (y != i)
                                        sClass.Attributes.Move(y, i);
                                    break;
                                }
                                else if (eInfo.ElementName != "SerializedIdProperty" && !(sClass.Attributes[y] is SerializedIdProperty))
                                {
                                    SerializedDomainProperty p = sClass.Attributes[y] as SerializedDomainProperty;
                                    p.OmitProperty = eInfo.OmitElement;
                                    if (p.DomainProperty.Id == newId && y != i)
                                    {
                                        sClass.Attributes.Move(y, i);
                                        break;
                                    }
                                }
                            }
                            #endregion
                        }

                        for (int i = 0; i < info.ChildrenOrder.Count; i++)
                        {
                            #region Children
                            ElementSerializationInfo eInfo = info.ChildrenOrder[i] as ElementSerializationInfo;
                            Guid newId = Guid.Empty;

                            try
                            {
                                newId = groupMerger.GetIdMapping(eInfo.ElementId);
                            }
                            catch
                            {
                                newId = Guid.Empty;
                            }

                            if (newId == Guid.Empty)
                            {
                                ModelElement m = this.Store.ElementDirectory.FindElement(eInfo.ElementId);
                                if (m != null)
                                    newId = m.Id;
                            }

                            for (int y = i; y < sClass.Children.Count; y++)
                            {
                                if (sClass.Children[y] is SerializedDomainProperty)
                                {
                                    SerializedDomainProperty p = sClass.Children[y] as SerializedDomainProperty;
                                    if (p.DomainProperty.Id == newId)
                                    {
                                        p.OmitProperty = eInfo.OmitElement;

                                        if (y != i)
                                            sClass.Children.Move(y, i);
                                        break;
                                    }
                                }
                            }
                            #endregion
                        }
                    }
                }
        }
 public List<ModelProtoLink> GetReferenceLinksTarget(Partition partition, ModelProtoElement protoElement)
 {
     List<ModelProtoLink> elements;
     this.referencingMappingTarget.TryGetValue(protoElement.ElementId, out elements);
     return elements;
 }
 /// <summary>
 /// Adds a proto element to the proto elements collection.
 /// </summary>
 /// <param name="protoElement">Proto element to add to the collection.</param>
 /// <param name="index">Index.</param>
 public void InsertNewRootElement(ModelProtoElement protoElement, int index)
 {
     if (!this.protoRootElements.Contains(protoElement))
         protoRootElements.Insert(index, protoElement);
 }
        private void FinalizeReferenceRelationshipMerge(ModelProtoElement protoElement, ModelProtoGroupMerger groupMerger, bool bCreateSInfo)
        {
            ReferenceRelationship refRel = this.Store.ElementDirectory.FindElement(groupMerger.GetIdMapping(protoElement.ElementId)) as ReferenceRelationship;
            if (bCreateSInfo)
                SerializationDomainRelationshipAddRule.OnReferenceRelationshipAdded(refRel);
            if (refRel == null)
                return;

            ModelTreeHelper.AddNewReferenceRelationship(refRel, refRel.Source.RolePlayer as DomainClass, refRel.Target.RolePlayer);
        }
        private void FinalizeEmbeddingRelationshipsMerge(ModelProtoElement protoElement, ModelProtoGroupMerger groupMerger, bool bCreateSInfo)
        {
            EmbeddingRelationship embRel = this.Store.ElementDirectory.FindElement(groupMerger.GetIdMapping(protoElement.ElementId)) as EmbeddingRelationship;
            if (bCreateSInfo)
                SerializationDomainRelationshipAddRule.OnEmbeddingRelationshipAdded(embRel);
            if (embRel == null)
                return;

            ModelTreeHelper.AddNewEmbeddingRS(embRel, embRel.Source.RolePlayer as DomainClass, embRel.Target.RolePlayer, false);
        }
Пример #25
0
        public override void ModelProcessMergeCopy(CopyPaste.ModelProtoElement protoElement, CopyPaste.ModelProtoGroup protoGroup)
        {
            base.ModelProcessMergeCopy(protoElement, protoGroup);

            // copy rs and target elements if required
            if (CopyPaste.CopyAndPasteOperations.Operation == CopyPaste.CopyAndPasteOperation.CopyEmbeddingTree ||
                CopyPaste.CopyAndPasteOperations.Operation == CopyPaste.CopyAndPasteOperation.CopyAllTree ||
                CopyPaste.CopyAndPasteOperations.Operation == CopyPaste.CopyAndPasteOperation.CopyReferenceTree)
            {
                foreach (DomainRole role in this.RolesPlayed)
                {
                    if (role.Relationship is EmbeddingRelationship && role.Relationship.Source == role)
                    {
                        if (CopyPaste.CopyAndPasteOperations.Operation == CopyPaste.CopyAndPasteOperation.CopyEmbeddingTree ||
                            CopyPaste.CopyAndPasteOperations.Operation == CopyPaste.CopyAndPasteOperation.CopyAllTree)
                        {
                            ModelProtoElement e = (role.Relationship as IModelMergeElements).ModelCreateMergeCopy(protoGroup);
                            protoGroup.AddNewRootElement(e);

                            // continue with target element
                            if (ImmutabilityExtensionMethods.GetLocks(role.Relationship.Target.RolePlayer) == Locks.None)
                            {
                                if (!protoGroup.HasProtoElementFor(role.Relationship.Target.RolePlayer.Id, this.Partition))
                                {
                                    ModelProtoElement d = (role.Relationship.Target.RolePlayer as IModelMergeElements).ModelCreateMergeCopy(protoGroup);
                                    protoGroup.InsertNewRootElement(d, 0);
                                }
                            }
                        }
                    }
                    else if (role.Relationship is ReferenceRelationship && role.Relationship.Source == role)
                    {
                        if (CopyPaste.CopyAndPasteOperations.Operation == CopyPaste.CopyAndPasteOperation.CopyAllTree ||
                            CopyPaste.CopyAndPasteOperations.Operation == CopyPaste.CopyAndPasteOperation.CopyReferenceTree)
                        {
                            ModelProtoElement e = (role.Relationship as IModelMergeElements).ModelCreateMergeCopy(protoGroup);
                            protoGroup.AddNewRootElement(e);
                        }
                    }
                }

                // sort proto elements: bring domain classes to the top
                protoGroup.SortProtoElements(SortProtoElements);
            }

            // copy order of attributes and children
            DomainClassSerializationInfo info = new DomainClassSerializationInfo(
                this.SerializedDomainClass.Children.Count,
                this.SerializedDomainClass.Attributes.Count);

            for (int i = 0; i < this.SerializedDomainClass.Attributes.Count; i++)
            {
                SerializationAttributeElement aatr = this.SerializedDomainClass.Attributes[i];
                if (aatr is SerializedDomainProperty)
                {
                    SerializedDomainProperty sP    = aatr as SerializedDomainProperty;
                    ElementSerializationInfo sInfo = new ElementSerializationInfo(
                        sP.DomainProperty.Name, sP.DomainProperty.Id);
                    if (sP.OmitProperty)
                    {
                        sInfo.OmitElement = true;
                    }

                    info.AttributesOrder.Add(sInfo);
                }
                else if (aatr is SerializedIdProperty)
                {
                    SerializedIdProperty     sI    = aatr as SerializedIdProperty;
                    ElementSerializationInfo sInfo = new ElementSerializationInfo("SerializedIdProperty", Guid.Empty);
                    if (sI.OmitIdProperty)
                    {
                        sInfo.OmitElement = true;
                    }

                    info.AttributesOrder.Add(sInfo);
                }
            }

            for (int i = 0; i < this.SerializedDomainClass.Children.Count; i++)
            {
                SerializationElement sE = this.SerializedDomainClass.Children[i];
                if (sE is SerializedReferenceRelationship)
                {
                    SerializedReferenceRelationship sDomainRel = sE as SerializedReferenceRelationship;
                    ElementSerializationInfo        sInfo      = new ElementSerializationInfo(
                        sDomainRel.ReferenceRelationship.Name, sDomainRel.ReferenceRelationship.Id);
                    if (sDomainRel.OmitRelationship)
                    {
                        sInfo.OmitElement = true;
                    }

                    info.ChildrenOrder.Add(sInfo);
                }
                else if (sE is SerializedEmbeddingRelationship)
                {
                    SerializedEmbeddingRelationship sDomainRel = sE as SerializedEmbeddingRelationship;
                    ElementSerializationInfo        sInfo      = new ElementSerializationInfo(
                        sDomainRel.EmbeddingRelationship.Name, sDomainRel.EmbeddingRelationship.Id);
                    if (sDomainRel.OmitRelationship)
                    {
                        sInfo.OmitElement = true;
                    }

                    info.ChildrenOrder.Add(sInfo);
                }
                else if (sE is SerializedDomainProperty)
                {
                    SerializedDomainProperty sP    = sE as SerializedDomainProperty;
                    ElementSerializationInfo sInfo = new ElementSerializationInfo(
                        sP.DomainProperty.Name, sP.DomainProperty.Id);
                    if (sP.OmitProperty)
                    {
                        sInfo.OmitElement = true;
                    }

                    info.ChildrenOrder.Add(sInfo);
                }
            }

            protoElement.CustomArguments = info;
        }
        public override void ModelProcessMergeCopy(ModelProtoElement protoElement, ModelProtoGroup protoGroup)
        {
            base.ModelProcessMergeCopy(protoElement, protoGroup);

            bool isInFull = false;
            bool isTargetInc = false;
            SerializationClass sClass;
            if (this is ReferenceRelationship)
            {
                sClass = (this as ReferenceRelationship).SerializedReferenceRelationship;
                isInFull = (this as ReferenceRelationship).SerializedReferenceRelationship.IsInFullSerialization;
            }
            else
            {
                sClass = (this as EmbeddingRelationship).SerializedEmbeddingRelationship;
                isInFull = (this as EmbeddingRelationship).SerializedEmbeddingRelationship.IsInFullSerialization;
                isTargetInc = (this as EmbeddingRelationship).SerializedEmbeddingRelationship.IsTargetIncludedSubmodel;
            }

            // copy order of attributes and children
            DomainRelationshipSerializationInfo info = new DomainRelationshipSerializationInfo(
                sClass.Children.Count,
                sClass.Attributes.Count);
            info.IsInFullSerialization = isInFull;
            info.IsTargetIncludedSubmodel = isTargetInc;

            for (int i = 0; i < sClass.Attributes.Count; i++)
            {
                SerializationAttributeElement aatr = sClass.Attributes[i];
                if (aatr is SerializedDomainProperty)
                {
                    SerializedDomainProperty sP = aatr as SerializedDomainProperty;
                    ElementSerializationInfo sInfo = new ElementSerializationInfo(
                        sP.DomainProperty.Name, sP.DomainProperty.Id);
                    if (sP.OmitProperty)
                        sInfo.OmitElement = true;

                    info.AttributesOrder.Add(sInfo);
                }
                else if (aatr is SerializedIdProperty)
                {
                    SerializedIdProperty sI = aatr as SerializedIdProperty;
                    ElementSerializationInfo sInfo = new ElementSerializationInfo("SerializedIdProperty", Guid.Empty);
                    if (sI.OmitIdProperty)
                        sInfo.OmitElement = true;

                    info.AttributesOrder.Add(sInfo);
                }
            }

            for (int i = 0; i < sClass.Children.Count; i++)
            {
                SerializationElement sE = sClass.Children[i];
                if (sE is SerializedDomainProperty)
                {
                    SerializedDomainProperty sP = sE as SerializedDomainProperty;
                    ElementSerializationInfo sInfo = new ElementSerializationInfo(
                        sP.DomainProperty.Name, sP.DomainProperty.Id);
                    if (sP.OmitProperty)
                        sInfo.OmitElement = true;

                    info.ChildrenOrder.Add(sInfo);
                }
            }

            protoElement.CustomArguments = info;
        }