public Mapping(MappingNode sourceEnd, MappingNode targetEnd) { this._source = sourceEnd; this._source.addMapping(this); this._target = targetEnd; this._target.addMapping(this); }
public static Mapping getMapping(MappingNode startNode, TaggedValue mappingTag, MappingNode targetRootNode) { var sourceMappingPath = getMappingPath(mappingTag, false); var targetMappingPath = getMappingPath(mappingTag, true); var targetElement = mappingTag.tagValue as Element; return(getMapping(mappingTag, targetElement, startNode, sourceMappingPath, targetMappingPath, targetRootNode)); }
public static Mapping getMapping(MappingNode startNode, ConnectorWrapper mappingRelation, MappingNode targetRootNode) { var sourceMappingPath = getMappingPath(mappingRelation, false); var targetMappingPath = getMappingPath(mappingRelation, true); Element targetElement = mappingRelation.targetElement; return(getMapping(mappingRelation, targetElement, startNode, sourceMappingPath, targetMappingPath, targetRootNode)); }
protected MappingNode(UML.Classes.Kernel.NamedElement source, MappingNode parent, MappingSettings settings, MP.ModelStructure structure) { this.source = source; this.parent = parent; this.settings = settings; this.parent?.addChildNode(this); this.structure = structure; }
protected MappingNode(NamedElement source, MappingNode parent, MappingSettings settings, MP.ModelStructure structure, NamedElement virtualOwner) { this.source = source; this.parent = parent; this.settings = settings; this.parent?.addChildNode(this); this.structure = structure; this.virtualOwner = virtualOwner; }
public TaggedValueMapping(TaggedValue wrappedTaggedValue, MappingNode source, MappingNode target) : base(source, target) { this.wrappedTaggedValue = wrappedTaggedValue; //make sure the mappingset is defined for all tagged value mappings. if (!this.hasMappingSetDefined && !this.isReadOnly) { var temp = this.EAMappingLogics; //load mapping logics to make sure they get saved this.saveMe(); } }
private static List <string> getMappingPath(Element nodeSource, MappingNode targetRootNode) { if (nodeSource.owner == null || targetRootNode.source == null || nodeSource.uniqueID == targetRootNode.source.uniqueID) { return(new List <string>() { nodeSource.uniqueID }); } var path = getMappingPath((Element)nodeSource.owner, targetRootNode); path.Add(nodeSource.uniqueID); return(path); }
public static Mapping createMapping(UML.Extended.UMLItem mappingItem, MappingNode startNode, MappingNode targetNode) { var connector = mappingItem as ConnectorWrapper; if (connector != null) { return(new ConnectorMapping(connector, startNode, targetNode)); } var taggedValue = mappingItem as TaggedValue; if (taggedValue != null) { return(new TaggedValueMapping(taggedValue, startNode, targetNode)); } throw new ArgumentException("MappingItem should be Connector or TaggedValue"); }
protected override UMLItem createMappingItem(MappingNode targetNode) { var classifierTargetNode = targetNode as ClassifierMappingNode; if (classifierTargetNode != null) { var trace = this.sourceElement.EAModel.factory.createNewElement <UML.Classes.Dependencies.Abstraction>(this.sourceElement, ""); trace.addStereotype(this.sourceElement.EAModel.factory.createStereotype(trace, "trace")); trace.target = classifierTargetNode.sourceElement; trace.save(); return(trace); } else { return(this.createTaggedValueMappingItem(targetNode)); } }
public static MappingNode getMappingNode(UML.Classes.Kernel.NamedElement source, MappingNode rootNode) { var mappingPath = getMappingPath(source as Element, rootNode); return(rootNode.createMappingNode(mappingPath)); }
private static Mapping getMapping(UML.Extended.UMLItem mappingItem, Element mappingTarget, MappingNode startNode, List <string> sourceMappingPath, List <string> targetMappingPath, MappingNode targetRootNode) { //do nothing if mappign target is null if (mappingTarget == null) { return(null); } //check if the mappingPath of the source corresponds with the path of the node var startNodeMappingPath = startNode.mappingPath; //source is OK if mapping corresponds, or no mappingPath found and it is not virtual var sourceOK = sourceMappingPath.SequenceEqual(startNodeMappingPath) || (!sourceMappingPath.Any() && !startNode.isVirtual); // if no targetMapping found then we try to build a Mapping up to the target root node source element if (!targetMappingPath.Any()) { targetMappingPath = getMappingPath(mappingTarget, targetRootNode); } //target is OK if the first item of the targetMappignPath corresponds to the targetRootNode var targetOK = targetMappingPath.FirstOrDefault() == targetRootNode.source?.uniqueID; //if target or source is not OK then we return null if (!sourceOK || !targetOK) { return(null); } //first create the targetMappingNode var targetMappingNode = targetRootNode.createMappingNode(targetMappingPath); //return the actual mapping return(createMapping(mappingItem, startNode, targetMappingNode)); }
public ClassifierMappingNode(TSF_EA.ElementWrapper sourceElement, MappingNode parent, MappingSettings settings, MP.ModelStructure structure) : base(sourceElement, parent, settings, structure) { }
public ConnectorMapping(ConnectorWrapper wrappedConnector, MappingNode sourceEnd, MappingNode targetEnd) : base(sourceEnd, targetEnd) { this.wrappedConnector = wrappedConnector; }
public ElementMappingNode(TSF_EA.ElementWrapper sourceElement, MappingNode parent, MappingSettings settings, MP.ModelStructure structure, bool isTarget) : this(sourceElement, parent, settings, structure, null, isTarget) { }
public Mapping(MappingNode sourceEnd, MappingNode targetEnd, MappingLogic logic) : this(sourceEnd, targetEnd) { this._mappingLogic = logic; }
public ClassifierMappingNode(TSF_EA.ElementWrapper sourceElement, MappingNode parent, MappingSettings settings, MP.ModelStructure structure, UML.Classes.Kernel.NamedElement virtualOwner) : base(sourceElement, parent, settings, structure, virtualOwner) { }
public TaggedValueMapping(TaggedValue wrappedTaggedValue, MappingNode source, MappingNode target) : base(source, target) { this.wrappedTaggedValue = wrappedTaggedValue; }
public Mapping(MappingNode sourceEnd, MappingNode targetEnd, IEnumerable <MappingLogic> logics) : this(sourceEnd, targetEnd) { this.mappingLogics = logics; }
public static MappingNode createMappingNode(UML.Classes.Kernel.NamedElement source, MappingNode parent, MappingSettings settings) { //AttributeMappingNode var attributeSource = source as AttributeWrapper; if (attributeSource != null) { return(new AttributeMappingNode(attributeSource, parent as ClassifierMappingNode, settings, parent.structure)); } //AssociationMappingNode var associationSource = source as Association; if (associationSource != null) { return(new AssociationMappingNode(associationSource, parent as ClassifierMappingNode, settings, parent.structure)); } //ClassifierMappingNode var classifierSource = source as ElementWrapper; if (classifierSource != null) { return(new ClassifierMappingNode(classifierSource, parent, settings, parent.structure)); } //not a valid source type, return null return(null); }
public static MappingNode createMappingNode(UML.Classes.Kernel.NamedElement source, MappingNode parent, MappingSettings settings) { //check if there is a virtual owner UML.Classes.Kernel.NamedElement virtualOwner = null; if (source.owner.uniqueID != parent.source.uniqueID) { virtualOwner = source.owner as UML.Classes.Kernel.NamedElement; } //AttributeMappingNode var attributeSource = source as AttributeWrapper; if (attributeSource != null) { return(new AttributeMappingNode(attributeSource, parent as ElementMappingNode, settings, parent.structure, virtualOwner, parent.isTarget)); } //AssociationMappingNode var associationSource = source as Association; if (associationSource != null) { return(new AssociationMappingNode(associationSource, parent as ElementMappingNode, settings, parent.structure, virtualOwner, parent.isTarget)); } //ClassifierMappingNode var classifierSource = source as ElementWrapper; if (classifierSource != null) { return(new ElementMappingNode(classifierSource, parent, settings, parent.structure, parent.isTarget)); } //not a valid source type, return null return(null); }
protected override UMLItem createMappingItem(MappingNode targetNode) { return(this.createTaggedValueMappingItem(targetNode)); }
public ElementMappingNode(TSF_EA.ElementWrapper sourceElement, MappingNode parent, MappingSettings settings, MP.ModelStructure structure, UML.Classes.Kernel.NamedElement virtualOwner, bool isTarget) : base(sourceElement, parent, settings, structure, virtualOwner, isTarget) { }