| /******************************************************************************* |
| * Copyright (c) 2001, 2006 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.jem.java.internal.impl; |
| import java.util.List; |
| |
| import org.eclipse.emf.common.util.URI; |
| import org.eclipse.emf.ecore.*; |
| import org.eclipse.emf.ecore.impl.EFactoryImpl; |
| import org.eclipse.emf.ecore.plugin.EcorePlugin; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.emf.ecore.resource.ResourceSet; |
| |
| import org.eclipse.jem.internal.java.adapters.ReflectionAdaptor; |
| import org.eclipse.jem.java.*; |
| import org.eclipse.jem.java.util.JavaContext; |
| |
| |
| |
| /** |
| * @generated |
| */ |
| public class JavaRefFactoryImpl extends EFactoryImpl implements JavaRefFactory { |
| |
| /** |
| * Creates the default factory implementation. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public static JavaRefFactory init() { |
| try { |
| JavaRefFactory theJavaRefFactory = (JavaRefFactory)EPackage.Registry.INSTANCE.getEFactory("java.xmi"); |
| if (theJavaRefFactory != null) { |
| return theJavaRefFactory; |
| } |
| } |
| catch (Exception exception) { |
| EcorePlugin.INSTANCE.log(exception); |
| } |
| return new JavaRefFactoryImpl(); |
| } |
| |
| /** |
| * Notes about Type URI's. |
| * <p> |
| * The format of a type uri is: "java:/package#classname". "package" is either the package name, |
| * with '.' for package separator (e.g. "java:/a.b#XYZ"). Or for primitive (e.g. "java:/#int") or |
| * for default package (e.g. "java:/#XYZ"). |
| * <p> |
| * The classname has some special changes. First it must use reflection format which means |
| * that any inner class must use the '$' format, i.e. "A.B" must be "A$B". |
| * <p> |
| * Next if there is |
| * a generic involved then it must be changed in the following way: "A<? extends a.B>" will |
| * be changed to "A{? extends a!B}". The reason for this is first that '<' and '>' are |
| * invalid in a fragment (id) of a URI. So we replace them with '{}'. Next because we use |
| * the fragment "A.field" or "A.method(" to mean a field or method id, we can't have the |
| * '.' in the generic portion. If it was there we couldn't quickly find the appropriate nesting |
| * of the generic's '{}' because there could be another generic within the generic, and then |
| * say to find the '.' after that nested set. |
| */ |
| |
| |
| /** |
| * Comment for <code>GENERIC_ID_SEPARATOR</code> |
| * |
| * @since 1.2.0 |
| */ |
| private static final char GENERIC_ID_SEPARATOR = '!'; |
| /** |
| * Comment for <code>GENERIC_SEPARATOR</code> |
| * |
| * @since 1.2.0 |
| */ |
| private static final char GENERIC_SEPARATOR = '.'; |
| /** |
| * Comment for <code>GENERIC_ID_END</code> |
| * |
| * @since 1.2.0 |
| */ |
| private static final char GENERIC_ID_END = '}'; |
| /** |
| * Comment for <code>GENERIC_END</code> |
| * |
| * @since 1.2.0 |
| */ |
| private static final char GENERIC_END = '>'; |
| /** |
| * Comment for <code>GENERIC_ID_START</code> |
| * |
| * @since 1.2.0 |
| */ |
| private static final char GENERIC_ID_START = '{'; |
| /** |
| * Comment for <code>GENERIC_START</code> |
| * |
| * @since 1.2.0 |
| */ |
| private static final char GENERIC_START = '<'; |
| |
| |
| public JavaRefFactoryImpl() { |
| super(); |
| } |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public EObject create(EClass eClass) { |
| switch (eClass.getClassifierID()) { |
| case JavaRefPackage.JAVA_CLASS: return createJavaClass(); |
| case JavaRefPackage.INITIALIZER: return createInitializer(); |
| case JavaRefPackage.JAVA_PARAMETER: return createJavaParameter(); |
| case JavaRefPackage.METHOD: return createMethod(); |
| case JavaRefPackage.FIELD: return createField(); |
| case JavaRefPackage.BLOCK: return createBlock(); |
| case JavaRefPackage.COMMENT: return createComment(); |
| case JavaRefPackage.STATEMENT: return createStatement(); |
| case JavaRefPackage.JAVA_PACKAGE: return createJavaPackage(); |
| case JavaRefPackage.JAVA_DATA_TYPE: return createJavaDataType(); |
| case JavaRefPackage.ARRAY_TYPE: return createArrayType(); |
| default: |
| throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier"); |
| } |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public Object createFromString(EDataType eDataType, String initialValue) { |
| switch (eDataType.getClassifierID()) { |
| case JavaRefPackage.TYPE_KIND: |
| return createTypeKindFromString(eDataType, initialValue); |
| case JavaRefPackage.JAVA_VISIBILITY_KIND: |
| return createJavaVisibilityKindFromString(eDataType, initialValue); |
| case JavaRefPackage.JAVA_PARAMETER_KIND: |
| return createJavaParameterKindFromString(eDataType, initialValue); |
| case JavaRefPackage.JTYPE_JAVA_HELPERS: |
| return createJTypeJavaHelpersFromString(eDataType, initialValue); |
| case JavaRefPackage.JTYPE_LIST: |
| return createJTypeListFromString(eDataType, initialValue); |
| default: |
| throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier"); |
| } |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public String convertToString(EDataType eDataType, Object instanceValue) { |
| switch (eDataType.getClassifierID()) { |
| case JavaRefPackage.TYPE_KIND: |
| return convertTypeKindToString(eDataType, instanceValue); |
| case JavaRefPackage.JAVA_VISIBILITY_KIND: |
| return convertJavaVisibilityKindToString(eDataType, instanceValue); |
| case JavaRefPackage.JAVA_PARAMETER_KIND: |
| return convertJavaParameterKindToString(eDataType, instanceValue); |
| case JavaRefPackage.JTYPE_JAVA_HELPERS: |
| return convertJTypeJavaHelpersToString(eDataType, instanceValue); |
| case JavaRefPackage.JTYPE_LIST: |
| return convertJTypeListToString(eDataType, instanceValue); |
| default: |
| throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier"); |
| } |
| } |
| |
| public ArrayType createArrayType(JavaHelpers componentType) { |
| ArrayType at = createArrayType(); |
| |
| String computedName = componentType.getQualifiedName() + "[]"; |
| at.setName(computedName); |
| return at; |
| } |
| public ArrayType createArrayType(JavaHelpers finalComponentType, int dimensions) { |
| ArrayType at = createArrayType(); |
| |
| String computedName = finalComponentType.getQualifiedName(); |
| for (int i = 0; i < dimensions; i++){ |
| computedName = computedName + "[]"; |
| } |
| at.setName(computedName); |
| return at; |
| } |
| |
| /** |
| * Get the java context |
| * @return |
| * |
| * @deprecated Use the API {@link JavaContext#createJavaContext()} instead. |
| * @since 1.2.0 |
| */ |
| public static ResourceSet createJavaContext() { |
| return JavaContext.createJavaContext(); |
| } |
| /** |
| * Return the Class for the Java refection adapter factory. |
| * @deprecated Use the API {@link JavaContext#getReflectionAdapterFactoryClass()} instead. |
| */ |
| public static Class getReflectionAdapterFactoryClass() { |
| return JavaContext.getReflectionAdapterFactoryClass(); |
| } |
| |
| /** |
| * Set the Class for the Java refection adapter factory. |
| * |
| * @deprecated Use the API {@link JavaContext#setReflectionAdapterFactoryClass(Class)} instead. |
| */ |
| public static void setReflectionAdapterFactoryClass(Class javaReflectionFactoryClass) { |
| JavaContext.setReflectionAdapterFactoryClass(javaReflectionFactoryClass); |
| } |
| |
| /** |
| * @generated This field/method will be replaced during code generation. |
| */ |
| public Method createMethod() { |
| MethodImpl method = new MethodImpl(); |
| return method; |
| } |
| |
| /** |
| * @generated This field/method will be replaced during code generation. |
| */ |
| public JavaClass createJavaClass() { |
| JavaClassImpl javaClass = new JavaClassImpl(); |
| return javaClass; |
| } |
| |
| /** |
| * @generated This field/method will be replaced during code generation. |
| */ |
| public Field createField() { |
| FieldImpl field = new FieldImpl(); |
| return field; |
| } |
| |
| /** |
| * @generated This field/method will be replaced during code generation. |
| */ |
| public Block createBlock() { |
| BlockImpl block = new BlockImpl(); |
| return block; |
| } |
| |
| /** |
| * @generated This field/method will be replaced during code generation. |
| */ |
| public Comment createComment() { |
| CommentImpl comment = new CommentImpl(); |
| return comment; |
| } |
| |
| /** |
| * @generated This field/method will be replaced during code generation. |
| */ |
| public Statement createStatement() { |
| StatementImpl statement = new StatementImpl(); |
| return statement; |
| } |
| |
| /** |
| * @generated This field/method will be replaced during code generation. |
| */ |
| public Initializer createInitializer() { |
| InitializerImpl initializer = new InitializerImpl(); |
| return initializer; |
| } |
| |
| /** |
| * @generated This field/method will be replaced during code generation. |
| */ |
| public JavaParameter createJavaParameter() { |
| JavaParameterImpl javaParameter = new JavaParameterImpl(); |
| return javaParameter; |
| } |
| |
| /** |
| * @generated This field/method will be replaced during code generation. |
| */ |
| public ArrayType createArrayType() { |
| ArrayTypeImpl arrayType = new ArrayTypeImpl(); |
| return arrayType; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public TypeKind createTypeKindFromString(EDataType eDataType, String initialValue) { |
| TypeKind result = TypeKind.get(initialValue); |
| if (result == null) throw new IllegalArgumentException("The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'"); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public String convertTypeKindToString(EDataType eDataType, Object instanceValue) { |
| return instanceValue == null ? null : instanceValue.toString(); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public JavaVisibilityKind createJavaVisibilityKindFromString(EDataType eDataType, String initialValue) { |
| JavaVisibilityKind result = JavaVisibilityKind.get(initialValue); |
| if (result == null) throw new IllegalArgumentException("The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'"); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public String convertJavaVisibilityKindToString(EDataType eDataType, Object instanceValue) { |
| return instanceValue == null ? null : instanceValue.toString(); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public JavaParameterKind createJavaParameterKindFromString(EDataType eDataType, String initialValue) { |
| JavaParameterKind result = JavaParameterKind.get(initialValue); |
| if (result == null) throw new IllegalArgumentException("The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'"); |
| return result; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public String convertJavaParameterKindToString(EDataType eDataType, Object instanceValue) { |
| return instanceValue == null ? null : instanceValue.toString(); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public JavaHelpers createJTypeJavaHelpersFromString(EDataType eDataType, String initialValue) { |
| return (JavaHelpers)super.createFromString(eDataType, initialValue); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public String convertJTypeJavaHelpersToString(EDataType eDataType, Object instanceValue) { |
| return super.convertToString(eDataType, instanceValue); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public List createJTypeListFromString(EDataType eDataType, String initialValue) { |
| return (List)super.createFromString(eDataType, initialValue); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public String convertJTypeListToString(EDataType eDataType, Object instanceValue) { |
| return super.convertToString(eDataType, instanceValue); |
| } |
| |
| /** |
| * @generated This field/method will be replaced during code generation. |
| */ |
| public JavaDataType createJavaDataType() { |
| JavaDataTypeImpl javaDataType = new JavaDataTypeImpl(); |
| return javaDataType; |
| } |
| |
| /** |
| * @generated This field/method will be replaced during code generation. |
| */ |
| public JavaPackage createJavaPackage() { |
| JavaPackageImpl javaPackage = new JavaPackageImpl(); |
| return javaPackage; |
| } |
| |
| /** |
| * @generated This field/method will be replaced during code generation. |
| */ |
| public JavaRefPackage getJavaRefPackage() { |
| return (JavaRefPackage)getEPackage(); |
| } |
| |
| /** |
| * @generated This field/method will be replaced during code generation. |
| */ |
| public static JavaRefPackage getPackage() { |
| return JavaRefPackage.eINSTANCE; |
| } |
| |
| public static JavaRefFactory getActiveFactory() { |
| return JavaRefFactory.eINSTANCE; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jem.java.JavaRefFactory#createClassRef(java.lang.String) |
| */ |
| public JavaClass createClassRef(String targetName) { |
| JavaClass ref = createJavaClass(); |
| ((InternalEObject) ref).eSetProxyURI(createTypeURI(targetName)); |
| return ref; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.java.JavaRefFactory#reflectType(java.lang.String, org.eclipse.emf.ecore.EObject) |
| */ |
| public JavaHelpers reflectType(String aQualifiedName, EObject relatedObject) { |
| Resource r = relatedObject.eResource(); |
| if (r != null) { |
| ResourceSet rs = r.getResourceSet(); |
| if (rs != null) { |
| return reflectType(aQualifiedName, rs); |
| } |
| } |
| return null; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.java.JavaRefFactory#reflectType(java.lang.String, org.eclipse.emf.ecore.resource.ResourceSet) |
| */ |
| public JavaHelpers reflectType(String aQualifiedName, ResourceSet set) { |
| if (aQualifiedName != null) { |
| int index = aQualifiedName.lastIndexOf("."); |
| if (index > 0) |
| return reflectType(aQualifiedName.substring(0, index), aQualifiedName.substring(index + 1, aQualifiedName.length()), set); |
| else |
| return reflectType("", aQualifiedName, set); |
| } |
| return null; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.java.JavaRefFactory#reflectType(java.lang.String, java.lang.String, org.eclipse.emf.ecore.resource.ResourceSet) |
| */ |
| public JavaHelpers reflectType(String aPackageName, String aTypeName, ResourceSet set) { |
| if (aTypeName != null && aPackageName != null) { |
| org.eclipse.jem.internal.java.init.JavaInit.init(); |
| return (JavaHelpers) set.getEObject(createTypeURI(aPackageName, aTypeName), true); |
| } |
| return null; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.java.JavaRefFactory#reflectPackage(java.lang.String, org.eclipse.emf.ecore.resource.ResourceSet) |
| */ |
| public JavaPackage reflectPackage(String packageName, ResourceSet set) { |
| if (packageName != null) { |
| org.eclipse.jem.internal.java.init.JavaInit.init(); |
| return (JavaPackage) set.getEObject(createPackageURI(packageName), true); |
| } |
| return null; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.java.JavaRefFactory#createTypeURI(java.lang.String) |
| */ |
| public URI createTypeURI(String aQualifiedName) { |
| // for need to just tolerate generics (i.e. "<...>". Fully support later. |
| //In this case tolerate means ignore the parameter types. |
| int genNdx = aQualifiedName.indexOf(GENERIC_START); |
| int pkgNdx = genNdx == -1 ? aQualifiedName.lastIndexOf('.') : aQualifiedName.lastIndexOf('.', genNdx); |
| if (pkgNdx > -1) |
| return createTypeURI(aQualifiedName.substring(0, pkgNdx), genNdx == -1 ? aQualifiedName.substring(pkgNdx+1) : aQualifiedName.substring(pkgNdx+1, genNdx)); |
| else |
| return createTypeURI(null, aQualifiedName); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.java.JavaRefFactory#createTypeURI(java.lang.String, java.lang.String) |
| */ |
| public URI createTypeURI(String packageName, String typeName) { |
| String[] pkgname = null; |
| if (packageName != null && packageName.length() > 0) |
| pkgname = new String[] {packageName}; |
| return URI.createHierarchicalURI(JAVA_PROTOCOL_URI_SCHEME, null, null, pkgname, null, createTypeName(typeName)); |
| } |
| |
| /** |
| * Create a URI'd type name from a regular typename. |
| * <p> |
| * This should only be used by friends of the Impl package. |
| * @param typeName type name, no package allowed, and must be in form for reflection (i.e. '$' not '.' to separate outer and inner classes). |
| * @return |
| * |
| * @since 1.2.0 |
| */ |
| public String createTypeName(String typeName) { |
| |
| int genStart = typeName.indexOf(GENERIC_START); |
| if (genStart > -1) { |
| char[] chName = new char[typeName.length()]; |
| typeName.getChars(0, chName.length, chName, 0); |
| for (int i = 0; i < chName.length; i++) { |
| switch (chName[i]) { |
| case GENERIC_START: |
| chName[i] = GENERIC_ID_START; |
| break; |
| case GENERIC_END: |
| chName[i] = GENERIC_ID_END; |
| break; |
| case GENERIC_SEPARATOR: |
| chName[i] = GENERIC_ID_SEPARATOR; |
| break; |
| default: |
| break; |
| } |
| } |
| typeName = new String(chName); |
| } |
| return typeName; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.java.JavaRefFactory#getTypeName(org.eclipse.emf.common.util.URI) |
| */ |
| public String getTypeName(URI typeURI) { |
| if (isTypeURI(typeURI)) { |
| return primGetTypeName(typeURI.fragment()); |
| } else |
| throw new IllegalArgumentException(typeURI.toString()); |
| } |
| |
| /** |
| * Get type name from URI'd typename. |
| * <p> |
| * This should only be used by friends of the Impl package. |
| * @param type uri fragment value for type name. |
| * @return |
| * |
| * @since 1.2.0 |
| */ |
| public String primGetTypeName(String typeName) { |
| int genStart = typeName.indexOf(GENERIC_ID_START); |
| if (genStart > -1) { |
| char[] chName = new char[typeName.length()]; |
| typeName.getChars(0, chName.length, chName, 0); |
| for (int i = 0; i < chName.length; i++) { |
| switch (chName[i]) { |
| case GENERIC_ID_START: |
| chName[i] = GENERIC_START; |
| break; |
| case GENERIC_ID_END: |
| chName[i] = GENERIC_END; |
| break; |
| case GENERIC_ID_SEPARATOR: |
| chName[i] = GENERIC_SEPARATOR; |
| break; |
| default: |
| break; |
| } |
| } |
| typeName = new String(chName); |
| } |
| return typeName; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.java.JavaRefFactory#getPackageName(org.eclipse.emf.common.util.URI) |
| */ |
| public String getPackageName(URI javaURI) { |
| if (isTypeURI(javaURI) || isPackageURI(javaURI)) { |
| if (javaURI.segmentCount() == 1) { |
| return javaURI.segment(0); |
| } else if (javaURI.segmentCount() == 0) |
| return ""; //$NON-NLS-1$ |
| else |
| throw new IllegalArgumentException(javaURI.toString()); |
| } else |
| throw new IllegalArgumentException(javaURI.toString()); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.java.JavaRefFactory#getFullTypeName(org.eclipse.emf.common.util.URI) |
| */ |
| public String getFullTypeName(URI typeURI) { |
| String pkgName = getPackageName(typeURI); |
| if (!isTypeURI(typeURI)) |
| throw new IllegalArgumentException(typeURI.toString()); |
| |
| if (pkgName.length() > 0) |
| return pkgName+'.'+getTypeName(typeURI); |
| else |
| return typeURI.fragment(); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.java.JavaRefFactory#createPackageURI(java.lang.String) |
| */ |
| public URI createPackageURI(String packageName) { |
| String[] pkgname = null; |
| if (packageName != null && packageName.length() > 0) |
| pkgname = new String[] {packageName}; |
| return URI.createHierarchicalURI(JAVA_PROTOCOL_URI_SCHEME, null, null, pkgname, null, JavaPackage.PACKAGE_ID); |
| } |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.java.JavaRefFactory#isJavaURI(org.eclipse.emf.common.util.URI) |
| */ |
| public boolean isJavaURI(URI uri) { |
| return JAVA_PROTOCOL_URI_SCHEME.equals(uri.scheme()); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.java.JavaRefFactory#isTypeURI(org.eclipse.emf.common.util.URI) |
| */ |
| public boolean isTypeURI(URI uri) { |
| if (isJavaURI(uri)) { |
| String frag = uri.fragment(); |
| if (frag != null && !JavaPackage.PACKAGE_ID.equals(frag)) { |
| int delimNdx = frag.indexOf(ReflectionAdaptor.C_CLASS_MEMBER_DELIMITER); |
| if (delimNdx != -1) |
| return false; |
| delimNdx = frag.indexOf('/'); // From beaninfo for property. |
| if (delimNdx != -1) |
| return false; |
| else |
| return true; |
| } else |
| return false; |
| } else |
| return false; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.java.JavaRefFactory#isPackageURI(org.eclipse.emf.common.util.URI) |
| */ |
| public boolean isPackageURI(URI uri) { |
| return isJavaURI(uri) && JavaPackage.PACKAGE_ID.equals(uri.fragment()); |
| } |
| |
| } |
| |
| |
| |
| |
| |
| |