package com.amig.maestro.patterns.core.servicedataobject; import com.ibm.xtools.patterns.framework.AbstractPatternLibrary; import com.ibm.xtools.patterns.framework.PatternIdentity; import com.ibm.xtools.patterns.framework.uml2.AbstractPatternDefinition; import com.ibm.xtools.patterns.framework.uml2.AbstractPatternInstance; import com.ibm.xtools.patterns.framework.PatternParameterIdentity; import com.ibm.xtools.patterns.framework.uml2.AbstractPatternParameter; import com.ibm.xtools.patterns.framework.AbstractPatternDependency; import com.ibm.xtools.patterns.framework.PatternParameterValue; import org.eclipse.uml2.*; /** * This class implements the Service Data Object, it extends * from the abstract pattern definition base class to gain most of the functionality needed to make * pattern definition specification in code easier. * * */ public class ServiceDataObject extends AbstractPatternDefinition { /** * DO NOT EDIT EXCEPT FOR THE USER DOC SECTION * NEEDS TO BE KEPT IN SYNC WITH THE PATTERN MANIFEST FILE * * * @generated */ private final static String PATTERN_ID = "com.amig.maestro.patterns.core.servicedataobject.ServiceDataObject"; //$NON-NLS-1$ /** * DO NOT EDIT EXCEPT FOR THE USER DOC SECTION * NEEDS TO BE KEPT IN SYNC WITH THE PATTERN MANIFEST FILE * * * @generated */ private final static String PATTERN_VER = "1.0.0"; //$NON-NLS-1$ /** * DO NOT EDIT EXCEPT FOR THE USER DOC SECTION * NEEDS TO BE KEPT IN SYNC WITH THE PATTERN MANIFEST FILE * * * @generated */ private final DataGraph dataGraph = new DataGraph(); /** * DO NOT EDIT EXCEPT FOR THE USER DOC SECTION * NEEDS TO BE KEPT IN SYNC WITH THE PATTERN MANIFEST FILE * * * @generated */ private final ChangeSummary changeSummary = new ChangeSummary( this.dataGraph); /** * DO NOT EDIT EXCEPT FOR THE USER DOC SECTION * NEEDS TO BE KEPT IN SYNC WITH THE PATTERN MANIFEST FILE * * * @generated */ private final DataObject dataObject = new DataObject(this.dataGraph); /** * DO NOT EDIT EXCEPT FOR THE USER DOC SECTION * NEEDS TO BE KEPT IN SYNC WITH THE PATTERN MANIFEST FILE * * * @generated */ private final Sequence sequence = new Sequence(this.dataObject); /** * DO NOT EDIT EXCEPT FOR THE USER DOC SECTION * NEEDS TO BE KEPT IN SYNC WITH THE PATTERN MANIFEST FILE * * * @generated */ private final Property property = new Property(this.sequence); /** * DO NOT EDIT EXCEPT FOR THE USER DOC SECTION * NEEDS TO BE KEPT IN SYNC WITH THE PATTERN MANIFEST FILE * * * @generated */ private final Type type = new Type(this.dataObject, this.property); /** * * * @generated */ public ServiceDataObject(AbstractPatternLibrary owningPatternLibrary) { super( new PatternIdentity(owningPatternLibrary, PATTERN_ID, PATTERN_VER)); // DO NOT EDIT } /** * This class implements the DataGraph, it extends * from the abstract pattern parameter base class to gain most of the functionality needed to make * pattern parameter specification in code easier. * * * @generated */ private class DataGraph extends AbstractPatternParameter { /** * DO NOT EDIT EXCEPT FOR THE USER DOC SECTION * NEEDS TO BE KEPT IN SYNC WITH THE PATTERN MANIFEST FILE * * * @generated */ private final static String PARAMETER_ID = "DataGraph"; //$NON-NLS-1$ /** * * * @generated */ DataGraph() { super(ServiceDataObject.this, new PatternParameterIdentity( PARAMETER_ID));// DO NOT EDIT } /** * This is the default general expand method that is typically implemented * by concrete pattern parameters for handling the added and maintained * expand variants which are usually similar. * * This method gets called during a pattern expansion for each new parameter * value that has been bound since last expansion, or for each exisitng value * in a reapply scenerio. * * The default behavior is to return true. * * * @generated */ public boolean expand(PatternParameterValue value) { System.out.println("InterfaceParameter.expand"); return true; } /** * The default behavior is to return true since removed value expansion is * optional but it is recommended that pattern parameters support this for * consistency with the patterns shipped in the product and a better user * experience for the patter applying user. * * This method gets called during a pattern expansion for each parameter * value that has been unbound since last expansion. * * * * @generated */ public boolean expand(PatternParameterValue.Removed value) { System.out.println("InterfaceParameter.expand removed"); return true; } } /** * This class implements the ChangeSummary, it extends * from the abstract pattern parameter base class to gain most of the functionality needed to make * pattern parameter specification in code easier. * * * @generated */ private class ChangeSummary extends AbstractPatternParameter { /** * DO NOT EDIT EXCEPT FOR THE USER DOC SECTION * NEEDS TO BE KEPT IN SYNC WITH THE PATTERN MANIFEST FILE * * * @generated */ private final static String PARAMETER_ID = "ChangeSummary"; //$NON-NLS-1$ /** * * * @generated */ ChangeSummary(DataGraph dataGraph) { super(ServiceDataObject.this, new PatternParameterIdentity( PARAMETER_ID));// DO NOT EDIT new ChangeSummary_DataGraphDependency(dataGraph); } /** * This is the default general expand method that is typically implemented * by concrete pattern parameters for handling the added and maintained * expand variants which are usually similar. * * This method gets called during a pattern expansion for each new parameter * value that has been bound since last expansion, or for each exisitng value * in a reapply scenerio. * * The default behavior is to return true. * * * @generated */ public boolean expand(PatternParameterValue value) { System.out.println("ChangeSummary.expand"); return true; } /** * The default behavior is to return true since removed value expansion is * optional but it is recommended that pattern parameters support this for * consistency with the patterns shipped in the product and a better user * experience for the patter applying user. * * This method gets called during a pattern expansion for each parameter * value that has been unbound since last expansion. * * * * @generated */ public boolean expand(PatternParameterValue.Removed value) { System.out.println("ChangeSummary.expand removed"); return true; } /** * * * @generated */ private class ChangeSummary_DataGraphDependency extends AbstractPatternDependency { /** * * * @generated */ private ChangeSummary_DataGraphDependency( AbstractPatternParameter dependency) { super(ChangeSummary.this, dependency); } /** * This method gets called during a pattern expansion for each pair * of new values that has been added to the dependent and dependency * parameter since last expansion as a result of binding a value to either * the dependent or dependency parameter. In a reapply scenerio, it gets * called for each pair of existing values bound to the parameters. * * Update the dependency using the dependent and dependency values as * provided. This is a hot-spot method and the default behavior if not * overridden is to do nothing more than return true. * * * @generated */ public boolean update(PatternParameterValue value, PatternParameterValue dependencyValue) { System.out.println("ChangeSummary_DataGraphDependency updated"); org.eclipse.uml2.Interface ChangeSummaryValue = (org.eclipse.uml2.Interface) value.getValue(); org.eclipse.uml2.Interface DataGraphValue = (org.eclipse.uml2.Interface) dependencyValue.getValue(); ChangeSummaryValue.createAssociation(false, AggregationKind.NONE_LITERAL, "", 1, 1, DataGraphValue, false, AggregationKind.COMPOSITE_LITERAL, "", 1, 1); return true; } /** * This method gets called during a pattern expansion for each pair * of values that has been removed from the dependent and dependency * parameter since last expansion as a result of unbinding a value from * the dependency parameter. * * Update the dependency using the dependent and dependency values as * provided. This is a hot-spot method and the default behavior if not * overridden is to do nothing more than return true. To support remove * behavior in pattern implementations this method would be overridden. In * most cases the implementation of this method would be very much like the * method variant with the types transposed. * * * @generated */ public boolean update(PatternParameterValue.Maintained value, PatternParameterValue.Removed dependencyValue) { System.out.println("ChangeSummary_DataGraphDependency maintained removed"); return true; } /** * This method gets called during a pattern expansion for each pair * of values that has been removed from the dependent and dependency * parameter since last expansion as a result of unbinding a value from * the dependent parameter. * * Update the dependency using the dependent and dependency values as * provided. This is a hot-spot method and the default behavior if not * overridden is to do nothing more than return true. To support remove * behavior in pattern implementations this method woul be overridden. In * most cases the implementation of this method would be very much like the * method variant with the types transposed. * * * @generated */ public boolean update(PatternParameterValue.Removed value, PatternParameterValue.Maintained dependencyValue) { System.out.println("ChangeSummary_DataGraphDependency removed maintained"); return true; } } } /** * This class implements the DataObject, it extends * from the abstract pattern parameter base class to gain most of the functionality needed to make * pattern parameter specification in code easier. * * * @generated */ private class DataObject extends AbstractPatternParameter { /** * DO NOT EDIT EXCEPT FOR THE USER DOC SECTION * NEEDS TO BE KEPT IN SYNC WITH THE PATTERN MANIFEST FILE * * * @generated */ private final static String PARAMETER_ID = "DataObject"; //$NON-NLS-1$ /** * * * @generated */ DataObject(DataGraph dataGraph) { super(ServiceDataObject.this, new PatternParameterIdentity( PARAMETER_ID));// DO NOT EDIT new DataObject_DataGraphDependency(dataGraph); } /** * This is the default general expand method that is typically implemented * by concrete pattern parameters for handling the added and maintained * expand variants which are usually similar. * * This method gets called during a pattern expansion for each new parameter * value that has been bound since last expansion, or for each exisitng value * in a reapply scenerio. * * The default behavior is to return true. * * * @generated */ public boolean expand(PatternParameterValue value) { System.out.println("DataObject.expand"); return true; } /** * The default behavior is to return true since removed value expansion is * optional but it is recommended that pattern parameters support this for * consistency with the patterns shipped in the product and a better user * experience for the patter applying user. * * This method gets called during a pattern expansion for each parameter * value that has been unbound since last expansion. * * * * @generated */ public boolean expand(PatternParameterValue.Removed value) { System.out.println("DataObject.expand removed"); return true; } /** * * * @generated */ private class DataObject_DataGraphDependency extends AbstractPatternDependency { /** * * * @generated */ private DataObject_DataGraphDependency( AbstractPatternParameter dependency) { super(DataObject.this, dependency); } /** * This method gets called during a pattern expansion for each pair * of new values that has been added to the dependent and dependency * parameter since last expansion as a result of binding a value to either * the dependent or dependency parameter. In a reapply scenerio, it gets * called for each pair of existing values bound to the parameters. * * Update the dependency using the dependent and dependency values as * provided. This is a hot-spot method and the default behavior if not * overridden is to do nothing more than return true. * * * @generated */ public boolean update(PatternParameterValue value, PatternParameterValue dependencyValue) { System.out.println("DataObject_DataGraphDependency updated"); org.eclipse.uml2.Interface DataObjectValue = (org.eclipse.uml2.Interface) value.getValue(); org.eclipse.uml2.Interface DataGraphValue = (org.eclipse.uml2.Interface) dependencyValue.getValue(); org.eclipse.uml2.Association associationRelationship = DataObjectValue.createAssociation(false, AggregationKind.NONE_LITERAL, "", 1, 1, DataGraphValue, false, AggregationKind.COMPOSITE_LITERAL, "", 0, 1); org.eclipse.uml2.Association associationRelationship2 = DataObjectValue.createAssociation(false, AggregationKind.COMPOSITE_LITERAL, "", 0, MultiplicityElement.UNLIMITED_UPPER_BOUND, DataObjectValue, false, AggregationKind.NONE_LITERAL, "container", 0, 1); /* AbstractPatternInstance instance = (AbstractPatternInstance) value.getOwningInstance(); instance.ensureInterfaceOperations(DataGraphValue, DataObjectValue); */ return true; } /** * This method gets called during a pattern expansion for each pair * of values that has been removed from the dependent and dependency * parameter since last expansion as a result of unbinding a value from * the dependency parameter. * * Update the dependency using the dependent and dependency values as * provided. This is a hot-spot method and the default behavior if not * overridden is to do nothing more than return true. To support remove * behavior in pattern implementations this method would be overridden. In * most cases the implementation of this method would be very much like the * method variant with the types transposed. * * * @generated */ public boolean update(PatternParameterValue.Maintained value, PatternParameterValue.Removed dependencyValue) { System.out.println("DataObject_DataGraphDependency maintained removed"); return true; } /** * This method gets called during a pattern expansion for each pair * of values that has been removed from the dependent and dependency * parameter since last expansion as a result of unbinding a value from * the dependent parameter. * * Update the dependency using the dependent and dependency values as * provided. This is a hot-spot method and the default behavior if not * overridden is to do nothing more than return true. To support remove * behavior in pattern implementations this method woul be overridden. In * most cases the implementation of this method would be very much like the * method variant with the types transposed. * * * @generated */ public boolean update(PatternParameterValue.Removed value, PatternParameterValue.Maintained dependencyValue) { System.out.println("DataObject_DataGraphDependency removed maintained"); return true; } } } /** * This class implements the Sequence, it extends * from the abstract pattern parameter base class to gain most of the functionality needed to make * pattern parameter specification in code easier. * * * @generated */ private class Sequence extends AbstractPatternParameter { /** * DO NOT EDIT EXCEPT FOR THE USER DOC SECTION * NEEDS TO BE KEPT IN SYNC WITH THE PATTERN MANIFEST FILE * * * @generated */ private final static String PARAMETER_ID = "Sequence"; //$NON-NLS-1$ /** * * * @generated */ Sequence(DataObject dataObject) { super(ServiceDataObject.this, new PatternParameterIdentity( PARAMETER_ID));// DO NOT EDIT new Sequence_DataObjectDependency(dataObject); } /** * This is the default general expand method that is typically implemented * by concrete pattern parameters for handling the added and maintained * expand variants which are usually similar. * * This method gets called during a pattern expansion for each new parameter * value that has been bound since last expansion, or for each exisitng value * in a reapply scenerio. * * The default behavior is to return true. * * * @generated */ public boolean expand(PatternParameterValue value) { System.out.println("Sequence.expand"); return true; } /** * The default behavior is to return true since removed value expansion is * optional but it is recommended that pattern parameters support this for * consistency with the patterns shipped in the product and a better user * experience for the patter applying user. * * This method gets called during a pattern expansion for each parameter * value that has been unbound since last expansion. * * * * @generated */ public boolean expand(PatternParameterValue.Removed value) { System.out.println("Sequence.expand removed"); return true; } /** * * * @generated */ private class Sequence_DataObjectDependency extends AbstractPatternDependency { /** * * * @generated */ private Sequence_DataObjectDependency( AbstractPatternParameter dependency) { super(Sequence.this, dependency); } /** * This method gets called during a pattern expansion for each pair * of new values that has been added to the dependent and dependency * parameter since last expansion as a result of binding a value to either * the dependent or dependency parameter. In a reapply scenerio, it gets * called for each pair of existing values bound to the parameters. * * Update the dependency using the dependent and dependency values as * provided. This is a hot-spot method and the default behavior if not * overridden is to do nothing more than return true. * * * @generated */ public boolean update(PatternParameterValue value, PatternParameterValue dependencyValue) { System.out.println("Sequence_DataObjectDependency updated"); org.eclipse.uml2.Interface SequenceValue = (org.eclipse.uml2.Interface) value.getValue(); org.eclipse.uml2.Interface DataObjectValue = (org.eclipse.uml2.Interface) dependencyValue.getValue(); org.eclipse.uml2.Association associationRelationship = SequenceValue.createAssociation(false, AggregationKind.NONE_LITERAL, "", 1, 1, DataObjectValue, false, AggregationKind.COMPOSITE_LITERAL, "", 0, MultiplicityElement.UNLIMITED_UPPER_BOUND); return true; } /** * This method gets called during a pattern expansion for each pair * of values that has been removed from the dependent and dependency * parameter since last expansion as a result of unbinding a value from * the dependency parameter. * * Update the dependency using the dependent and dependency values as * provided. This is a hot-spot method and the default behavior if not * overridden is to do nothing more than return true. To support remove * behavior in pattern implementations this method would be overridden. In * most cases the implementation of this method would be very much like the * method variant with the types transposed. * * * @generated */ public boolean update(PatternParameterValue.Maintained value, PatternParameterValue.Removed dependencyValue) { System.out.println("Sequence_DataObjectDependency maintained remove"); return true; } /** * This method gets called during a pattern expansion for each pair * of values that has been removed from the dependent and dependency * parameter since last expansion as a result of unbinding a value from * the dependent parameter. * * Update the dependency using the dependent and dependency values as * provided. This is a hot-spot method and the default behavior if not * overridden is to do nothing more than return true. To support remove * behavior in pattern implementations this method woul be overridden. In * most cases the implementation of this method would be very much like the * method variant with the types transposed. * * * @generated */ public boolean update(PatternParameterValue.Removed value, PatternParameterValue.Maintained dependencyValue) { System.out.println("Sequence_DataObjectDependency removed maintained"); return true; } } } /** * This class implements the Property, it extends * from the abstract pattern parameter base class to gain most of the functionality needed to make * pattern parameter specification in code easier. * * * @generated */ private class Property extends AbstractPatternParameter { /** * DO NOT EDIT EXCEPT FOR THE USER DOC SECTION * NEEDS TO BE KEPT IN SYNC WITH THE PATTERN MANIFEST FILE * * * @generated */ private final static String PARAMETER_ID = "Property"; //$NON-NLS-1$ /** * * * @generated */ Property(Sequence sequence) { super(ServiceDataObject.this, new PatternParameterIdentity( PARAMETER_ID));// DO NOT EDIT new Property_SequenceDependency(sequence); } /** * This is the default general expand method that is typically implemented * by concrete pattern parameters for handling the added and maintained * expand variants which are usually similar. * * This method gets called during a pattern expansion for each new parameter * value that has been bound since last expansion, or for each exisitng value * in a reapply scenerio. * * The default behavior is to return true. * * * @generated */ public boolean expand(PatternParameterValue value) { System.out.println("Property.expand"); return true; } /** * The default behavior is to return true since removed value expansion is * optional but it is recommended that pattern parameters support this for * consistency with the patterns shipped in the product and a better user * experience for the patter applying user. * * This method gets called during a pattern expansion for each parameter * value that has been unbound since last expansion. * * * * @generated */ public boolean expand(PatternParameterValue.Removed value) { System.out.println("Property.expand removed"); return true; } /** * * * @generated */ private class Property_SequenceDependency extends AbstractPatternDependency { /** * * * @generated */ private Property_SequenceDependency( AbstractPatternParameter dependency) { super(Property.this, dependency); } /** * This method gets called during a pattern expansion for each pair * of new values that has been added to the dependent and dependency * parameter since last expansion as a result of binding a value to either * the dependent or dependency parameter. In a reapply scenerio, it gets * called for each pair of existing values bound to the parameters. * * Update the dependency using the dependent and dependency values as * provided. This is a hot-spot method and the default behavior if not * overridden is to do nothing more than return true. * * * @generated */ public boolean update(PatternParameterValue value, PatternParameterValue dependencyValue) { System.out.println("Property_SequenceDependency updated"); org.eclipse.uml2.Interface PropertyValue = (org.eclipse.uml2.Interface) value.getValue(); org.eclipse.uml2.Interface SequenceValue = (org.eclipse.uml2.Interface) dependencyValue.getValue(); org.eclipse.uml2.Association associationRelationship = PropertyValue.createAssociation(false, AggregationKind.NONE_LITERAL, "", 1, 1, SequenceValue, true, AggregationKind.NONE_LITERAL, "", 0, MultiplicityElement.UNLIMITED_UPPER_BOUND); return true; } /** * This method gets called during a pattern expansion for each pair * of values that has been removed from the dependent and dependency * parameter since last expansion as a result of unbinding a value from * the dependency parameter. * * Update the dependency using the dependent and dependency values as * provided. This is a hot-spot method and the default behavior if not * overridden is to do nothing more than return true. To support remove * behavior in pattern implementations this method would be overridden. In * most cases the implementation of this method would be very much like the * method variant with the types transposed. * * * @generated */ public boolean update(PatternParameterValue.Maintained value, PatternParameterValue.Removed dependencyValue) { System.out.println("Property_SequenceDependency maintained removed"); return true; } /** * This method gets called during a pattern expansion for each pair * of values that has been removed from the dependent and dependency * parameter since last expansion as a result of unbinding a value from * the dependent parameter. * * Update the dependency using the dependent and dependency values as * provided. This is a hot-spot method and the default behavior if not * overridden is to do nothing more than return true. To support remove * behavior in pattern implementations this method woul be overridden. In * most cases the implementation of this method would be very much like the * method variant with the types transposed. * * * @generated */ public boolean update(PatternParameterValue.Removed value, PatternParameterValue.Maintained dependencyValue) { System.out.println("Property_SequenceDependency removed maintained"); return true; } } } /** * This class implements the Type, it extends * from the abstract pattern parameter base class to gain most of the functionality needed to make * pattern parameter specification in code easier. * * * @generated */ private class Type extends AbstractPatternParameter { /** * DO NOT EDIT EXCEPT FOR THE USER DOC SECTION * NEEDS TO BE KEPT IN SYNC WITH THE PATTERN MANIFEST FILE * * * @generated */ private final static String PARAMETER_ID = "Type"; //$NON-NLS-1$ /** * * * @generated */ Type(DataObject dataObject, Property property) { super(ServiceDataObject.this, new PatternParameterIdentity( PARAMETER_ID));// DO NOT EDIT new Type_DataObjectDependency(dataObject); new Type_PropertyDependency(property); } /** * This is the default general expand method that is typically implemented * by concrete pattern parameters for handling the added and maintained * expand variants which are usually similar. * * This method gets called during a pattern expansion for each new parameter * value that has been bound since last expansion, or for each exisitng value * in a reapply scenerio. * * The default behavior is to return true. * * * @generated */ public boolean expand(PatternParameterValue value) { System.out.println("Type.expand"); return true; } /** * The default behavior is to return true since removed value expansion is * optional but it is recommended that pattern parameters support this for * consistency with the patterns shipped in the product and a better user * experience for the patter applying user. * * This method gets called during a pattern expansion for each parameter * value that has been unbound since last expansion. * * * * @generated */ public boolean expand(PatternParameterValue.Removed value) { System.out.println("Type.expand removed"); return true; } /** * * * @generated */ private class Type_DataObjectDependency extends AbstractPatternDependency { /** * * * @generated */ private Type_DataObjectDependency( AbstractPatternParameter dependency) { super(Type.this, dependency); } /** * This method gets called during a pattern expansion for each pair * of new values that has been added to the dependent and dependency * parameter since last expansion as a result of binding a value to either * the dependent or dependency parameter. In a reapply scenerio, it gets * called for each pair of existing values bound to the parameters. * * Update the dependency using the dependent and dependency values as * provided. This is a hot-spot method and the default behavior if not * overridden is to do nothing more than return true. * * * @generated */ public boolean update(PatternParameterValue value, PatternParameterValue dependencyValue) { System.out.println("Type_DataObjectDependency updated"); org.eclipse.uml2.Interface TypeValue = (org.eclipse.uml2.Interface) value.getValue(); org.eclipse.uml2.Interface DataObjectValue = (org.eclipse.uml2.Interface) dependencyValue.getValue(); org.eclipse.uml2.Association associationRelationship = TypeValue.createAssociation(false, AggregationKind.NONE_LITERAL, "", 0, 1, DataObjectValue, true, AggregationKind.NONE_LITERAL, "type", 1, 1); return true; } /** * This method gets called during a pattern expansion for each pair * of values that has been removed from the dependent and dependency * parameter since last expansion as a result of unbinding a value from * the dependency parameter. * * Update the dependency using the dependent and dependency values as * provided. This is a hot-spot method and the default behavior if not * overridden is to do nothing more than return true. To support remove * behavior in pattern implementations this method would be overridden. In * most cases the implementation of this method would be very much like the * method variant with the types transposed. * * * @generated */ public boolean update(PatternParameterValue.Maintained value, PatternParameterValue.Removed dependencyValue) { System.out.println("Type_DataObjectDependency maintained removed"); return true; } /** * This method gets called during a pattern expansion for each pair * of values that has been removed from the dependent and dependency * parameter since last expansion as a result of unbinding a value from * the dependent parameter. * * Update the dependency using the dependent and dependency values as * provided. This is a hot-spot method and the default behavior if not * overridden is to do nothing more than return true. To support remove * behavior in pattern implementations this method woul be overridden. In * most cases the implementation of this method would be very much like the * method variant with the types transposed. * * * @generated */ public boolean update(PatternParameterValue.Removed value, PatternParameterValue.Maintained dependencyValue) { System.out.println("Type_DataObjectDependency removed maintained"); return true; } } /** * * * @generated */ private class Type_PropertyDependency extends AbstractPatternDependency { /** * * * @generated */ private Type_PropertyDependency(AbstractPatternParameter dependency) { super(Type.this, dependency); } /** * This method gets called during a pattern expansion for each pair * of new values that has been added to the dependent and dependency * parameter since last expansion as a result of binding a value to either * the dependent or dependency parameter. In a reapply scenerio, it gets * called for each pair of existing values bound to the parameters. * * Update the dependency using the dependent and dependency values as * provided. This is a hot-spot method and the default behavior if not * overridden is to do nothing more than return true. * * * @generated */ public boolean update(PatternParameterValue value, PatternParameterValue dependencyValue) { System.out.println("Type_PropertyDependency updated"); org.eclipse.uml2.Interface TypeValue = (org.eclipse.uml2.Interface) value.getValue(); org.eclipse.uml2.Interface DataObjectValue = (org.eclipse.uml2.Interface) dependencyValue.getValue(); org.eclipse.uml2.Association associationRelationship = TypeValue.createAssociation(false, AggregationKind.COMPOSITE_LITERAL, "property", 0, MultiplicityElement.UNLIMITED_UPPER_BOUND, DataObjectValue, false, AggregationKind.NONE_LITERAL, "", 1, 1); org.eclipse.uml2.Association associationRelationship2 = TypeValue.createAssociation(false, AggregationKind.NONE_LITERAL, "", 0, 1, DataObjectValue, true, AggregationKind.NONE_LITERAL, "type", 1, 1); return true; } /** * This method gets called during a pattern expansion for each pair * of values that has been removed from the dependent and dependency * parameter since last expansion as a result of unbinding a value from * the dependency parameter. * * Update the dependency using the dependent and dependency values as * provided. This is a hot-spot method and the default behavior if not * overridden is to do nothing more than return true. To support remove * behavior in pattern implementations this method would be overridden. In * most cases the implementation of this method would be very much like the * method variant with the types transposed. * * * @generated */ public boolean update(PatternParameterValue.Maintained value, PatternParameterValue.Removed dependencyValue) { System.out.println("Type_PropertyDependency maintained removed"); return true; } /** * This method gets called during a pattern expansion for each pair * of values that has been removed from the dependent and dependency * parameter since last expansion as a result of unbinding a value from * the dependent parameter. * * Update the dependency using the dependent and dependency values as * provided. This is a hot-spot method and the default behavior if not * overridden is to do nothing more than return true. To support remove * behavior in pattern implementations this method woul be overridden. In * most cases the implementation of this method would be very much like the * method variant with the types transposed. * * * @generated */ public boolean update(PatternParameterValue.Removed value, PatternParameterValue.Maintained dependencyValue) { System.out.println("Type_PropertyDependency removed maintained"); return true; } } } }