path: root/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/JavaRefFactoryImpl.java

/*******************************************************************************
 * 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());
	}

}