/**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 @Override
 public EObject create(EClass eClass) {
   switch (eClass.getClassifierID()) {
     case DslFilterPackage.ALL_FILTERS:
       return createAllFilters();
     case DslFilterPackage.FILTER_GROUP:
       return createFilterGroup();
     case DslFilterPackage.FILTER:
       return createFilter();
     case DslFilterPackage.CNUMBER_OPERATION:
       return createCNumberOperation();
     case DslFilterPackage.CSTRING_OPERATION:
       return createCStringOperation();
     case DslFilterPackage.CSTRUCTURAL_EOBJECT:
       return createCStructuralEObject();
     case DslFilterPackage.CLOGIC_OPERATION:
       return createCLogicOperation();
     case DslFilterPackage.INT_TO_EOBJECT_MAP:
       return (EObject) createIntToEObjectMap();
     case DslFilterPackage.BASIC_CSTRING_OPERATION:
       return createBasicCStringOperation();
     case DslFilterPackage.BASIC_CNUMBER_OPERATION:
       return createBasicCNumberOperation();
     case DslFilterPackage.BASIC_CLOGIC_OPERATION:
       return createBasicCLogicOperation();
     default:
       throw new IllegalArgumentException(
           "The class '" + eClass.getName() + "' is not a valid classifier");
   }
 }
Example #2
0
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 @Override
 public EObject create(EClass eClass) {
   switch (eClass.getClassifierID()) {
     case WorkspacePackage.WORKSPACE_CONTEXT:
       return createWorkspaceContext();
     case WorkspacePackage.WS_FILE:
       return createWSFile();
     case WorkspacePackage.WS_FOLDER:
       return createWSFolder();
     case WorkspacePackage.WS_PROJECT:
       return createWSProject();
     case WorkspacePackage.WS_ROOT:
       return createWSRoot();
     case WorkspacePackage.WS_LINK:
       return createWSLink();
     case WorkspacePackage.WS_FILE_LINK:
       return createWSFileLink();
     case WorkspacePackage.WS_FOLDER_LINK:
       return createWSFolderLink();
     case WorkspacePackage.WS_PROJECT_LINK:
       return createWSProjectLink();
     default:
       throw new IllegalArgumentException(
           "The class '" + eClass.getName() + "' is not a valid classifier");
   }
 }
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 @Override
 public EObject create(EClass eClass) {
   switch (eClass.getClassifierID()) {
     case DocumentationPackage.BOOK:
       return createBook();
     case DocumentationPackage.PARAGRAPH:
       return createParagraph();
     case DocumentationPackage.SECTION:
       return createSection();
     case DocumentationPackage.TEXTUAL_VALUE:
       return createTextualValue();
     case DocumentationPackage.ITEMIZED_LIST_VALUE:
       return createItemizedListValue();
     case DocumentationPackage.ITEMIZED_LIST_VALUE_ITEM:
       return createItemizedListValueItem();
     case DocumentationPackage.EMPHASIS_VALUE:
       return createEmphasisValue();
     case DocumentationPackage.XREF_VALUE:
       return createXRefValue();
     case DocumentationPackage.INFORMAL_TABLE_VALUE:
       return createInformalTableValue();
     case DocumentationPackage.INFORMAL_TABLE_VALUE_ROW:
       return createInformalTableValueRow();
     default:
       throw new IllegalArgumentException(
           "The class '" + eClass.getName() + "' is not a valid classifier");
   }
 }
Example #4
0
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 @Override
 public EObject create(EClass eClass) {
   switch (eClass.getClassifierID()) {
     case UnorderedGroupsTestPackage.MODEL:
       return createModel();
     case UnorderedGroupsTestPackage.SIMPLE_MODEL:
       return createSimpleModel();
     case UnorderedGroupsTestPackage.MANDATORY_MODEL:
       return createMandatoryModel();
     case UnorderedGroupsTestPackage.LOOPED_MODEL:
       return createLoopedModel();
     case UnorderedGroupsTestPackage.GROUP_LOOPED_MODEL:
       return createGroupLoopedModel();
     case UnorderedGroupsTestPackage.LOOPED_ALTERNATIVE_MODEL:
       return createLoopedAlternativeModel();
     case UnorderedGroupsTestPackage.BUG304681_MODEL:
       return createBug304681Model();
     case UnorderedGroupsTestPackage.BUG304681_FEATURE:
       return createBug304681Feature();
     case UnorderedGroupsTestPackage.BUG304681_ATTRIBUTE:
       return createBug304681Attribute();
     case UnorderedGroupsTestPackage.BUG304681_REFERENCE:
       return createBug304681Reference();
     default:
       throw new IllegalArgumentException(
           "The class '" + eClass.getName() + "' is not a valid classifier");
   }
 }
Example #5
0
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 @Override
 public EObject create(EClass eClass) {
   switch (eClass.getClassifierID()) {
     case XsdPackage.SEQUENCE:
       return createSequence();
     case XsdPackage.CHOICE:
       return createChoice();
     case XsdPackage.COMPLEX_TYPE:
       return createComplexType();
     case XsdPackage.ELEMENT_DEFINITION:
       return createElementDefinition();
     case XsdPackage.ATTRIBUTE:
       return createAttribute();
     case XsdPackage.ANY:
       return createAny();
     case XsdPackage.GROUP:
       return createGroup();
     case XsdPackage.ANNOTATION:
       return createAnnotation();
     case XsdPackage.NOTATION:
       return createNotation();
     case XsdPackage.SIMPLE_TYPE:
       return createSimpleType();
     case XsdPackage.ELEMENT_REFERENCE:
       return createElementReference();
     case XsdPackage.SIMPLE_CONTENT:
       return createSimpleContent();
     case XsdPackage.COMPLEX_CONTENT:
       return createComplexContent();
     default:
       throw new IllegalArgumentException(
           "The class '" + eClass.getName() + "' is not a valid classifier");
   }
 }
 /**
  * Wraps an object in a {@link ModelObject}.
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @param eClass the EClass of the object
  * @param adaptee the object being wrapped/adapted
  * @return the wrapper {@link ModelObject}
  * @generated
  */
 @SuppressWarnings({"unchecked", "rawtypes"})
 public <T> ModelObject<T> createModelObject(EClass eClass, T adaptee) {
   ModelObject<Object> modelObject = null;
   switch (eClass.getClassifierID()) {
     case SubstitutionzvonModelPackage.COMPLEXAAA_CLASSIFIER_ID:
       modelObject = new ComplexAAAModelObject();
       break;
     case SubstitutionzvonModelPackage.COMPLEXEVENTYPE_CLASSIFIER_ID:
       modelObject = new ComplexEvenTypeModelObject();
       break;
     case SubstitutionzvonModelPackage.COMPLEXODDTYPE_CLASSIFIER_ID:
       modelObject = new ComplexOddTypeModelObject();
       break;
     case SubstitutionzvonModelPackage.DOCUMENTROOT_CLASSIFIER_ID:
       modelObject = new DocumentRootModelObject();
       break;
     case SubstitutionzvonModelPackage.ROOTTYPE_CLASSIFIER_ID:
       modelObject = new RootTypeModelObject();
       break;
     default:
       throw new IllegalArgumentException(
           "The EClass '" + eClass + "' is not defined in this EPackage");
   }
   modelObject.setTarget(adaptee);
   return (ModelObject<T>) modelObject;
 }
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 @Override
 public EObject create(EClass eClass) {
   switch (eClass.getClassifierID()) {
     case EXTLibraryPackage.BOOK:
       return createBook();
     case EXTLibraryPackage.LIBRARY:
       return createLibrary();
     case EXTLibraryPackage.WRITER:
       return createWriter();
     case EXTLibraryPackage.PERIODICAL:
       return createPeriodical();
     case EXTLibraryPackage.BOOK_ON_TAPE:
       return createBookOnTape();
     case EXTLibraryPackage.VIDEO_CASSETTE:
       return createVideoCassette();
     case EXTLibraryPackage.BORROWER:
       return createBorrower();
     case EXTLibraryPackage.PERSON:
       return createPerson();
     case EXTLibraryPackage.EMPLOYEE:
       return createEmployee();
     default:
       throw new IllegalArgumentException(
           "The class '"
               + eClass.getName()
               + "' is not a valid classifier"); //$NON-NLS-1$ //$NON-NLS-2$
   }
 }
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 @Override
 public EObject create(EClass eClass) {
   switch (eClass.getClassifierID()) {
     case ConceptualPackage.CONCEPTUAL_MODEL:
       return createConceptualModel();
     case ConceptualPackage.TERM_UNIT:
       return createTermUnit();
     case ConceptualPackage.CONCEPTUAL_CONTAINER:
       return createConceptualContainer();
     case ConceptualPackage.FACT_UNIT:
       return createFactUnit();
     case ConceptualPackage.CONCEPTUAL_RELATIONSHIP:
       return createConceptualRelationship();
     case ConceptualPackage.BEHAVIOR_UNIT:
       return createBehaviorUnit();
     case ConceptualPackage.RULE_UNIT:
       return createRuleUnit();
     case ConceptualPackage.SCENARIO_UNIT:
       return createScenarioUnit();
     case ConceptualPackage.CONCEPTUAL_FLOW:
       return createConceptualFlow();
     case ConceptualPackage.CONCEPTUAL_ELEMENT:
       return createConceptualElement();
     case ConceptualPackage.CONCEPTUAL_ROLE:
       return createConceptualRole();
     default:
       throw new IllegalArgumentException(
           "The class '" + eClass.getName() + "' is not a valid classifier");
   }
 }
Example #9
0
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 @Override
 public EObject create(EClass eClass) {
   switch (eClass.getClassifierID()) {
     case RuntimePackage.EXTENDET_DATA:
       return createExtendetData();
     case RuntimePackage.ENVIORMENT:
       return createEnviorment();
     case RuntimePackage.RUNTIME_CHARACTER:
       return createRuntimeCharacter();
     case RuntimePackage.TEAM:
       return createTeam();
     case RuntimePackage.GRUNT_TEAM:
       return createGruntTeam();
     case RuntimePackage.GRUNT_RUNTIME_CHARACTER:
       return createGruntRuntimeCharacter();
     case RuntimePackage.DRONE:
       return createDrone();
     case RuntimePackage.MATRIX_DEVICE:
       return createMatrixDevice();
     case RuntimePackage.RIGGER_CONSOLE:
       return createRiggerConsole();
     case RuntimePackage.CYBERDECK:
       return createCyberdeck();
     default:
       throw new IllegalArgumentException(
           "The class '" + eClass.getName() + "' is not a valid classifier");
   }
 }
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 @Override
 public EObject create(EClass eClass) {
   switch (eClass.getClassifierID()) {
     case CommandsPackageImpl.BINDING_CONTEXT:
       return (EObject) createBindingContext();
     case CommandsPackageImpl.BINDING_TABLE:
       return (EObject) createBindingTable();
     case CommandsPackageImpl.COMMAND:
       return (EObject) createCommand();
     case CommandsPackageImpl.COMMAND_PARAMETER:
       return (EObject) createCommandParameter();
     case CommandsPackageImpl.HANDLER:
       return (EObject) createHandler();
     case CommandsPackageImpl.KEY_BINDING:
       return (EObject) createKeyBinding();
     case CommandsPackageImpl.PARAMETER:
       return (EObject) createParameter();
     case CommandsPackageImpl.CATEGORY:
       return (EObject) createCategory();
     default:
       throw new IllegalArgumentException(
           "The class '"
               + eClass.getName()
               + "' is not a valid classifier"); //$NON-NLS-1$ //$NON-NLS-2$
   }
 }
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 @Override
 public EObject create(EClass eClass) {
   switch (eClass.getClassifierID()) {
     case ComponentsPackage.COMPONENT:
       return createComponent();
     case ComponentsPackage.PORT:
       return createPort();
     case ComponentsPackage.CAPABILITY:
       return createCapability();
     case ComponentsPackage.REQUIREMENT:
       return createRequirement();
     case ComponentsPackage.PROPERTY:
       return createProperty();
     case ComponentsPackage.COMPONENT_ASSEMBLY:
       return createComponentAssembly();
     case ComponentsPackage.PROPERTY_CONNECTOR:
       return createPropertyConnector();
     case ComponentsPackage.PORT_CONNECTOR:
       return createPortConnector();
     case ComponentsPackage.EXTERNAL_REFERENCE:
       return createExternalReference();
     case ComponentsPackage.MONOLITHIC_IMPLEMENTATION:
       return createMonolithicImplementation();
     default:
       throw new IllegalArgumentException(
           "The class '" + eClass.getName() + "' is not a valid classifier");
   }
 }
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 @Override
 public EObject create(EClass eClass) {
   switch (eClass.getClassifierID()) {
     case DpdPackage.AUTHOR:
       return createAuthor();
     case DpdPackage.CHILD_HW_DEVICE:
       return createChildHwDevice();
     case DpdPackage.DEVICE_CLASS:
       return createDeviceClass();
     case DpdPackage.DEVICE_PKG:
       return createDevicePkg();
     case DpdPackage.DEVICE_PKG_REF:
       return createDevicePkgRef();
     case DpdPackage.DOCUMENT_ROOT:
       return createDocumentRoot();
     case DpdPackage.HW_DEVICE_REGISTRATION:
       return createHwDeviceRegistration();
     case DpdPackage.LOCAL_FILE:
       return createLocalFile();
     case DpdPackage.PROPERTY_FILE:
       return createPropertyFile();
     default:
       throw new IllegalArgumentException(
           "The class '" + eClass.getName() + "' is not a valid classifier");
   }
 }
Example #13
0
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 @Override
 public EObject create(EClass eClass) {
   switch (eClass.getClassifierID()) {
     case RuntimePackage.WORKFLOW_CONTEXT:
       return createWorkflowContext();
     case RuntimePackage.WORKFLOW_ENGINE:
       return createWorkflowEngine();
     case RuntimePackage.WORKFLOW_STATE_MAP:
       return (EObject) createWorkflowStateMap();
     case RuntimePackage.WORKFLOW_PARAMETER_MAP:
       return (EObject) createWorkflowParameterMap();
     case RuntimePackage.WORKFLOW_PARAMETER_VALUE_PROXY:
       return createWorkflowParameterValueProxy();
     case RuntimePackage.WORKFLOW_STATE_RESOLUTION_STRATEGY:
       return createWorkflowStateResolutionStrategy();
     case RuntimePackage.WORKFLOW_RUNNABLE:
       return (EObject) createWorkflowRunnable();
     case RuntimePackage.WORKFLOW_RUNNER:
       return createWorkflowRunner();
     case RuntimePackage.WORKFLOW_LOG:
       return createWorkflowLog();
     case RuntimePackage.WORKFLOW_LOG_ENTRY:
       return createWorkflowLogEntry();
     case RuntimePackage.WORKFLOW_LOG_MAP:
       return (EObject) createWorkflowLogMap();
     case RuntimePackage.WORKFLOW_COMPONENT_EXECUTION_INFO:
       return createWorkflowComponentExecutionInfo();
     case RuntimePackage.WORKFLOW_COMPONENT_EXECUTION_INFO_MAP:
       return (EObject) createWorkflowComponentExecutionInfoMap();
     default:
       throw new IllegalArgumentException(
           "The class '" + eClass.getName() + "' is not a valid classifier");
   }
 }
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 @Override
 public EObject create(EClass eClass) {
   switch (eClass.getClassifierID()) {
     case NplPackage.DECLARATION:
       return createDeclaration();
     case NplPackage.IMAGES_COUNT:
       return createImagesCount();
     case NplPackage.FONT_SIZE:
       return createFontSize();
     case NplPackage.FORMAT:
       return createFormat();
     case NplPackage.DATE:
       return createDate();
     case NplPackage.LANGUAGE:
       return createLanguage();
     case NplPackage.PRICE:
       return createPrice();
     case NplPackage.CURRENCY:
       return createCurrency();
     case NplPackage.TOPIC:
       return createTopic();
     case NplPackage.PAIR:
       return createPair();
     default:
       throw new IllegalArgumentException(
           "The class '" + eClass.getName() + "' is not a valid classifier");
   }
 }
Example #15
0
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 @Override
 public EObject create(EClass eClass) {
   switch (eClass.getClassifierID()) {
     case WikimPackage.CATEGORY:
       return createCategory();
     case WikimPackage.WIKI_CONTENT:
       return createWikiContent();
     case WikimPackage.SECTION:
       return createSection();
     case WikimPackage.WIKI_DATABASE:
       return createWikiDatabase();
     case WikimPackage.ARTICLE:
       return createArticle();
     case WikimPackage.IMAGE:
       return createImage();
     case WikimPackage.PARAGRAPH:
       return createParagraph();
     case WikimPackage.ITEM_LIST:
       return createItemList();
     case WikimPackage.ITEM:
       return createItem();
     case WikimPackage.FILE:
       return createFile();
     case WikimPackage.USER:
       return createUser();
     default:
       throw new IllegalArgumentException(
           "The class '" + eClass.getName() + "' is not a valid classifier");
   }
 }
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 @Override
 public EObject create(EClass eClass) {
   switch (eClass.getClassifierID()) {
     case UiextensionmodelPackage.ACTIVITY_EXTENSION:
       return createActivityExtension();
     case UiextensionmodelPackage.CASE_EXTENSION:
       return createCaseExtension();
     case UiextensionmodelPackage.COPY_EXTENSION:
       return createCopyExtension();
     case UiextensionmodelPackage.END_NODE:
       return createEndNode();
     case UiextensionmodelPackage.LINK_EXTENSION:
       return createLinkExtension();
     case UiextensionmodelPackage.ON_ALARM_EXTENSION:
       return createOnAlarmExtension();
     case UiextensionmodelPackage.ON_EVENT_EXTENSION:
       return createOnEventExtension();
     case UiextensionmodelPackage.ON_MESSAGE_EXTENSION:
       return createOnMessageExtension();
     case UiextensionmodelPackage.PARTNER_LINK_EXTENSION:
       return createPartnerLinkExtension();
     case UiextensionmodelPackage.PROCESS_EXTENSION:
       return createProcessExtension();
     case UiextensionmodelPackage.REFERENCE_PARTNER_LINKS:
       return createReferencePartnerLinks();
     case UiextensionmodelPackage.START_NODE:
       return createStartNode();
     case UiextensionmodelPackage.VARIABLE_EXTENSION:
       return createVariableExtension();
     default:
       throw new IllegalArgumentException(
           "The class '" + eClass.getName() + "' is not a valid classifier");
   }
 }
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 @Override
 public EObject create(EClass eClass) {
   switch (eClass.getClassifierID()) {
     default:
       throw new IllegalArgumentException(
           "The class '" + eClass.getName() + "' is not a valid classifier");
   }
 }
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 @Override
 public EObject create(EClass eClass) {
   switch (eClass.getClassifierID()) {
     case ArduinoPackage.HARDWARE:
       return createHardware();
     case ArduinoPackage.PLATFORM:
       return createPlatform();
     case ArduinoPackage.DIGITAL_PIN:
       return createDigitalPin();
     case ArduinoPackage.ANALOG_PIN:
       return createAnalogPin();
     case ArduinoPackage.SKETCH:
       return createSketch();
     case ArduinoPackage.PROJECT:
       return createProject();
     case ArduinoPackage.STATUS:
       return createStatus();
     case ArduinoPackage.LEVEL:
       return createLevel();
     case ArduinoPackage.DELAY:
       return createDelay();
     case ArduinoPackage.INPUT_MODULE:
       return createInputModule();
     case ArduinoPackage.OUTPUT_MODULE:
       return createOutputModule();
     case ArduinoPackage.CONNECTOR:
       return createConnector();
     case ArduinoPackage.REPEAT:
       return createRepeat();
     case ArduinoPackage.SENSOR:
       return createSensor();
     case ArduinoPackage.WHILE:
       return createWhile();
     case ArduinoPackage.VARIABLE:
       return createVariable();
     case ArduinoPackage.SET:
       return createSet();
     case ArduinoPackage.NUMERICAL_OPERATOR:
       return createNumericalOperator();
     case ArduinoPackage.BOOLEAN_OPERATOR:
       return createBooleanOperator();
     case ArduinoPackage.CONSTANT:
       return createConstant();
     case ArduinoPackage.IF:
       return createIf();
     case ArduinoPackage.FUNCTION:
       return createFunction();
     case ArduinoPackage.PARAMETER_DEFINITION:
       return createParameterDefinition();
     case ArduinoPackage.FUNCTION_CALL:
       return createFunctionCall();
     case ArduinoPackage.PARAMETER_CALL:
       return createParameterCall();
     default:
       throw new IllegalArgumentException(
           "The class '" + eClass.getName() + "' is not a valid classifier");
   }
 }
Example #19
0
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 @Override
 public EObject create(EClass eClass) {
   switch (eClass.getClassifierID()) {
     case TextbtPackage.TEXT_BT:
       return createTextBT();
     case TextbtPackage.REQUIREMENT_LIST:
       return createRequirementList();
     case TextbtPackage.REQUIREMENT:
       return createRequirement();
     case TextbtPackage.COMPONENT_LIST:
       return createComponentList();
     case TextbtPackage.COMPONENT:
       return createComponent();
     case TextbtPackage.SYSTEM_COMPONENT:
       return createSystemComponent();
     case TextbtPackage.OPTION_LIST:
       return createOptionList();
     case TextbtPackage.OPTION:
       return createOption();
     case TextbtPackage.BEHAVIOR_TREE:
       return createBehaviorTree();
     case TextbtPackage.RELATIONAL_BEHAVIOR:
       return createRelationalBehavior();
     case TextbtPackage.RELATION:
       return createRelation();
     case TextbtPackage.STATE:
       return createState();
     case TextbtPackage.SELECTION:
       return createSelection();
     case TextbtPackage.EVENT:
       return createEvent();
     case TextbtPackage.GUARD:
       return createGuard();
     case TextbtPackage.INTERNAL_INPUT:
       return createInternalInput();
     case TextbtPackage.INTERNAL_OUTPUT:
       return createInternalOutput();
     case TextbtPackage.EXTERNAL_INPUT:
       return createExternalInput();
     case TextbtPackage.EXTERNAL_OUTPUT:
       return createExternalOutput();
     case TextbtPackage.ASSERTION:
       return createAssertion();
     case TextbtPackage.NODE:
       return createNode();
     case TextbtPackage.SEQUENTIAL_NODE:
       return createSequentialNode();
     case TextbtPackage.ATOMIC_NODE:
       return createAtomicNode();
     case TextbtPackage.PARALLEL_BLOCK:
       return createParallelBlock();
     case TextbtPackage.ALTERNATIVE_BLOCK:
       return createAlternativeBlock();
     default:
       throw new IllegalArgumentException(
           "The class '" + eClass.getName() + "' is not a valid classifier");
   }
 }
Example #20
0
 /**
  * Creates an instance for an {@link EClass}
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @param eClass creates a Object instance for this EClass
  * @return an object representing the eClass
  * @generated
  */
 public Object create(EClass eClass) {
   switch (eClass.getClassifierID()) {
     case ListModelPackage.STATESBYCOUNTRY_CLASSIFIER_ID:
       return createStatesByCountry();
     default:
       throw new IllegalArgumentException(
           "The EClass '" + eClass.getName() + "' is not a valid EClass for this EPackage");
   }
 }
Example #21
0
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 @Override
 public EObject create(EClass eClass) {
   switch (eClass.getClassifierID()) {
     case Model6Package.ROOT:
       return createRoot();
     case Model6Package.BASE_OBJECT:
       return createBaseObject();
     case Model6Package.REFERENCE_OBJECT:
       return createReferenceObject();
     case Model6Package.CONTAINMENT_OBJECT:
       return createContainmentObject();
     case Model6Package.UNORDERED_LIST:
       return createUnorderedList();
     case Model6Package.PROPERTIES_MAP:
       return createPropertiesMap();
     case Model6Package.PROPERTIES_MAP_ENTRY:
       return (EObject) createPropertiesMapEntry();
     case Model6Package.PROPERTIES_MAP_ENTRY_VALUE:
       return createPropertiesMapEntryValue();
     case Model6Package.A:
       return createA();
     case Model6Package.B:
       return createB();
     case Model6Package.C:
       return createC();
     case Model6Package.D:
       return createD();
     case Model6Package.E:
       return createE();
     case Model6Package.F:
       return createF();
     case Model6Package.G:
       return createG();
     case Model6Package.MY_ENUM_LIST:
       return createMyEnumList();
     case Model6Package.MY_ENUM_LIST_UNSETTABLE:
       return createMyEnumListUnsettable();
     case Model6Package.HOLDER:
       return createHolder();
     case Model6Package.THING:
       return createThing();
     case Model6Package.HAS_NILLABLE_ATTRIBUTE:
       return createHasNillableAttribute();
     case Model6Package.EMPTY_STRING_DEFAULT:
       return createEmptyStringDefault();
     case Model6Package.EMPTY_STRING_DEFAULT_UNSETTABLE:
       return createEmptyStringDefaultUnsettable();
     case Model6Package.UNSETTABLE_ATTRIBUTES:
       return createUnsettableAttributes();
     case Model6Package.CAN_REFERENCE_LEGACY:
       return createCanReferenceLegacy();
     default:
       throw new IllegalArgumentException(
           "The class '" + eClass.getName() + "' is not a valid classifier");
   }
 }
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 @Override
 public EObject create(EClass eClass) {
   switch (eClass.getClassifierID()) {
     case FacadePackage.FACADE:
       return createFacade();
     default:
       throw new IllegalArgumentException(
           "The class '" + eClass.getName() + "' is not a valid classifier");
   }
 }
Example #23
0
 /**
  * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it
  * yields that result.
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @return the first non-null result returned by a <code>caseXXX</code> call.
  * @generated
  */
 protected T doSwitch(EClass theEClass, EObject theEObject) {
   if (theEClass.eContainer() == modelPackage) {
     return doSwitch(theEClass.getClassifierID(), theEObject);
   } else {
     List<EClass> eSuperTypes = theEClass.getESuperTypes();
     return eSuperTypes.isEmpty()
         ? defaultCase(theEObject)
         : doSwitch(eSuperTypes.get(0), theEObject);
   }
 }
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 @Override
 public EObject create(EClass eClass) {
   switch (eClass.getClassifierID()) {
     case HwLayoutPackage.HW_COMPONENT:
       return createHwComponent();
     default:
       throw new IllegalArgumentException(
           "The class '" + eClass.getName() + "' is not a valid classifier");
   }
 }
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 @Override
 public EObject create(EClass eClass) {
   switch (eClass.getClassifierID()) {
     case KeywordsUiTestLanguagePackage.MODEL:
       return createModel();
     default:
       throw new IllegalArgumentException(
           "The class '" + eClass.getName() + "' is not a valid classifier");
   }
 }
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 @Override
 public EObject create(EClass eClass) {
   switch (eClass.getClassifierID()) {
     case Core_pc_pcPackage.PCM_RANDOM_VARIABLE:
       return createPCMRandomVariable();
     default:
       throw new IllegalArgumentException(
           "The class '" + eClass.getName() + "' is not a valid classifier");
   }
 }
Example #27
0
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 @Override
 public EObject create(EClass eClass) {
   switch (eClass.getClassifierID()) {
     case GenericsPackage.GENERIC_CLS:
       return createGenericCls();
     default:
       throw new IllegalArgumentException(
           "The class '" + eClass.getName() + "' is not a valid classifier");
   }
 }
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 @Override
 public EObject create(EClass eClass) {
   switch (eClass.getClassifierID()) {
     case EzpachubePackage.COSM_CMD:
       return createCosmCmd();
     default:
       throw new IllegalArgumentException(
           "The class '" + eClass.getName() + "' is not a valid classifier");
   }
 }
Example #29
0
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 @Override
 public EObject create(EClass eClass) {
   switch (eClass.getClassifierID()) {
     case DatalayerPackage.DATABASE:
       return createDatabase();
     default:
       throw new IllegalArgumentException(
           "The class '" + eClass.getName() + "' is not a valid classifier");
   }
 }
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 @Override
 public EObject create(EClass eClass) {
   switch (eClass.getClassifierID()) {
     case MTestPackage.TEST_HARNESS:
       return (EObject) createTestHarness();
     default:
       throw new IllegalArgumentException(
           "The class '" + eClass.getName() + "' is not a valid classifier");
   }
 }