Description of MappingFactory.
Exemplo n.º 1
0
        public override IEnumerable <MP.Mapping> getOwnedMappings(MP.MappingNode targetRootNode)
        {
            var foundMappings = new List <MP.Mapping>();

            //get the mappings using trace relations
            //TODO: is this fast enough?
            foreach (var trace in this.sourceElement.getRelationships <TSF_EA.Abstraction>().Where(x => x.target is TSF_EA.Element && x.stereotypes.Any(y => y.name == "trace")))
            {
                //get the mappings based on traces
                var mapping = MappingFactory.getMapping(this, trace, (MappingNode)targetRootNode);
                if (mapping != null)
                {
                    foundMappings.Add(mapping);
                }
            }
            //also add the base mappings
            foundMappings.AddRange(base.getOwnedMappings(targetRootNode));
            return(foundMappings);
        }
        List <Mapping> getMappings()
        {
            //get the connector mappings
            //check if the package has a trace to another package
            ElementWrapper targetRootElement = null;
            var            packageTrace      = this.wrappedPackage.relationships.OfType <Abstraction>().FirstOrDefault(x => x.target is Element && x.stereotypes.Any(y => y.name == "trace"));

            if (packageTrace != null)
            {
                targetRootElement = packageTrace.target as ElementWrapper;
            }
            List <Mapping> returnedMappings = new List <Mapping>();

            foreach (var classElement in wrappedPackage.ownedElements.OfType <ElementWrapper>())
            {
                returnedMappings.AddRange(MappingFactory.createOwnedMappings(classElement, wrappedPackage.name + "." + classElement.name, targetRootElement, true));
            }
            return(returnedMappings);
        }
Exemplo n.º 3
0
        public override IEnumerable <MP.Mapping> getOwnedMappings(MP.MappingNode targetRootNode)
        {
            //the mappings are stored in a tagged value
            var foundMappings = new List <MP.Mapping>();

            //Mappings are stored in tagged values
            foreach (var mappingTag in this.sourceAssociation.taggedValues.Where(x => x.name == this.settings.linkedAttributeTagName))
            {
                var mapping = MappingFactory.getMapping(this, (TSF_EA.TaggedValue)mappingTag, (MappingNode)targetRootNode);
                if (mapping != null)
                {
                    foundMappings.Add(mapping);
                }
            }
            //loop subNodes
            foreach (MappingNode childNode in this.allChildNodes)
            {
                foundMappings.AddRange(childNode.getOwnedMappings(targetRootNode));
            }
            return(foundMappings);
        }
        public override IEnumerable <MP.Mapping> getOwnedMappings(MP.MappingNode targetRootNode)
        {
            var foundMappings = new List <MP.Mapping>();

            //TODO: is this fast enough?
            foreach (var trace in this.sourceElement.relationships.OfType <TSF_EA.Abstraction>().Where(x => x.target is TSF_EA.Element && x.stereotypes.Any(y => y.name == "trace")))
            {
                //check if this trace represents a mappingNode to somewhere in in the targetNode
                //get the mapping path
                var mapping = MappingFactory.getMapping(this, trace, (MappingNode)targetRootNode);
                if (mapping != null)
                {
                    foundMappings.Add(mapping);
                }
            }
            //loop subNodes
            foreach (MappingNode childNode in this.allChildNodes)
            {
                foundMappings.AddRange(childNode.getOwnedMappings(targetRootNode));
            }
            return(foundMappings);
        }
Exemplo n.º 5
0
        public MappingNode createMappingNode(List <string> mappingPath)
        {
            //if the path is empty we return this node
            if (!mappingPath.Any())
            {
                return(this);
            }
            //check if the first node corresponds to this node
            if (mappingPath[0] == this.source.uniqueID)
            {
                //pop the first node
                mappingPath.RemoveAt(0);
                //if this was the last guid then also return this
                if (!mappingPath.Any())
                {
                    return(this);
                }
                //get the element corresponding to the (now) first guid.
                var subElement = this._source.model.getItemFromGUID(mappingPath[0]) as UML.Classes.Kernel.NamedElement;

                //check if a childNode for the given subElement is already present
                var childNode = this.allChildNodes.FirstOrDefault(x => x.source.uniqueID == subElement?.uniqueID) as MappingNode;
                //create new new node if not already present
                if (childNode == null)
                {
                    //TODO: check if subElement is actually somehow linked to this node?
                    childNode = MappingFactory.createMappingNode(subElement, this, this.settings);
                }

                return(childNode?.createMappingNode(mappingPath));
            }
            else
            {
                //the first GUID indicates that it does not below in this node
                this.mappingPath.Clear();
                return(this);
            }
        }
Exemplo n.º 6
0
        public static List <Mapping> createRootMappings(ElementWrapper root, string basepath)
        {
            //get the owned mappings
            var returnedMappings = MappingFactory.createOwnedMappings(root, basepath, false);

            //get the mappings of all associated elements
            foreach (var assocation in root.relationships
                     .OfType <Association>()
                     .Where(x => x.source.Equals(root)))
            {
                var targetElement = assocation.target as ElementWrapper;
                if (targetElement != null)
                {
                    returnedMappings.AddRange(createRootMappings(targetElement, basepath + "." + getConnectorString(assocation)));
                }
            }
            //get the owned mappings of all owned elements
            foreach (var ownedElement in root.ownedElements.OfType <ElementWrapper>())
            {
                returnedMappings.AddRange(createRootMappings(ownedElement, basepath + "." + ownedElement.name));
            }
            return(returnedMappings);
        }
Exemplo n.º 7
0
 List <Mapping> getMappings()
 {
     return(MappingFactory.createRootMappings(this.wrappedElement, this.wrappedElement.name));
 }