Java EDataType.getClassifierID方法代码示例

import org.eclipse.emf.ecore.EDataType; //导入方法依赖的package包/类
/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
@Override
public Object createFromString(EDataType eDataType, String initialValue) {
	switch (eDataType.getClassifierID()) {
		case MetamodelPackage.ORDER_TYPE:
			return createOrderTypeFromString(eDataType, initialValue);
		case MetamodelPackage.OUTPUT_TYPE:
			return createOutputTypeFromString(eDataType, initialValue);
		case MetamodelPackage.QUERY_TYPE:
			return createQueryTypeFromString(eDataType, initialValue);
		case MetamodelPackage.PERCENT:
			return createPercentFromString(eDataType, initialValue);
		case MetamodelPackage.POSITIVE_INT:
			return createPositiveIntFromString(eDataType, initialValue);
		case MetamodelPackage.POSITIVE_DOUBLE:
			return createPositiveDoubleFromString(eDataType, initialValue);
		case MetamodelPackage.POSITIVE_INT_NOT_NULL:
			return createPositiveIntNotNullFromString(eDataType, initialValue);
		case MetamodelPackage.POSITIVE_DOUBLE_NOT_NULL:
			return createPositiveDoubleNotNullFromString(eDataType, initialValue);
		default:
			throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
	}
}
 

import org.eclipse.emf.ecore.EDataType; //导入方法依赖的package包/类
/**
 * <!-- 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$
    }
}
 

import org.eclipse.emf.ecore.EDataType; //导入方法依赖的package包/类
/**
 * <!-- begin-user-doc --> <!-- end-user-doc -->
 * @generated
 */
@Override
public String convertToString(EDataType eDataType, Object instanceValue)
{
  switch (eDataType.getClassifierID())
  {
    case ListenersPackage.RECIPIENT_TYPE_ENUM:
      return convertRecipientTypeEnumToString(eDataType, instanceValue);
    case ListenersPackage.TAP_OUTPUT_TYPE_ENUM:
      return convertTAPOutputTypeEnumToString(eDataType, instanceValue);
    case ListenersPackage.RECIPIENT_TYPE_ENUM_OBJECT:
      return convertRecipientTypeEnumObjectToString(eDataType, instanceValue);
    case ListenersPackage.TAP_OUTPUT_TYPE_ENUM_OBJECT:
      return convertTAPOutputTypeEnumObjectToString(eDataType, instanceValue);
    default:
      throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
  }
}
 

import org.eclipse.emf.ecore.EDataType; //导入方法依赖的package包/类
/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
@Override
public String convertToString(EDataType eDataType, Object instanceValue) {
	switch (eDataType.getClassifierID()) {
		case CIMPackage.ENUMERATED_TYPE:
			return convertEnumeratedTypeToString(eDataType, instanceValue);
		case CIMPackage.POWER_ROC_PER_MIN:
			return convertPowerROCPerMinToString(eDataType, instanceValue);
		case CIMPackage.FLOWGATE_IDC_TYPE:
			return convertFlowgateIdcTypeToString(eDataType, instanceValue);
		case CIMPackage.QUANTITY:
			return convertQuantityToString(eDataType, instanceValue);
		case CIMPackage.ENERGY_AS_MWH:
			return convertEnergyAsMWhToString(eDataType, instanceValue);
		case CIMPackage.PENALTY_FACTOR:
			return convertPenaltyFactorToString(eDataType, instanceValue);
		case CIMPackage.FREQ_BIAS_FACTOR:
			return convertFreqBiasFactorToString(eDataType, instanceValue);
		case CIMPackage.RATE_OF_CHANGE:
			return convertRateOfChangeToString(eDataType, instanceValue);
		case CIMPackage.FLOWGATE_AFC_USE_CODE:
			return convertFlowgateAfcUseCodeToString(eDataType, instanceValue);
		default:
			throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
	}
}
 

import org.eclipse.emf.ecore.EDataType; //导入方法依赖的package包/类
/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
@Override
public String convertToString(EDataType eDataType, Object instanceValue) {
	switch (eDataType.getClassifierID()) {
		case InfAssetModelsPackage.TRANSFORMER_CONSTRUCTION_KIND:
			return convertTransformerConstructionKindToString(eDataType, instanceValue);
		case InfAssetModelsPackage.WINDING_INSULATION_KIND:
			return convertWindingInsulationKindToString(eDataType, instanceValue);
		case InfAssetModelsPackage.OIL_PRESERVATION_KIND:
			return convertOilPreservationKindToString(eDataType, instanceValue);
		case InfAssetModelsPackage.TAP_CHANGER_SWITCHING_KIND:
			return convertTapChangerSwitchingKindToString(eDataType, instanceValue);
		case InfAssetModelsPackage.CABLE_SHIELD_KIND:
			return convertCableShieldKindToString(eDataType, instanceValue);
		case InfAssetModelsPackage.TRANSFORMER_FUNCTION_KIND:
			return convertTransformerFunctionKindToString(eDataType, instanceValue);
		case InfAssetModelsPackage.TRANSFORMER_CORE_KIND:
			return convertTransformerCoreKindToString(eDataType, instanceValue);
		default:
			throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
	}
}
 

import org.eclipse.emf.ecore.EDataType; //导入方法依赖的package包/类
/**
 * <!-- begin-user-doc --> <!-- end-user-doc -->
 * 
 * @generated
 */
@Override
public Object createFromString(EDataType eDataType, String initialValue) {
	switch (eDataType.getClassifierID()) {
	case BoemTestPackage.AN_ENUMERATION:
		return createAnEnumerationFromString(eDataType, initialValue);
	default:
		throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
	}
}
 

import org.eclipse.emf.ecore.EDataType; //导入方法依赖的package包/类
/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
@Override
public String convertToString(EDataType eDataType, Object instanceValue) {
	switch (eDataType.getClassifierID()) {
		case MeasPackage.VALIDITY:
			return convertValidityToString(eDataType, instanceValue);
		default:
			throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
	}
}
 

import org.eclipse.emf.ecore.EDataType; //导入方法依赖的package包/类
/**
 * <!-- begin-user-doc --> <!-- end-user-doc -->
 * @generated
 */
@Override
public String convertToString(EDataType eDataType, Object instanceValue)
{
  switch (eDataType.getClassifierID())
  {
    case SaturnReportPackage.RESULT_STATUS:
      return convertResultStatusToString(eDataType, instanceValue);
    case SaturnReportPackage.RESULT_STATUS_OBJECT:
      return convertResultStatusObjectToString(eDataType, instanceValue);
    default:
      throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
  }
}
 

import org.eclipse.emf.ecore.EDataType; //导入方法依赖的package包/类
/**
 * <!-- 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.PARAMETERIZED_TYPE_REF_ITERABLE:
			return convertParameterizedTypeRefIterableToString(eDataType, instanceValue);
		default:
			throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
	}
}
 

import org.eclipse.emf.ecore.EDataType; //导入方法依赖的package包/类
/**
 * <!-- 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" ); //$NON-NLS-1$ //$NON-NLS-2$
    }
}
 

import org.eclipse.emf.ecore.EDataType; //导入方法依赖的package包/类
/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
@Override
public Object createFromString(EDataType eDataType, String initialValue) {
	switch (eDataType.getClassifierID()) {
		case SCADAPackage.SOURCE:
			return createSourceFromString(eDataType, initialValue);
		case SCADAPackage.REMOTE_UNIT_TYPE:
			return createRemoteUnitTypeFromString(eDataType, initialValue);
		default:
			throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
	}
}
 

import org.eclipse.emf.ecore.EDataType; //导入方法依赖的package包/类
/**
 * <!-- begin-user-doc --> <!-- end-user-doc -->
 * @generated
 */
@Override
public String convertToString(EDataType eDataType, Object instanceValue)
{
  switch (eDataType.getClassifierID())
  {
    case EnvValidatorModulePackage.ENV_VAR_VALIDATION_TYPE:
      return convertEnvVarValidationTypeToString(eDataType, instanceValue);
    case EnvValidatorModulePackage.ENV_VAR_VALIDATION_TYPE_OBJECT:
      return convertEnvVarValidationTypeObjectToString(eDataType, instanceValue);
    default:
      throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
  }
}
 

import org.eclipse.emf.ecore.EDataType; //导入方法依赖的package包/类
/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
@Override
public String convertToString(EDataType eDataType, Object instanceValue) {
	switch (eDataType.getClassifierID()) {
		case OutagePackage.SWITCH_STATE:
			return convertSwitchStateToString(eDataType, instanceValue);
		default:
			throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
	}
}
 

import org.eclipse.emf.ecore.EDataType; //导入方法依赖的package包/类
/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
@Override
public Object createFromString(EDataType eDataType, String initialValue) {
	switch (eDataType.getClassifierID()) {
		case ProductionPackage.FUEL_TYPE:
			return createFuelTypeFromString(eDataType, initialValue);
		case ProductionPackage.PENSTOCK_TYPE:
			return createPenstockTypeFromString(eDataType, initialValue);
		case ProductionPackage.GENERATOR_CONTROL_SOURCE:
			return createGeneratorControlSourceFromString(eDataType, initialValue);
		case ProductionPackage.EMISSION_VALUE_SOURCE:
			return createEmissionValueSourceFromString(eDataType, initialValue);
		case ProductionPackage.GENERATOR_OPERATING_MODE:
			return createGeneratorOperatingModeFromString(eDataType, initialValue);
		case ProductionPackage.SPILLWAY_GATE_TYPE:
			return createSpillwayGateTypeFromString(eDataType, initialValue);
		case ProductionPackage.GENERATOR_CONTROL_MODE:
			return createGeneratorControlModeFromString(eDataType, initialValue);
		case ProductionPackage.HYDRO_PLANT_TYPE:
			return createHydroPlantTypeFromString(eDataType, initialValue);
		case ProductionPackage.EMISSION_TYPE:
			return createEmissionTypeFromString(eDataType, initialValue);
		case ProductionPackage.HYDRO_ENERGY_CONVERSION_KIND:
			return createHydroEnergyConversionKindFromString(eDataType, initialValue);
		case ProductionPackage.SURGE_TANK_CODE:
			return createSurgeTankCodeFromString(eDataType, initialValue);
		case ProductionPackage.HEAT_RATE:
			return createHeatRateFromString(eDataType, initialValue);
		case ProductionPackage.CLASSIFICATION:
			return createClassificationFromString(eDataType, initialValue);
		case ProductionPackage.EMISSION:
			return createEmissionFromString(eDataType, initialValue);
		case ProductionPackage.COST_PER_HEAT_UNIT:
			return createCostPerHeatUnitFromString(eDataType, initialValue);
		default:
			throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
	}
}
 

import org.eclipse.emf.ecore.EDataType; //导入方法依赖的package包/类
/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
@Override
public Object createFromString(EDataType eDataType, String initialValue) {
	switch (eDataType.getClassifierID()) {
		case InfWorkPackage.DESIGN_KIND:
			return createDesignKindFromString(eDataType, initialValue);
		case InfWorkPackage.CONDITION_FACTOR_KIND:
			return createConditionFactorKindFromString(eDataType, initialValue);
		case InfWorkPackage.WORK_ACTION_KIND:
			return createWorkActionKindFromString(eDataType, initialValue);
		default:
			throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
	}
}