/**
 *                                                                            
 * Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
 *                                                                            
 * 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:   
 * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation 
 */
 package org.eclipse.osbp.infogrid.model.gridsource.impl;

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.osbp.infogrid.model.gridsource.*;

/**
 * <!-- begin-user-doc -->
 * An implementation of the model <b>Factory</b>.
 * <!-- end-user-doc -->
 * @generated
 */
public class CxGridSourceFactoryImpl extends EFactoryImpl implements CxGridSourceFactory {
	/**
	 * Creates the default factory implementation.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public static CxGridSourceFactory init() {
		try {
			CxGridSourceFactory theCxGridSourceFactory = (CxGridSourceFactory)EPackage.Registry.INSTANCE.getEFactory(CxGridSourcePackage.eNS_URI);
			if (theCxGridSourceFactory != null) {
				return theCxGridSourceFactory;
			}
		}
		catch (Exception exception) {
			EcorePlugin.INSTANCE.log(exception);
		}
		return new CxGridSourceFactoryImpl();
	}

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

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public EObject create(EClass eClass) {
		switch (eClass.getClassifierID()) {
			case CxGridSourcePackage.CX_GRID_SOURCE: return createCxGridSource();
			case CxGridSourcePackage.CX_GRID_SOURCE_INPUT: return createCxGridSourceInput();
			case CxGridSourcePackage.CX_GRID_PROPERTY: return createCxGridProperty();
			case CxGridSourcePackage.CX_GRID_NESTED_FIELD: return createCxGridNestedField();
			case CxGridSourcePackage.CX_GRID_NESTED_PATH: return createCxGridNestedPath();
			case CxGridSourcePackage.CX_GRID_SOURCE_EQ_FILTER: return createCxGridSourceEQFilter();
			default:
				throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
		}
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public CxGridSource createCxGridSource() {
		CxGridSourceImpl cxGridSource = new CxGridSourceImpl();
		return cxGridSource;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public CxGridSourceInput createCxGridSourceInput() {
		CxGridSourceInputImpl cxGridSourceInput = new CxGridSourceInputImpl();
		return cxGridSourceInput;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public CxGridProperty createCxGridProperty() {
		CxGridPropertyImpl cxGridProperty = new CxGridPropertyImpl();
		return cxGridProperty;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public CxGridNestedField createCxGridNestedField() {
		CxGridNestedFieldImpl cxGridNestedField = new CxGridNestedFieldImpl();
		return cxGridNestedField;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public CxGridNestedPath createCxGridNestedPath() {
		CxGridNestedPathImpl cxGridNestedPath = new CxGridNestedPathImpl();
		return cxGridNestedPath;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public CxGridSourceEQFilter createCxGridSourceEQFilter() {
		CxGridSourceEQFilterImpl cxGridSourceEQFilter = new CxGridSourceEQFilterImpl();
		return cxGridSourceEQFilter;
	}

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

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

} //CxGridSourceFactoryImpl
