kieker.analysis.model.analysisMetaModel.impl.MAnalysisMetaModelFactory Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of kieker Show documentation
Kieker: Application Performance Monitoring and Dynamic Software Analysis
The newest version!
/**
 */
package kieker.analysis.model.analysisMetaModel.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 kieker.analysis.model.analysisMetaModel.MIAnalysisMetaModelFactory;
import kieker.analysis.model.analysisMetaModel.MIAnalysisMetaModelPackage;
import kieker.analysis.model.analysisMetaModel.MIDependency;
import kieker.analysis.model.analysisMetaModel.MIDisplay;
import kieker.analysis.model.analysisMetaModel.MIDisplayConnector;
import kieker.analysis.model.analysisMetaModel.MIFilter;
import kieker.analysis.model.analysisMetaModel.MIInputPort;
import kieker.analysis.model.analysisMetaModel.MIOutputPort;
import kieker.analysis.model.analysisMetaModel.MIProject;
import kieker.analysis.model.analysisMetaModel.MIProperty;
import kieker.analysis.model.analysisMetaModel.MIReader;
import kieker.analysis.model.analysisMetaModel.MIRepository;
import kieker.analysis.model.analysisMetaModel.MIRepositoryConnector;
import kieker.analysis.model.analysisMetaModel.MIView;

/**
 * 
 * An implementation of the model Factory.
 * 
 *
 * @generated
 */
public class MAnalysisMetaModelFactory extends EFactoryImpl implements MIAnalysisMetaModelFactory {
	/**
	 * Creates the default factory implementation.
	 * 
	 * 
	 *
	 * @generated
	 */
	public static MIAnalysisMetaModelFactory init() {
		try {
			final MIAnalysisMetaModelFactory theAnalysisMetaModelFactory = (MIAnalysisMetaModelFactory) EPackage.Registry.INSTANCE
					.getEFactory(MIAnalysisMetaModelPackage.eNS_URI);
			if (theAnalysisMetaModelFactory != null) {
				return theAnalysisMetaModelFactory;
			}
		} catch (final Exception exception) {
			EcorePlugin.INSTANCE.log(exception);
		}
		return new MAnalysisMetaModelFactory();
	}

	/**
	 * Creates an instance of the factory.
	 * 
	 * 
	 *
	 * @generated
	 */
	public MAnalysisMetaModelFactory() {
		super();
	}

	/**
	 * 
	 * 
	 *
	 * @generated
	 */
	@Override
	public EObject create(final EClass eClass) {
		switch (eClass.getClassifierID()) {
		case MIAnalysisMetaModelPackage.PROJECT:
			return this.createProject();
		case MIAnalysisMetaModelPackage.INPUT_PORT:
			return this.createInputPort();
		case MIAnalysisMetaModelPackage.OUTPUT_PORT:
			return this.createOutputPort();
		case MIAnalysisMetaModelPackage.PROPERTY:
			return this.createProperty();
		case MIAnalysisMetaModelPackage.FILTER:
			return this.createFilter();
		case MIAnalysisMetaModelPackage.READER:
			return this.createReader();
		case MIAnalysisMetaModelPackage.REPOSITORY:
			return this.createRepository();
		case MIAnalysisMetaModelPackage.DEPENDENCY:
			return this.createDependency();
		case MIAnalysisMetaModelPackage.REPOSITORY_CONNECTOR:
			return this.createRepositoryConnector();
		case MIAnalysisMetaModelPackage.DISPLAY:
			return this.createDisplay();
		case MIAnalysisMetaModelPackage.VIEW:
			return this.createView();
		case MIAnalysisMetaModelPackage.DISPLAY_CONNECTOR:
			return this.createDisplayConnector();
		default:
			throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
		}
	}

	/**
	 * 
	 * 
	 *
	 * @generated
	 */
	public MIProject createProject() {
		final MProject project = new MProject();
		return project;
	}

	/**
	 * 
	 * 
	 *
	 * @generated
	 */
	public MIInputPort createInputPort() {
		final MInputPort inputPort = new MInputPort();
		return inputPort;
	}

	/**
	 * 
	 * 
	 *
	 * @generated
	 */
	public MIOutputPort createOutputPort() {
		final MOutputPort outputPort = new MOutputPort();
		return outputPort;
	}

	/**
	 * 
	 * 
	 *
	 * @generated
	 */
	public MIProperty createProperty() {
		final MProperty property = new MProperty();
		return property;
	}

	/**
	 * 
	 * 
	 *
	 * @generated
	 */
	public MIFilter createFilter() {
		final MFilter filter = new MFilter();
		return filter;
	}

	/**
	 * 
	 * 
	 *
	 * @generated
	 */
	public MIReader createReader() {
		final MReader reader = new MReader();
		return reader;
	}

	/**
	 * 
	 * 
	 *
	 * @generated
	 */
	public MIRepository createRepository() {
		final MRepository repository = new MRepository();
		return repository;
	}

	/**
	 * 
	 * 
	 *
	 * @generated
	 */
	public MIDependency createDependency() {
		final MDependency dependency = new MDependency();
		return dependency;
	}

	/**
	 * 
	 * 
	 *
	 * @generated
	 */
	public MIRepositoryConnector createRepositoryConnector() {
		final MRepositoryConnector repositoryConnector = new MRepositoryConnector();
		return repositoryConnector;
	}

	/**
	 * 
	 * 
	 *
	 * @generated
	 */
	public MIDisplay createDisplay() {
		final MDisplay display = new MDisplay();
		return display;
	}

	/**
	 * 
	 * 
	 *
	 * @generated
	 */
	public MIView createView() {
		final MView view = new MView();
		return view;
	}

	/**
	 * 
	 * 
	 *
	 * @generated
	 */
	public MIDisplayConnector createDisplayConnector() {
		final MDisplayConnector displayConnector = new MDisplayConnector();
		return displayConnector;
	}

	/**
	 * 
	 * 
	 *
	 * @generated
	 */
	public MIAnalysisMetaModelPackage getAnalysisMetaModelPackage() {
		return (MIAnalysisMetaModelPackage) this.getEPackage();
	}

	/**
	 * 
	 * 
	 *
	 * @deprecated
	 * @generated
	 */
	@Deprecated
	public static MIAnalysisMetaModelPackage getPackage() {
		return MIAnalysisMetaModelPackage.eINSTANCE;
	}

} // MAnalysisMetaModelFactory