jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/mappings/JpaJavaMappingsFactory.java

/*******************************************************************************
 * Copyright (c) 2006, 2007 Oracle. 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:
 *     Oracle - initial API and implementation
 ******************************************************************************/
package org.eclipse.jpt.core.internal.content.java.mappings;

import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.impl.EFactoryImpl;
import org.eclipse.emf.ecore.plugin.EcorePlugin;
import org.eclipse.jpt.core.internal.jdtutility.Attribute;
import org.eclipse.jpt.core.internal.jdtutility.DeclarationAnnotationAdapter;
import org.eclipse.jpt.core.internal.jdtutility.DeclarationAnnotationElementAdapter;
import org.eclipse.jpt.core.internal.jdtutility.IndexedDeclarationAnnotationAdapter;
import org.eclipse.jpt.core.internal.jdtutility.Member;
import org.eclipse.jpt.core.internal.jdtutility.NullDeclarationAnnotationAdapter;
import org.eclipse.jpt.core.internal.jdtutility.Type;
import org.eclipse.jpt.core.internal.mappings.IAbstractJoinColumn;
import org.eclipse.jpt.core.internal.mappings.IColumn;
import org.eclipse.jpt.core.internal.mappings.IJoinColumn;
import org.eclipse.jpt.core.internal.mappings.IOverride;
import org.eclipse.jpt.core.internal.mappings.ITable;
import org.eclipse.jpt.core.internal.mappings.IUniqueConstraint;
import org.eclipse.jpt.core.internal.mappings.INamedColumn.Owner;

/**
 * <!-- begin-user-doc -->
 * The <b>Factory</b> for the model.
 * It provides a create method for each non-abstract class of the model.
 * <!-- end-user-doc -->
 * @see org.eclipse.jpt.core.internal.content.java.mappings.JpaJavaMappingsPackage
 * @generated
 */
public class JpaJavaMappingsFactory extends EFactoryImpl
{
	/**
	 * The singleton instance of the factory.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public static final JpaJavaMappingsFactory eINSTANCE = init();

	/**
	 * Creates the default factory implementation.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public static JpaJavaMappingsFactory init() {
		try {
			JpaJavaMappingsFactory theJpaJavaMappingsFactory = (JpaJavaMappingsFactory) EPackage.Registry.INSTANCE.getEFactory("jpt.core.java.mappings.xmi");
			if (theJpaJavaMappingsFactory != null) {
				return theJpaJavaMappingsFactory;
			}
		}
		catch (Exception exception) {
			EcorePlugin.INSTANCE.log(exception);
		}
		return new JpaJavaMappingsFactory();
	}

	/**
	 * Creates an instance of the factory.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public JpaJavaMappingsFactory() {
		super();
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public EObject create(EClass eClass) {
		switch (eClass.getClassifierID()) {
			case JpaJavaMappingsPackage.JAVA_ENTITY :
				return createJavaEntity();
			case JpaJavaMappingsPackage.JAVA_MAPPED_SUPERCLASS :
				return createJavaMappedSuperclass();
			case JpaJavaMappingsPackage.JAVA_EMBEDDABLE :
				return createJavaEmbeddable();
			case JpaJavaMappingsPackage.JAVA_NULL_TYPE_MAPPING :
				return createJavaNullTypeMapping();
			case JpaJavaMappingsPackage.JAVA_BASIC :
				return createJavaBasic();
			case JpaJavaMappingsPackage.JAVA_ID :
				return createJavaId();
			case JpaJavaMappingsPackage.JAVA_TRANSIENT :
				return createJavaTransient();
			case JpaJavaMappingsPackage.JAVA_VERSION :
				return createJavaVersion();
			case JpaJavaMappingsPackage.JAVA_EMBEDDED_ID :
				return createJavaEmbeddedId();
			case JpaJavaMappingsPackage.JAVA_EMBEDDED :
				return createJavaEmbedded();
			case JpaJavaMappingsPackage.JAVA_MANY_TO_ONE :
				return createJavaManyToOne();
			case JpaJavaMappingsPackage.JAVA_ONE_TO_ONE :
				return createJavaOneToOne();
			case JpaJavaMappingsPackage.JAVA_ONE_TO_MANY :
				return createJavaOneToMany();
			case JpaJavaMappingsPackage.JAVA_MANY_TO_MANY :
				return createJavaManyToMany();
			case JpaJavaMappingsPackage.JAVA_NULL_ATTRIBUTE_MAPPING :
				return createJavaNullAttributeMapping();
			case JpaJavaMappingsPackage.JAVA_TABLE :
				return createJavaTable();
			case JpaJavaMappingsPackage.JAVA_SECONDARY_TABLE :
				return createJavaSecondaryTable();
			case JpaJavaMappingsPackage.JAVA_JOIN_TABLE :
				return createJavaJoinTable();
			case JpaJavaMappingsPackage.JAVA_COLUMN :
				return createJavaColumn();
			case JpaJavaMappingsPackage.JAVA_JOIN_COLUMN :
				return createJavaJoinColumn();
			case JpaJavaMappingsPackage.JAVA_ATTRIBUTE_OVERRIDE :
				return createJavaAttributeOverride();
			case JpaJavaMappingsPackage.JAVA_ASSOCIATION_OVERRIDE :
				return createJavaAssociationOverride();
			case JpaJavaMappingsPackage.JAVA_DISCRIMINATOR_COLUMN :
				return createJavaDiscriminatorColumn();
			case JpaJavaMappingsPackage.JAVA_PRIMARY_KEY_JOIN_COLUMN :
				return createJavaPrimaryKeyJoinColumn();
			case JpaJavaMappingsPackage.JAVA_GENERATED_VALUE :
				return createJavaGeneratedValue();
			case JpaJavaMappingsPackage.JAVA_TABLE_GENERATOR :
				return createJavaTableGenerator();
			case JpaJavaMappingsPackage.JAVA_SEQUENCE_GENERATOR :
				return createJavaSequenceGenerator();
			case JpaJavaMappingsPackage.JAVA_NAMED_QUERY :
				return createJavaNamedQuery();
			case JpaJavaMappingsPackage.JAVA_NAMED_NATIVE_QUERY :
				return createJavaNamedNativeQuery();
			case JpaJavaMappingsPackage.JAVA_QUERY_HINT :
				return createJavaQueryHint();
			case JpaJavaMappingsPackage.JAVA_UNIQUE_CONSTRAINT :
				return createJavaUniqueConstraint();
			case JpaJavaMappingsPackage.JAVA_CASCADE :
				return createJavaCascade();
			default :
				throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
		}
	}

	public JavaEntity createJavaEntity() {
		throw new UnsupportedOperationException("Use createJavaEntity(Type) instead");
	}

	public JavaEntity createJavaEntity(Type type) {
		JavaEntity javaEntity = new JavaEntity(type);
		return javaEntity;
	}

	public JavaMappedSuperclass createJavaMappedSuperclass() {
		throw new UnsupportedOperationException("Use createJavaMappedSuperclass(Type) instead");
	}

	public JavaEmbeddable createJavaEmbeddable() {
		throw new UnsupportedOperationException("Use createJavaEmbeddable(Type) instead");
	}

	public JavaEmbeddable createJavaEmbeddable(Type type) {
		JavaEmbeddable javaEmbeddable = new JavaEmbeddable(type);
		return javaEmbeddable;
	}

	public JavaMappedSuperclass createJavaMappedSuperclass(Type type) {
		JavaMappedSuperclass javaMappedSuperclass = new JavaMappedSuperclass(type);
		return javaMappedSuperclass;
	}

	public JavaNullTypeMapping createJavaNullTypeMapping() {
		throw new UnsupportedOperationException("Use createJavaNullTypeMapping(Type) instead");
	}

	public JavaNullTypeMapping createJavaNullTypeMapping(Type type) {
		JavaNullTypeMapping javaNullTypeMapping = new JavaNullTypeMapping(type);
		return javaNullTypeMapping;
	}

	public JavaNullAttributeMapping createJavaNullAttributeMapping() {
		throw new UnsupportedOperationException("Use createJavaNullAttributeMapping(Attribute) instead");
	}

	public JavaNullAttributeMapping createJavaNullAttributeMapping(Attribute attribute) {
		JavaNullAttributeMapping javaNullAttributeMapping = new JavaNullAttributeMapping(attribute);
		return javaNullAttributeMapping;
	}

	public JavaBasic createJavaBasic() {
		throw new UnsupportedOperationException("Use createJavaBasic(Attribute) instead");
	}

	public JavaBasic createJavaBasic(Attribute attribute) {
		JavaBasic javaBasic = new JavaBasic(attribute);
		return javaBasic;
	}

	public JavaId createJavaId() {
		throw new UnsupportedOperationException("Use createJavaId(Attribute) instead");
	}

	public JavaTransient createJavaTransient() {
		throw new UnsupportedOperationException("Use createJavaTransient(Attribute) instead");
	}

	public JavaVersion createJavaVersion() {
		throw new UnsupportedOperationException("Use createJavaVersion(Attribute) instead");
	}

	public JavaVersion createJavaVersion(Attribute attribute) {
		JavaVersion javaVersion = new JavaVersion(attribute);
		return javaVersion;
	}

	public JavaEmbeddedId createJavaEmbeddedId() {
		throw new UnsupportedOperationException("Use createJavaEmbeddedId(Attribute) instead");
	}

	public JavaEmbeddedId createJavaEmbeddedId(Attribute attribute) {
		JavaEmbeddedId javaEmbeddedId = new JavaEmbeddedId(attribute);
		return javaEmbeddedId;
	}

	public JavaEmbedded createJavaEmbedded() {
		throw new UnsupportedOperationException("Use createJavaEmbedded(Attribute) instead");
	}

	public JavaEmbedded createJavaEmbedded(Attribute attribute) {
		JavaEmbedded javaEmbedded = new JavaEmbedded(attribute);
		return javaEmbedded;
	}

	public JavaTransient createJavaTransient(Attribute attribute) {
		JavaTransient javaTransient = new JavaTransient(attribute);
		return javaTransient;
	}

	public JavaId createJavaId(Attribute attribute) {
		JavaId javaId = new JavaId(attribute);
		return javaId;
	}

	public JavaTable createJavaTable() {
		throw new UnsupportedOperationException("Use createJavaTable(ITable.Owner, Member) instead");
	}

	public JavaTable createJavaTable(ITable.Owner owner, Member member) {
		JavaTable javaTable = new JavaTable(owner, member);
		return javaTable;
	}

	public JavaColumn createJavaColumn() {
		throw new UnsupportedOperationException("Use createJavaColumn(Member ) instead");
	}

	public JavaOneToMany createJavaOneToMany() {
		throw new UnsupportedOperationException("Use createJavaOneToMany(Attribute) instead");
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public JavaManyToMany createJavaManyToMany() {
		JavaManyToMany javaManyToMany = new JavaManyToMany();
		return javaManyToMany;
	}

	public JavaManyToMany createJavaManyToMany(Attribute attribute) {
		JavaManyToMany javaManyToMany = new JavaManyToMany(attribute);
		return javaManyToMany;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public JavaJoinTable createJavaJoinTable() {
		JavaJoinTable javaJoinTable = new JavaJoinTable();
		return javaJoinTable;
	}

	public JavaJoinTable createJavaJoinTable(ITable.Owner owner, Member member) {
		JavaJoinTable javaJoinTable = new JavaJoinTable(owner, member);
		return javaJoinTable;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public JavaJoinColumn createJavaJoinColumn() {
		JavaJoinColumn javaJoinColumn = new JavaJoinColumn();
		return javaJoinColumn;
	}

	public JavaAttributeOverride createJavaAttributeOverride() {
		throw new UnsupportedOperationException();
	}

	public JavaAttributeOverride createJavaAttributeOverride(IOverride.Owner owner, Member member, IndexedDeclarationAnnotationAdapter idaa) {
		JavaAttributeOverride javaAttributeOverride = new JavaAttributeOverride(owner, member, idaa);
		return javaAttributeOverride;
	}

	public JavaAttributeOverride createJavaAttributeOverride(IOverride.Owner owner, Member member) {
		return this.createJavaAttributeOverride(owner, member, NullDeclarationAnnotationAdapter.instance());
	}

	public JavaAssociationOverride createJavaAssociationOverride() {
		throw new UnsupportedOperationException();
	}

	public JavaAssociationOverride createJavaAssociationOverride(IOverride.Owner owner, Member member, IndexedDeclarationAnnotationAdapter idaa) {
		JavaAssociationOverride javaAssociationOverride = new JavaAssociationOverride(owner, member, idaa);
		return javaAssociationOverride;
	}

	public JavaAssociationOverride createJavaAssociationOverride(IOverride.Owner owner, Member member) {
		return this.createJavaAssociationOverride(owner, member, NullDeclarationAnnotationAdapter.instance());
	}

	public JavaDiscriminatorColumn createJavaDiscriminatorColumn() {
		throw new UnsupportedOperationException();
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public JavaPrimaryKeyJoinColumn createJavaPrimaryKeyJoinColumn() {
		JavaPrimaryKeyJoinColumn javaPrimaryKeyJoinColumn = new JavaPrimaryKeyJoinColumn();
		return javaPrimaryKeyJoinColumn;
	}

	public JavaGeneratedValue createJavaGeneratedValue() {
		throw new UnsupportedOperationException("Use createJavaGeneratedValue(Member) instead");
	}

	public JavaGeneratedValue createJavaGeneratedValue(Member member) {
		JavaGeneratedValue javaGeneratedValue = new JavaGeneratedValue(member);
		return javaGeneratedValue;
	}

	public JavaTableGenerator createJavaTableGenerator() {
		throw new UnsupportedOperationException("Use createJavaTableGenerator(Member) instead");
	}

	public JavaTableGenerator createJavaTableGenerator(Member member) {
		JavaTableGenerator javaTableGenerator = new JavaTableGenerator(member);
		return javaTableGenerator;
	}

	public JavaSequenceGenerator createJavaSequenceGenerator() {
		throw new UnsupportedOperationException("Use createJavaSequenceGenerator(Member) instead");
	}

	public JavaNamedQuery createJavaNamedQuery() {
		throw new UnsupportedOperationException("Use createJavaNamedQuery(Member, IndexedDeclarationAnnotationAdapter) instead");
	}

	public JavaNamedQuery createJavaNamedQuery(Member member, IndexedDeclarationAnnotationAdapter idaa) {
		JavaNamedQuery javaNamedQuery = new JavaNamedQuery(member, idaa);
		return javaNamedQuery;
	}

	public JavaNamedNativeQuery createJavaNamedNativeQuery() {
		throw new UnsupportedOperationException("Use createJavaNamedNativeQuery(Member, IndexedDeclarationAnnotationAdapter) instead");
	}

	public JavaNamedNativeQuery createJavaNamedNativeQuery(Member member, IndexedDeclarationAnnotationAdapter idaa) {
		JavaNamedNativeQuery javaNamedNativeQuery = new JavaNamedNativeQuery(member, idaa);
		return javaNamedNativeQuery;
	}

	public JavaQueryHint createJavaQueryHint() {
		throw new UnsupportedOperationException("Use createJavaQueryHint(Member, IndexedDeclarationAnnotationAdapter) instead");
	}

	public JavaUniqueConstraint createJavaUniqueConstraint() {
		throw new UnsupportedOperationException("Use createJavaUniqueConstraint(Member, IndexedDeclarationAnnotationAdapter) instead");
	}

	public JavaCascade createJavaCascade() {
		throw new UnsupportedOperationException("Use createJavaCascade(Attribute, DeclarationAnnotationElementAdapter) instead");
	}

	public JavaCascade createJavaCascade(Attribute attribute, DeclarationAnnotationElementAdapter<String[]> cascadeAdapter) {
		JavaCascade javaCascade = new JavaCascade(attribute, cascadeAdapter);
		return javaCascade;
	}

	public JavaUniqueConstraint createJavaUniqueConstraint(IUniqueConstraint.Owner owner, Member member, IndexedDeclarationAnnotationAdapter idaa) {
		JavaUniqueConstraint javaUniqueConstraint = new JavaUniqueConstraint(owner, member, idaa);
		return javaUniqueConstraint;
	}

	public JavaQueryHint createJavaQueryHint(Member member, IndexedDeclarationAnnotationAdapter idaa) {
		JavaQueryHint javaQueryHint = new JavaQueryHint(member, idaa);
		return javaQueryHint;
	}

	public JavaSequenceGenerator createJavaSequenceGenerator(Member member) {
		JavaSequenceGenerator javaSequenceGenerator = new JavaSequenceGenerator(member);
		return javaSequenceGenerator;
	}

	public JavaPrimaryKeyJoinColumn createJavaPrimaryKeyJoinColumn(IAbstractJoinColumn.Owner owner, Member member, IndexedDeclarationAnnotationAdapter idaa) {
		JavaPrimaryKeyJoinColumn javaPrimaryKeyJoinColumn = new JavaPrimaryKeyJoinColumn(owner, member, idaa);
		return javaPrimaryKeyJoinColumn;
	}

	public JavaSecondaryTable createJavaSecondaryTable() {
		throw new UnsupportedOperationException();
	}

	public JavaSecondaryTable createJavaSecondaryTable(ITable.Owner owner, Member member, IndexedDeclarationAnnotationAdapter idaa) {
		JavaSecondaryTable javaSecondaryTable = new JavaSecondaryTable(owner, member, idaa);
		return javaSecondaryTable;
	}

	public JavaDiscriminatorColumn createJavaDiscriminatorColumn(Owner owner, Type type, DeclarationAnnotationAdapter daa) {
		JavaDiscriminatorColumn javaDiscriminatorColumn = new JavaDiscriminatorColumn(owner, type, daa);
		return javaDiscriminatorColumn;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public JpaJavaMappingsPackage getJpaJavaMappingsPackage() {
		return (JpaJavaMappingsPackage) getEPackage();
	}

	public JavaJoinColumn createJavaJoinColumn(IJoinColumn.Owner joinColumnOwner, Member member, IndexedDeclarationAnnotationAdapter idaa) {
		JavaJoinColumn javaJoinColumn = new JavaJoinColumn(joinColumnOwner, member, idaa);
		return javaJoinColumn;
	}

	public JavaJoinColumn createJavaJoinColumn(IJoinColumn.Owner joinColumnOwner, Member member) {
		return this.createJavaJoinColumn(joinColumnOwner, member, NullDeclarationAnnotationAdapter.instance());
	}

	public JavaManyToOne createJavaManyToOne() {
		throw new UnsupportedOperationException("Use createJavaManyToOne(Attribute) instead");
	}

	public JavaOneToOne createJavaOneToOne() {
		throw new UnsupportedOperationException("Use createJavaOneToOne(Attribute) instead");
	}

	public JavaOneToOne createJavaOneToOne(Attribute attribute) {
		JavaOneToOne javaOneToOne = new JavaOneToOne(attribute);
		return javaOneToOne;
	}

	public JavaManyToOne createJavaManyToOne(Attribute attribute) {
		JavaManyToOne javaManyToOne = new JavaManyToOne(attribute);
		return javaManyToOne;
	}

	public JavaOneToMany createJavaOneToMany(Attribute attribute) {
		JavaOneToMany javaOneToMany = new JavaOneToMany(attribute);
		return javaOneToMany;
	}

	public JavaColumn createJavaColumn(IColumn.Owner owner, Member member, DeclarationAnnotationAdapter daa) {
		JavaColumn javaColumn = new JavaColumn(owner, member, daa);
		return javaColumn;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @deprecated
	 * @generated
	 */
	@Deprecated
	public static JpaJavaMappingsPackage getPackage() {
		return JpaJavaMappingsPackage.eINSTANCE;
	}
} //JavaMappingsFactory