Java Code Examples for org.eclipse.emf.ecore.EDataType#getClassifierID()

/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
@Override
public Object createFromString ( EDataType eDataType, String initialValue )
{
    switch ( eDataType.getClassifierID () )
    {
        case DeploymentPackage.FALLBACK_MAPPING_MODE:
            return createFallbackMappingModeFromString ( eDataType, initialValue );
        case DeploymentPackage.ARCHITECTURE:
            return createArchitectureFromString ( eDataType, initialValue );
        case DeploymentPackage.STARTUP_MECHANISM:
            return createStartupMechanismFromString ( eDataType, initialValue );
        default:
            throw new IllegalArgumentException ( "The datatype '" + eDataType.getName () + "' is not a valid classifier" ); //$NON-NLS-1$ //$NON-NLS-2$
    }
}
 

/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
@Override
public String convertToString ( EDataType eDataType, Object instanceValue )
{
    switch ( eDataType.getClassifierID () )
    {
        case IEC60870Package.DATA_TYPE:
            return convertDataTypeToString ( eDataType, instanceValue );
        case IEC60870Package.IEC_TYPE:
            return convertIECTypeToString ( eDataType, instanceValue );
        case IEC60870Package.ADDRESS:
            return convertAddressToString ( eDataType, instanceValue );
        default:
            throw new IllegalArgumentException ( "The datatype '" + eDataType.getName () + "' is not a valid classifier" ); //$NON-NLS-1$ //$NON-NLS-2$
    }
}
 

/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
@Override
public Object createFromString(EDataType eDataType, String initialValue) {
	switch (eDataType.getClassifierID()) {
		case ModelPackage.TASK_TRIGGER_TYPE:
			return createTaskTriggerTypeFromString(eDataType, initialValue);
		case ModelPackage.TASK_STATE:
			return createTaskStateFromString(eDataType, initialValue);
		case ModelPackage.OWNER_TASK_NOTIFICATION:
			return createOwnerTaskNotificationFromString(eDataType, initialValue);
		case ModelPackage.TASK_EXCEPTION:
			return createTaskExceptionFromString(eDataType, initialValue);
		case ModelPackage.IIDENTIFIED_RUNNABLE:
			return createIIdentifiedRunnableFromString(eDataType, initialValue);
		case ModelPackage.IPROGRESS_MONITOR:
			return createIProgressMonitorFromString(eDataType, initialValue);
		case ModelPackage.LOGGER:
			return createLoggerFromString(eDataType, initialValue);
		case ModelPackage.SERIALIZABLE:
			return createSerializableFromString(eDataType, initialValue);
		case ModelPackage.CRON:
			return createCronFromString(eDataType, initialValue);
		default:
			throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
	}
}
 

/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
@Override
public String convertToString(EDataType eDataType, Object instanceValue) {
	switch (eDataType.getClassifierID()) {
		case WebPackage.RELEASE_TYPE:
			return convertReleaseTypeToString(eDataType, instanceValue);
		case WebPackage.VERSION_STATE:
			return convertVersionStateToString(eDataType, instanceValue);
		case WebPackage.URL:
			return convertURLToString(eDataType, instanceValue);
		default:
			throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
	}
}
 

/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
@Override
public Object createFromString(EDataType eDataType, String initialValue)
{
  switch (eDataType.getClassifierID())
  {
    case EnumRulesUiTestLanguagePackage.GENERATED_ENUM:
      return createGeneratedEnumFromString(eDataType, initialValue);
    default:
      throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
  }
}
 

/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
@Override
public String convertToString ( EDataType eDataType, Object instanceValue )
{
    switch ( eDataType.getClassifierID () )
    {
        default:
            throw new IllegalArgumentException ( "The datatype '" + eDataType.getName () + "' is not a valid classifier" ); //$NON-NLS-1$ //$NON-NLS-2$
    }
}
 

/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
@Override
public String convertToString ( EDataType eDataType, Object instanceValue )
{
    switch ( eDataType.getClassifierID () )
    {
        default:
            throw new IllegalArgumentException ( "The datatype '" + eDataType.getName () + "' is not a valid classifier" ); //$NON-NLS-1$ //$NON-NLS-2$
    }
}
 

/**
   * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
   * @generated
   */
@Override
public Object createFromString(EDataType eDataType, String initialValue) {
     switch (eDataType.getClassifierID()) {
        case EipPackage.MESSAGE_PART:
           return createMessagePartFromString(eDataType, initialValue);
        case EipPackage.ROUTING_TYPE:
           return createRoutingTypeFromString(eDataType, initialValue);
        case EipPackage.EXCHANGE_TYPE:
           return createExchangeTypeFromString(eDataType, initialValue);
        default:
           throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
     }
  }
 

/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
@Override
public String convertToString(EDataType eDataType, Object instanceValue)
{
  switch (eDataType.getClassifierID())
  {
    case EnumAndReferenceTestLanguagePackage.KIND_OF_KEYWORD:
      return convertKindOfKeywordToString(eDataType, instanceValue);
    default:
      throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
  }
}
 

/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
@Override
public String convertToString(EDataType eDataType, Object instanceValue)
{
  switch (eDataType.getClassifierID())
  {
    case Bug378967TestPackage.FIRST_ENUM:
      return convertFirstEnumToString(eDataType, instanceValue);
    case Bug378967TestPackage.SECOND_ENUM:
      return convertSecondEnumToString(eDataType, instanceValue);
    default:
      throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
  }
}
 

/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * 
 * @generated
 */
@Override
public String convertToString(EDataType eDataType, Object instanceValue) {
    switch (eDataType.getClassifierID()) {
        case TemplatePackage.POSITION:
            return convertPOSITIONToString(eDataType, instanceValue);
        case TemplatePackage.INPUT_STREAM:
            return convertInputStreamToString(eDataType, instanceValue);
        case TemplatePackage.OPC_PACKAGE:
            return convertOPCPackageToString(eDataType, instanceValue);
        case TemplatePackage.DOCUMENT:
            return convertDocumentToString(eDataType, instanceValue);
        case TemplatePackage.WTABLE:
            return convertWTableToString(eDataType, instanceValue);
        case TemplatePackage.RUN:
            return convertRunToString(eDataType, instanceValue);
        case TemplatePackage.AST_RESULT:
            return convertAstResultToString(eDataType, instanceValue);
        case TemplatePackage.TEMPLATE_VALIDATION_MESSAGE:
            return convertTemplateValidationMessageToString(eDataType, instanceValue);
        case TemplatePackage.WTABLE_ROW:
            return convertWTableRowToString(eDataType, instanceValue);
        case TemplatePackage.WTABLE_CELL:
            return convertWTableCellToString(eDataType, instanceValue);
        case TemplatePackage.BODY:
            return convertBodyToString(eDataType, instanceValue);
        case TemplatePackage.CT_SDT_BLOCK:
            return convertCTSdtBlockToString(eDataType, instanceValue);
        default:
            throw new IllegalArgumentException(
                    "The datatype '" + eDataType.getName() + "' is not a valid classifier");
    }
}
 

/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
@Override
public String convertToString(EDataType eDataType, Object instanceValue) {
	switch (eDataType.getClassifierID()) {
		case TypeRefsPackage.OPTIONAL_FIELD_STRATEGY:
			return convertOptionalFieldStrategyToString(eDataType, instanceValue);
		case TypeRefsPackage.UUID:
			return convertUUIDToString(eDataType, instanceValue);
		default:
			throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
	}
}
 

/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
@Override
public String convertToString(EDataType eDataType, Object instanceValue)
{
  switch (eDataType.getClassifierID())
  {
    case MultiRuleenumsPackage.MY_ENUM:
      return convertMyEnumToString(eDataType, instanceValue);
    default:
      throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
  }
}
 

/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
@Override
public String convertToString(EDataType eDataType, Object instanceValue) {
    switch (eDataType.getClassifierID()) {
    case Bpmn2Package.AD_HOC_ORDERING:
        return convertAdHocOrderingToString(eDataType, instanceValue);
    case Bpmn2Package.ASSOCIATION_DIRECTION:
        return convertAssociationDirectionToString(eDataType, instanceValue);
    case Bpmn2Package.CHOREOGRAPHY_LOOP_TYPE:
        return convertChoreographyLoopTypeToString(eDataType, instanceValue);
    case Bpmn2Package.EVENT_BASED_GATEWAY_TYPE:
        return convertEventBasedGatewayTypeToString(eDataType, instanceValue);
    case Bpmn2Package.GATEWAY_DIRECTION:
        return convertGatewayDirectionToString(eDataType, instanceValue);
    case Bpmn2Package.ITEM_KIND:
        return convertItemKindToString(eDataType, instanceValue);
    case Bpmn2Package.MULTI_INSTANCE_BEHAVIOR:
        return convertMultiInstanceBehaviorToString(eDataType, instanceValue);
    case Bpmn2Package.PROCESS_TYPE:
        return convertProcessTypeToString(eDataType, instanceValue);
    case Bpmn2Package.RELATIONSHIP_DIRECTION:
        return convertRelationshipDirectionToString(eDataType, instanceValue);
    default:
        throw new IllegalArgumentException("The datatype '" + eDataType.getName()
                + "' is not a valid classifier");
    }
}
 

/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
@Override
public Object createFromString(EDataType eDataType, String initialValue)
{
  switch (eDataType.getClassifierID())
  {
    case Bug307519TestLanguagePackage.ENUM_T:
      return createEnumTFromString(eDataType, initialValue);
    default:
      throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
  }
}
 

/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
@Override
public Object createFromString( EDataType eDataType, String initialValue )
{
	switch ( eDataType.getClassifierID( ) )
	{
		case DataPackage.DATA :
			return createDataFromString( eDataType, initialValue );
		default :
			throw new IllegalArgumentException( "The datatype '" + eDataType.getName( ) + "' is not a valid classifier" ); //$NON-NLS-1$ //$NON-NLS-2$
	}
}
 

/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
@Override
public String convertToString(EDataType eDataType, Object instanceValue) {
	switch (eDataType.getClassifierID()) {
		case ModelPackage.DATA_TYPE:
			return convertDataTypeToString(eDataType, instanceValue);
		case ModelPackage.TYPE:
			return convertTypeToString(eDataType, instanceValue);
		default:
			throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
	}
}
 

/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
@Override
public Object createFromString ( EDataType eDataType, String initialValue )
{
    switch ( eDataType.getClassifierID () )
    {
        case CommonPackage.DATE_FORMAT:
            return createDateFormatFromString ( eDataType, initialValue );
        default:
            throw new IllegalArgumentException ( "The datatype '" + eDataType.getName () + "' is not a valid classifier" ); //$NON-NLS-1$ //$NON-NLS-2$
    }
}
 

/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
@Override
public Object createFromString(EDataType eDataType, String initialValue)
{
	switch (eDataType.getClassifierID())
	{
		default:
			throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
	}
}
 

/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
@Override
public Object createFromString(EDataType eDataType, String initialValue) {
	switch (eDataType.getClassifierID()) {
		case Xpdl1Package.ACCESS_LEVEL_TYPE:
			return createAccessLevelTypeFromString(eDataType, initialValue);
		case Xpdl1Package.DURATION_UNIT_TYPE:
			return createDurationUnitTypeFromString(eDataType, initialValue);
		case Xpdl1Package.EXECUTION_TYPE:
			return createExecutionTypeFromString(eDataType, initialValue);
		case Xpdl1Package.EXECUTION_TYPE1:
			return createExecutionType1FromString(eDataType, initialValue);
		case Xpdl1Package.GRAPH_CONFORMANCE_TYPE:
			return createGraphConformanceTypeFromString(eDataType, initialValue);
		case Xpdl1Package.INSTANTIATION_TYPE:
			return createInstantiationTypeFromString(eDataType, initialValue);
		case Xpdl1Package.IS_ARRAY_TYPE:
			return createIsArrayTypeFromString(eDataType, initialValue);
		case Xpdl1Package.MODE_TYPE:
			return createModeTypeFromString(eDataType, initialValue);
		case Xpdl1Package.PUBLICATION_STATUS_TYPE:
			return createPublicationStatusTypeFromString(eDataType, initialValue);
		case Xpdl1Package.TYPE_TYPE:
			return createTypeTypeFromString(eDataType, initialValue);
		case Xpdl1Package.TYPE_TYPE1:
			return createTypeType1FromString(eDataType, initialValue);
		case Xpdl1Package.TYPE_TYPE2:
			return createTypeType2FromString(eDataType, initialValue);
		case Xpdl1Package.TYPE_TYPE3:
			return createTypeType3FromString(eDataType, initialValue);
		case Xpdl1Package.TYPE_TYPE4:
			return createTypeType4FromString(eDataType, initialValue);
		case Xpdl1Package.TYPE_TYPE5:
			return createTypeType5FromString(eDataType, initialValue);
		case Xpdl1Package.ACCESS_LEVEL_TYPE_OBJECT:
			return createAccessLevelTypeObjectFromString(eDataType, initialValue);
		case Xpdl1Package.DURATION_UNIT_TYPE_OBJECT:
			return createDurationUnitTypeObjectFromString(eDataType, initialValue);
		case Xpdl1Package.EXECUTION_TYPE_OBJECT:
			return createExecutionTypeObjectFromString(eDataType, initialValue);
		case Xpdl1Package.EXECUTION_TYPE_OBJECT1:
			return createExecutionTypeObject1FromString(eDataType, initialValue);
		case Xpdl1Package.GRAPH_CONFORMANCE_TYPE_OBJECT:
			return createGraphConformanceTypeObjectFromString(eDataType, initialValue);
		case Xpdl1Package.INSTANTIATION_TYPE_OBJECT:
			return createInstantiationTypeObjectFromString(eDataType, initialValue);
		case Xpdl1Package.IS_ARRAY_TYPE_OBJECT:
			return createIsArrayTypeObjectFromString(eDataType, initialValue);
		case Xpdl1Package.MODE_TYPE_OBJECT:
			return createModeTypeObjectFromString(eDataType, initialValue);
		case Xpdl1Package.PUBLICATION_STATUS_TYPE_OBJECT:
			return createPublicationStatusTypeObjectFromString(eDataType, initialValue);
		case Xpdl1Package.TYPE_TYPE_OBJECT:
			return createTypeTypeObjectFromString(eDataType, initialValue);
		case Xpdl1Package.TYPE_TYPE_OBJECT1:
			return createTypeTypeObject1FromString(eDataType, initialValue);
		case Xpdl1Package.TYPE_TYPE_OBJECT2:
			return createTypeTypeObject2FromString(eDataType, initialValue);
		case Xpdl1Package.TYPE_TYPE_OBJECT3:
			return createTypeTypeObject3FromString(eDataType, initialValue);
		case Xpdl1Package.TYPE_TYPE_OBJECT4:
			return createTypeTypeObject4FromString(eDataType, initialValue);
		case Xpdl1Package.TYPE_TYPE_OBJECT5:
			return createTypeTypeObject5FromString(eDataType, initialValue);
		default:
			throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
	}
}