public void execute(RefObject sourceObject) throws RuntimeException, IllegalArgumentException { RefObject result; result = targetRefClass.refCreateInstance(null); objectsMap.put( sourceObject, result ); }
/** * @param source Navigate from this element, down the path */ public RefObject execute(RefObject source) throws IllegalArgumentException { RefObject result; // fond the source object if ( source == null ) { throw new IllegalArgumentException("Expected a non-null model element"); } // find the target extent result = source.refClass().refCreateInstance( null ); return result; } }
/** * The task's execution method. This method filters the model classes associated with metaclass and * executes the nested <template> tasks for the filtered classes collection. This * methods invokes the internal formatting tasks with the metaclass itself. * @param metaclass Path in the metamodel to the metaclass whose instances (in the model/extent) are to be * processed. Format of metaclass attribute: {<package>::} <meta class> */ public RefObject execute(String metaclass) throws IllegalArgumentException { RefClass refClass; RefObject result; if ( metaclass == null ) { throw new IllegalArgumentException( "Expected a non-null metaclass provided"); } refClass = Navigator.getMetaClass( extent, metaclass ); // non-null result = refClass.refCreateInstance( null ); return result; } }
public Multiplicity constructMultiplicity(int otherEndUpper) { Multiplicity result; MultiplicityRange range; result = (Multiplicity) multiplicity.getMetaClass( extent ).refCreateInstance( null ); range = (MultiplicityRange) multiplicityRange.getMetaClass( extent ).refCreateInstance( null ); range.setUpper( otherEndUpper ); result.getRange().add(range); return result; }
public Expression constructExpression(String body) { Expression result; result = (Expression) expression.getMetaClass( extent ).refCreateInstance( null ); result.setBody( body ); return result; }
/** * @param source Navigate from this element, down the path */ public RefObject execute(RefObject source) throws IllegalArgumentException { RefObject result; RefClass refClass; String metaclass; // fond the source object if ( source == null ) { throw new IllegalArgumentException("Expected a non-null model element"); } metaclass = Navigator.getMetaClassName( source ); refClass = Navigator.getMetaClass( extent, metaclass ); // non-null result = refClass.refCreateInstance( null ); return result; } }
public Parameter constructParameter(String name) { Parameter result; result = (Parameter) parameter.getMetaClass( extent ).refCreateInstance( null ); result.setName( name ); result.setVisibility( VisibilityKindEnum.VK_PUBLIC ); return result; }
public void constructTag(ModelElement modelElement, String name, String value) { TaggedValue result; result = (TaggedValue) taggedValue.getMetaClass( extent ).refCreateInstance( null ); result.setTag( name ); result.setValue( value ); result.setModelElement( modelElement ); }
public Operation constructOperation(String name) { Operation result; result = (Operation) operationName.getMetaClass( extent ).refCreateInstance( null ); result.setName( name ); result.setVisibility( VisibilityKindEnum.VK_PUBLIC ); result.setOwnerScope( ScopeKindEnum.SK_INSTANCE ); return result; }
public Dependency constructDependency(ModelElement client, ModelElement supplier, String name) { Dependency result; result = (Dependency) dependencyName.getMetaClass( extent ).refCreateInstance( null ); result.getSupplier().add( supplier ); result.getClient().add( client ); result.setNamespace( model ); result.setSpecification( false ); result.setName( name ); result.setVisibility( VisibilityKindEnum.VK_PUBLIC ); return result; }
public Attribute constructAttribute(String name) { Attribute result; result = (Attribute) attribute.getMetaClass( extent ).refCreateInstance( null ); result.setName( name ); result.setVisibility( VisibilityKindEnum.VK_PUBLIC ); result.setOwnerScope( ScopeKindEnum.SK_INSTANCE ); return result; }
public void constructStereotype(ModelElement extendedElement, String name) { Stereotype result; result = (Stereotype) locateLocalModelElement( model, name ); if ( result == null ) { // still not created, thus it is not included result = (Stereotype) stereotype.getMetaClass( extent ).refCreateInstance( null ); result.setName( name ); result.setNamespace( model ); result.setVisibility( VisibilityKindEnum.VK_PUBLIC ); } result.getExtendedElement().add( extendedElement ); }
public void constructGeneralization(Classifier subClass, Classifier superClass) { Generalization result; result = (Generalization) generalization.getMetaClass( extent ).refCreateInstance( null ); result.setNamespace( superClass.getNamespace() ); result.setParent( superClass ); result.setChild( subClass ); }
/** * Construct the data type with the name * @param dataTypeName is the non-null type name * @return the data type identified or class identified */ public DataType constructDataType(String dataTypeName) { DataType result; try { result = (DataType) locateModelElement(dataTypeName); } catch (IllegalArgumentException ex) { // data type not found result = (DataType) dataType.getMetaClass( extent ).refCreateInstance( null ); result.setName( dataTypeName ); result.setNamespace( model ); result.setVisibility( VisibilityKindEnum.VK_PUBLIC ); } return result; }
public UmlClass constructClass(Namespace namespace, String simpleTypeName) { UmlClass result; Object lookedUp; lookedUp = locateLocalModelElement( namespace, simpleTypeName ); if ( lookedUp == null ) { // none found - build it result = (UmlClass) className.getMetaClass( extent ).refCreateInstance( null ); result.setName( simpleTypeName ); result.setVisibility( VisibilityKindEnum.VK_PUBLIC ); result.setNamespace( namespace ); } else if ( lookedUp instanceof UmlClass ) { result = (UmlClass) lookedUp; } else { throw new IllegalArgumentException("Expected to lookup a UmlClass instance for the name: "+namespace.getName()+"."+simpleTypeName+" isntead of "+lookedUp); } return result; }
/** * Instantiate a public exception with the qualified name provided, but the Exceptions might be messed with the regular classes so they * are registered as DataTypes at the model level instead of UnlExceprion-s when they are also * reverse engineered. * @param qualifiedName of the exception to be created * @return the newly created public exception */ public Classifier constructException(String qualifiedName) { Classifier result = (Classifier) locateLocalModelElement( model, qualifiedName ); if ( result == null ) { // still not created, thus it is not included result = (Classifier) exceptionName.getMetaClass( extent ).refCreateInstance( null ); result.setName( qualifiedName ); result.setNamespace( model ); result.setVisibility( VisibilityKindEnum.VK_PUBLIC ); } return result; }
/** * This method creates the public interface in the package provided * * @param umlPackage the containing package * @param name is the name of the interface to create * @return the interface built */ public Interface constructInterface(Namespace umlPackage, String name) { Interface result = (Interface) locateLocalModelElement( umlPackage, name ); if ( result == null ) { // none found - build it result = (Interface) interfaceName.getMetaClass( extent ).refCreateInstance(null); result.setName( name ); result.setVisibility( VisibilityKindEnum.VK_PUBLIC ); result.setNamespace( umlPackage ); } return result; }
private AssociationEnd constructAssociationEnd(Classifier thisClass, String thisRole, int thisEndUpper, UmlAssociation result) { AssociationEnd thisEnd; thisEnd = (AssociationEnd) associationEnd.getMetaClass( extent ).refCreateInstance( null ); thisEnd.setName( thisRole ); thisEnd.setType( thisClass ); thisEnd.setVisibility( VisibilityKindEnum.VK_PUBLIC ); thisEnd.setAssociation( result ); thisEnd.setMultiplicity( constructMultiplicity( thisEndUpper ) ); return thisEnd; }
public UmlAssociation constructAssociation(Classifier thisClass, String thisRole, int thisEndUpper, boolean isComposition, boolean isThisNavigable, Classifier otherClass, String otherRole, int otherEndUpper, Namespace namespace, String documentation) { UmlAssociation result; AssociationEnd thisEnd; result = (UmlAssociation) association.getMetaClass( extent ).refCreateInstance( null ); result.setNamespace( namespace ); result.setName( "" ); result.setVisibility( VisibilityKindEnum.VK_PUBLIC ); // this end (the class with the associative attribute) thisEnd = constructAssociationEnd( thisClass, thisRole, thisEndUpper, result ); if ( isComposition ) { thisEnd.setAggregation( AggregationKindEnum.AK_COMPOSITE ); } constructAssociationEnd( otherClass, otherRole, otherEndUpper, result ); return result; }
/** * @param name not null name of the UML package to lookup/construct * @return not null UML package with the name provided from the current model */ public UmlPackage constructPackage(Name name) { UmlPackage result; UmlPackage namespace; if ( name.getOwner() == null ) { namespace = model; } else { namespace = constructPackage( name.getOwner() ); } result = (UmlPackage) locateLocalModelElement( namespace, name.getName() ); if ( result == null ) { // still not created, thus it is not included result = (UmlPackage) umlPackage.getMetaClass( extent ).refCreateInstance( null ); result.setName( name.getName() ); result.setNamespace( namespace ); } return result; }