Пример #1
0
        /// <summary>
        /// Verifies if a paste operation can be executed in the current context.
        /// </summary>
        /// <param name="rootElement">Root element, on which to paste the current data object's data.</param>
        /// <param name="dataObject">Data to be pasted.</param>
        /// <returns>True if paste can be executed. False otherwise.</returns>
        public static bool CanMerge(ModelElement rootElement, IDataObject dataObject)
        {
            if (rootElement is IModelMergeElements)
            {
                ModelProtoGroup group = GetModelProtoGroup(dataObject);
                if (group == null)
                {
                    return(false);
                }

                if (group.ProtoRootElements.Count == 0)
                {
                    return(false);
                }

                foreach (ModelProtoElement p in group.ProtoRootElements)
                {
                    if (!(rootElement as IModelMergeElements).ModelCanMerge(p, group))
                    {
                        return(false);
                    }
                }

                return(true);
            }
            return(false);
        }
        /// <summary>
        /// Executes the paste operation on the given element.
        /// </summary>
        /// <param name="modelElement">Element.</param>
        /// <returns>Validation result, indicating problems during the paste operation.</returns>
        public static ValidationResult ExecutePaste(ModelElement modelElement)
        {
            System.Windows.IDataObject idataObject = System.Windows.Clipboard.GetDataObject();

            ValidationResult result = null;

            using (Transaction transaction = modelElement.Store.TransactionManager.BeginTransaction("Paste"))
            {
                result = ModelElementOperations.Merge(modelElement, idataObject);
                transaction.Commit();
            }

            ModelProtoGroup group = ModelElementOperations.GetModelProtoGroup(idataObject);

            if (group != null)
            {
                if (group.Operation == ModelProtoGroupOperation.Move)
                {
                    System.Windows.Clipboard.Clear();
                    ElementsInMoveMode.Clear();
                }
            }

            return(result);
        }
Пример #3
0
        /// <summary>
        /// Copies the given elements to the dataObject for the move operation.
        /// </summary>
        /// <param name="elements">Elements to copy.</param>
        /// <param name="dataObject">DataObject to add the data to.</param>
        /// <returns>DataObjects with the added data.</returns>
        public static IDataObject CopyToMove(ICollection <ModelElement> elements, IDataObject dataObject)
        {
            ModelProtoGroup protoGroup = new ModelProtoGroup(elements, ModelProtoGroupOperation.Move);

            dataObject.SetData(ModelProtoGroup.DefaultDataFormatName, protoGroup);
            dataObject.SetData(ModelProtoGroup.DefaultDataIdentifierName, Guid.NewGuid());
            return(dataObject);
        }
Пример #4
0
        /// <summary>
        /// Executes the paste operation.
        /// </summary>
        /// <param name="rootElement">Root element, on which to paste the current data object's data.</param>
        /// <param name="dataObject">Data to be pasted.</param>
        /// <returns>ValidationResult holding errors, warning or information messages.</returns>
        public static ValidationResult Merge(ModelElement rootElement, IDataObject dataObject)
        {
            if (!CanMerge(rootElement, dataObject))
            {
                return(null);
            }

            ModelProtoGroup       group       = GetModelProtoGroup(dataObject);
            ModelProtoGroupMerger protoMerger = new ModelProtoGroupMerger(group, rootElement);

            return(protoMerger.MergeResult);
        }
        /// <summary>
        /// Helper method of the cut opeation.
        /// </summary>
        /// <param name="eventManager">Event manager.</param>
        /// <param name="idataObject">Data object.</param>
        public static void ProcessMoveMode(System.Windows.IDataObject idataObject)
        {
            bool isInMoveMode = false;

            if (idataObject != null)
            {
                ModelProtoGroup group = ModelElementOperations.GetModelProtoGroup(idataObject);
                if (group != null)
                {
                    if (group.Operation == ModelProtoGroupOperation.Move)
                    {
                        isInMoveMode = true;

                        List <System.Guid> guids = new List <System.Guid>();
                        foreach (ModelProtoElement root in group.ProtoRootElements)
                        {
                            guids.Add(root.ElementId);
                        }
                        foreach (System.Guid id in guids)
                        {
                            if (!ElementsInMoveMode.Contains(id))
                            {
                                //eventManager.GetEvent<ModelElementCustomEvent<bool>>().Publish(true, ModelElementCustomEventNames.ModelElementMoveModeStatus, id);
                                ElementsInMoveMode.Add(id);
                            }
                        }
                        for (int i = ElementsInMoveMode.Count - 1; i >= 0; i--)
                        {
                            if (!guids.Contains(ElementsInMoveMode[i]))
                            {
                                //eventManager.GetEvent<ModelElementCustomEvent<bool>>().Publish(false, ModelElementCustomEventNames.ModelElementMoveModeStatus, ElementsInMoveMode[i]);
                                ElementsInMoveMode.RemoveAt(i);
                            }
                        }
                    }
                }
            }

            if (!isInMoveMode)
            {
                // remove all elements from the current list and notify them to change status
                //foreach (System.Guid id in ElementsInMoveMode)
                //    eventManager.GetEvent<ModelElementCustomEvent<bool>>().Publish(false, ModelElementCustomEventNames.ModelElementMoveModeStatus, id);
            }
        }
Пример #6
0
        /// <summary>
        /// Deserialize.
        /// </summary>
        public void OnDeserialization(object sender)
        {
            elementId     = (Guid)serializationInfo.GetValue("elementId", typeof(Guid));
            domainClassId = (Guid)serializationInfo.GetValue("domainClassId", typeof(Guid));
            properties    = (System.Collections.ArrayList)serializationInfo.GetValue("properties", typeof(System.Collections.ArrayList));
            name          = (string)serializationInfo.GetValue("name", typeof(string));

            try
            {
                customChildGroup = (ModelProtoGroup)serializationInfo.GetValue("customChildGroup", typeof(ModelProtoGroup));
            }
            catch { }

            try
            {
                CustomArguments = serializationInfo.GetValue("customArguments", typeof(IModelMergeCustomArguments)) as IModelMergeCustomArguments;
            }
            catch
            {
            }
        }
        /// <summary>
        /// Deserialize.
        /// </summary>
        public void OnDeserialization(object sender)
        {
            elementId = (Guid)serializationInfo.GetValue("elementId", typeof(Guid));
            domainClassId = (Guid)serializationInfo.GetValue("domainClassId", typeof(Guid));
            properties = (System.Collections.ArrayList)serializationInfo.GetValue("properties", typeof(System.Collections.ArrayList));
            name = (string)serializationInfo.GetValue("name", typeof(string));

            try
            {
                customChildGroup = (ModelProtoGroup)serializationInfo.GetValue("customChildGroup", typeof(ModelProtoGroup));
            }
            catch { }

            try
            {
                CustomArguments = serializationInfo.GetValue("customArguments", typeof(IModelMergeCustomArguments)) as IModelMergeCustomArguments;
            }
            catch
            {
            }
            
        }
Пример #8
0
        /// <summary>
        /// Retrieves a model proto group from the given data object if one exists.
        /// </summary>
        /// <param name="dataObject">Data objects to retrieve a model proto group from.</param>
        /// <returns>ModelProtoGroup instance or null.</returns>
        public static ModelProtoGroup GetModelProtoGroup(IDataObject dataObject)
        {
            ModelProtoGroup group = null;

            if (dataObject.GetDataPresent(ModelProtoGroup.DefaultDataFormatName))
            {
                Guid guid = Guid.Empty;
                if (dataObject.GetDataPresent(ModelProtoGroup.DefaultDataIdentifierName))
                {
                    guid = (System.Guid)dataObject.GetData(ModelProtoGroup.DefaultDataIdentifierName);
                }

                if ((cachedPrototype != null) && guid == cachedPrototype.InstanceId)
                {
                    return(cachedPrototype.Prototype);
                }

                object obj = dataObject.GetData(ModelProtoGroup.DefaultDataFormatName);
                group           = obj as ModelProtoGroup;
                cachedPrototype = new CachedModelProtoGroup(guid, group);
            }

            return(group);
        }
Пример #9
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;
        }
        /// <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);
            }
        }
Пример #11
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);
            }
        }
Пример #12
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);
        }
Пример #13
0
 /// <summary>
 /// Constructor.
 /// </summary>
 /// <param name="instanceID"></param>
 /// <param name="prototype"></param>
 public CachedModelProtoGroup(Guid instanceID, ModelProtoGroup prototype)
 {
     this.instanceID = instanceID;
     this.prototype  = prototype;
 }
        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;
        }