/**
 * 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 
 * 
 *  Based on ideas from Xtext, Xtend, Xcore
 *   
 *  Contributors:  
 *  		Joerg Riegel - Initial implementation 
 *  
 */
package org.eclipse.osbp.xtext.datamartdsl.util;

import org.eclipse.emf.common.notify.Adapter;
import org.eclipse.emf.common.notify.Notifier;

import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;

import org.eclipse.emf.ecore.EObject;

import org.eclipse.osbp.dsl.semantic.common.types.LLazyResolver;
import org.eclipse.osbp.dsl.semantic.common.types.LPackage;

import org.eclipse.osbp.xtext.datamartdsl.*;

/**
 * <!-- begin-user-doc -->
 * The <b>Adapter Factory</b> for the model.
 * It provides an adapter <code>createXXX</code> method for each class of the model.
 * <!-- end-user-doc -->
 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartDSLPackage
 * @generated
 */
public class DatamartDSLAdapterFactory extends AdapterFactoryImpl {
	/**
	 * The cached model package.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	protected static DatamartDSLPackage modelPackage;

	/**
	 * Creates an instance of the adapter factory.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public DatamartDSLAdapterFactory() {
		if (modelPackage == null) {
			modelPackage = DatamartDSLPackage.eINSTANCE;
		}
	}

	/**
	 * Returns whether this factory is applicable for the type of the object.
	 * <!-- begin-user-doc -->
	 * This implementation returns <code>true</code> if the object is either the model's package or is an instance object of the model.
	 * <!-- end-user-doc -->
	 * @return whether this factory is applicable for the type of the object.
	 * @generated
	 */
	@Override
	public boolean isFactoryForType(Object object) {
		if (object == modelPackage) {
			return true;
		}
		if (object instanceof EObject) {
			return ((EObject)object).eClass().getEPackage() == modelPackage;
		}
		return false;
	}

	/**
	 * The switch that delegates to the <code>createXXX</code> methods.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	protected DatamartDSLSwitch<Adapter> modelSwitch =
		new DatamartDSLSwitch<Adapter>() {
			@Override
			public Adapter caseDatamartModel(DatamartModel object) {
				return createDatamartModelAdapter();
			}
			@Override
			public Adapter caseDatamartLazyResolver(DatamartLazyResolver object) {
				return createDatamartLazyResolverAdapter();
			}
			@Override
			public Adapter caseDatamartBase(DatamartBase object) {
				return createDatamartBaseAdapter();
			}
			@Override
			public Adapter caseDatamartPackage(DatamartPackage object) {
				return createDatamartPackageAdapter();
			}
			@Override
			public Adapter caseDatamartDefinition(DatamartDefinition object) {
				return createDatamartDefinitionAdapter();
			}
			@Override
			public Adapter caseDatamartSource(DatamartSource object) {
				return createDatamartSourceAdapter();
			}
			@Override
			public Adapter caseDatamartRole(DatamartRole object) {
				return createDatamartRoleAdapter();
			}
			@Override
			public Adapter caseDatamartTask(DatamartTask object) {
				return createDatamartTaskAdapter();
			}
			@Override
			public Adapter caseDatamartCube(DatamartCube object) {
				return createDatamartCubeAdapter();
			}
			@Override
			public Adapter caseDatamartEntity(DatamartEntity object) {
				return createDatamartEntityAdapter();
			}
			@Override
			public Adapter caseDatamartColumn(DatamartColumn object) {
				return createDatamartColumnAdapter();
			}
			@Override
			public Adapter caseDatamartTaskFilter(DatamartTaskFilter object) {
				return createDatamartTaskFilterAdapter();
			}
			@Override
			public Adapter caseDatamartNavigation(DatamartNavigation object) {
				return createDatamartNavigationAdapter();
			}
			@Override
			public Adapter caseDatamartOwner(DatamartOwner object) {
				return createDatamartOwnerAdapter();
			}
			@Override
			public Adapter caseDatamartMember(DatamartMember object) {
				return createDatamartMemberAdapter();
			}
			@Override
			public Adapter caseDatamartAxis(DatamartAxis object) {
				return createDatamartAxisAdapter();
			}
			@Override
			public Adapter caseDatamartAttributeBase(DatamartAttributeBase object) {
				return createDatamartAttributeBaseAdapter();
			}
			@Override
			public Adapter caseDatamartAttribute(DatamartAttribute object) {
				return createDatamartAttributeAdapter();
			}
			@Override
			public Adapter caseExpression(Expression object) {
				return createExpressionAdapter();
			}
			@Override
			public Adapter caseDatamartCondition(DatamartCondition object) {
				return createDatamartConditionAdapter();
			}
			@Override
			public Adapter caseDatamartOrder(DatamartOrder object) {
				return createDatamartOrderAdapter();
			}
			@Override
			public Adapter caseDatamartCubeElement(DatamartCubeElement object) {
				return createDatamartCubeElementAdapter();
			}
			@Override
			public Adapter caseDatamartDefineDerivedMeasure(DatamartDefineDerivedMeasure object) {
				return createDatamartDefineDerivedMeasureAdapter();
			}
			@Override
			public Adapter caseDatamartFunctionInterface(DatamartFunctionInterface object) {
				return createDatamartFunctionInterfaceAdapter();
			}
			@Override
			public Adapter caseDatamartFunction(DatamartFunction object) {
				return createDatamartFunctionAdapter();
			}
			@Override
			public Adapter caseDatamartParameterFunction(DatamartParameterFunction object) {
				return createDatamartParameterFunctionAdapter();
			}
			@Override
			public Adapter caseDatamartFunctionIntParameter(DatamartFunctionIntParameter object) {
				return createDatamartFunctionIntParameterAdapter();
			}
			@Override
			public Adapter caseDatamartSetFunctionInterface(DatamartSetFunctionInterface object) {
				return createDatamartSetFunctionInterfaceAdapter();
			}
			@Override
			public Adapter caseDatamartSetFunction(DatamartSetFunction object) {
				return createDatamartSetFunctionAdapter();
			}
			@Override
			public Adapter caseDatamartSetParameterFunction(DatamartSetParameterFunction object) {
				return createDatamartSetParameterFunctionAdapter();
			}
			@Override
			public Adapter caseDatamartAggregationFunctionInterface(DatamartAggregationFunctionInterface object) {
				return createDatamartAggregationFunctionInterfaceAdapter();
			}
			@Override
			public Adapter caseDatamartSetAggregationFunction(DatamartSetAggregationFunction object) {
				return createDatamartSetAggregationFunctionAdapter();
			}
			@Override
			public Adapter caseDatamartAggregationExpression(DatamartAggregationExpression object) {
				return createDatamartAggregationExpressionAdapter();
			}
			@Override
			public Adapter caseDatamartSetTuple(DatamartSetTuple object) {
				return createDatamartSetTupleAdapter();
			}
			@Override
			public Adapter caseDatamartSetAggregation(DatamartSetAggregation object) {
				return createDatamartSetAggregationAdapter();
			}
			@Override
			public Adapter caseDatamartAggregation(DatamartAggregation object) {
				return createDatamartAggregationAdapter();
			}
			@Override
			public Adapter caseDatamartMemberTuple(DatamartMemberTuple object) {
				return createDatamartMemberTupleAdapter();
			}
			@Override
			public Adapter caseDatamartAggregationFunction(DatamartAggregationFunction object) {
				return createDatamartAggregationFunctionAdapter();
			}
			@Override
			public Adapter caseDatamartSlicer(DatamartSlicer object) {
				return createDatamartSlicerAdapter();
			}
			@Override
			public Adapter caseDatamartCubeAxis(DatamartCubeAxis object) {
				return createDatamartCubeAxisAdapter();
			}
			@Override
			public Adapter caseDatamartElement(DatamartElement object) {
				return createDatamartElementAdapter();
			}
			@Override
			public Adapter caseDatamartDerivedMeasure(DatamartDerivedMeasure object) {
				return createDatamartDerivedMeasureAdapter();
			}
			@Override
			public Adapter caseDatamartMeasure(DatamartMeasure object) {
				return createDatamartMeasureAdapter();
			}
			@Override
			public Adapter caseDatamartHierarchy(DatamartHierarchy object) {
				return createDatamartHierarchyAdapter();
			}
			@Override
			public Adapter caseCalculation(Calculation object) {
				return createCalculationAdapter();
			}
			@Override
			public Adapter caseDatamartReference(DatamartReference object) {
				return createDatamartReferenceAdapter();
			}
			@Override
			public Adapter caseAddition(Addition object) {
				return createAdditionAdapter();
			}
			@Override
			public Adapter caseDivision(Division object) {
				return createDivisionAdapter();
			}
			@Override
			public Adapter caseMultiplication(Multiplication object) {
				return createMultiplicationAdapter();
			}
			@Override
			public Adapter caseSubtraction(Subtraction object) {
				return createSubtractionAdapter();
			}
			@Override
			public Adapter caseConjunction(Conjunction object) {
				return createConjunctionAdapter();
			}
			@Override
			public Adapter caseDisjunction(Disjunction object) {
				return createDisjunctionAdapter();
			}
			@Override
			public Adapter caseConditionalExpression(ConditionalExpression object) {
				return createConditionalExpressionAdapter();
			}
			@Override
			public Adapter caseAttributeFillerData(AttributeFillerData object) {
				return createAttributeFillerDataAdapter();
			}
			@Override
			public Adapter caseAttributeFillerType(AttributeFillerType object) {
				return createAttributeFillerTypeAdapter();
			}
			@Override
			public Adapter caseAttributeFillerDateType(AttributeFillerDateType object) {
				return createAttributeFillerDateTypeAdapter();
			}
			@Override
			public Adapter caseAttributeFillerDoubleType(AttributeFillerDoubleType object) {
				return createAttributeFillerDoubleTypeAdapter();
			}
			@Override
			public Adapter caseAttributeFillerIntegerType(AttributeFillerIntegerType object) {
				return createAttributeFillerIntegerTypeAdapter();
			}
			@Override
			public Adapter caseAttributeFillerTextType(AttributeFillerTextType object) {
				return createAttributeFillerTextTypeAdapter();
			}
			@Override
			public Adapter caseAttributeFillerDateFuture(AttributeFillerDateFuture object) {
				return createAttributeFillerDateFutureAdapter();
			}
			@Override
			public Adapter caseAttributeFillerDatePast(AttributeFillerDatePast object) {
				return createAttributeFillerDatePastAdapter();
			}
			@Override
			public Adapter caseAttributeFillerDateRange(AttributeFillerDateRange object) {
				return createAttributeFillerDateRangeAdapter();
			}
			@Override
			public Adapter caseAttributeFillerSignedDoubleRange(AttributeFillerSignedDoubleRange object) {
				return createAttributeFillerSignedDoubleRangeAdapter();
			}
			@Override
			public Adapter caseAttributeFillerSignedDoubleRandom(AttributeFillerSignedDoubleRandom object) {
				return createAttributeFillerSignedDoubleRandomAdapter();
			}
			@Override
			public Adapter caseAttributeFillerSignedIntegerRange(AttributeFillerSignedIntegerRange object) {
				return createAttributeFillerSignedIntegerRangeAdapter();
			}
			@Override
			public Adapter caseAttributeFillerSignedIntegerRandom(AttributeFillerSignedIntegerRandom object) {
				return createAttributeFillerSignedIntegerRandomAdapter();
			}
			@Override
			public Adapter caseAttributeFillerTextRandom(AttributeFillerTextRandom object) {
				return createAttributeFillerTextRandomAdapter();
			}
			@Override
			public Adapter caseAttributeFillerTextParagraphs(AttributeFillerTextParagraphs object) {
				return createAttributeFillerTextParagraphsAdapter();
			}
			@Override
			public Adapter caseAttributeFillerTextSentences(AttributeFillerTextSentences object) {
				return createAttributeFillerTextSentencesAdapter();
			}
			@Override
			public Adapter caseAttributeFillerTextWords(AttributeFillerTextWords object) {
				return createAttributeFillerTextWordsAdapter();
			}
			@Override
			public Adapter caseAttributeFillerUnsignedDoubleRange(AttributeFillerUnsignedDoubleRange object) {
				return createAttributeFillerUnsignedDoubleRangeAdapter();
			}
			@Override
			public Adapter caseAttributeFillerUnsignedDoubleRandom(AttributeFillerUnsignedDoubleRandom object) {
				return createAttributeFillerUnsignedDoubleRandomAdapter();
			}
			@Override
			public Adapter caseAttributeFillerUnsignedIntegerRange(AttributeFillerUnsignedIntegerRange object) {
				return createAttributeFillerUnsignedIntegerRangeAdapter();
			}
			@Override
			public Adapter caseAttributeFillerUnsignedIntegerRandom(AttributeFillerUnsignedIntegerRandom object) {
				return createAttributeFillerUnsignedIntegerRandomAdapter();
			}
			@Override
			public Adapter caseLLazyResolver(LLazyResolver object) {
				return createLLazyResolverAdapter();
			}
			@Override
			public Adapter caseLPackage(LPackage object) {
				return createLPackageAdapter();
			}
			@Override
			public Adapter defaultCase(EObject object) {
				return createEObjectAdapter();
			}
		};

	/**
	 * Creates an adapter for the <code>target</code>.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param target the object to adapt.
	 * @return the adapter for the <code>target</code>.
	 * @generated
	 */
	@Override
	public Adapter createAdapter(Notifier target) {
		return modelSwitch.doSwitch((EObject)target);
	}


	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartModel <em>Datamart Model</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartModel
	 * @generated
	 */
	public Adapter createDatamartModelAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartLazyResolver <em>Datamart Lazy Resolver</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartLazyResolver
	 * @generated
	 */
	public Adapter createDatamartLazyResolverAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartBase <em>Datamart Base</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartBase
	 * @generated
	 */
	public Adapter createDatamartBaseAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartPackage <em>Datamart Package</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartPackage
	 * @generated
	 */
	public Adapter createDatamartPackageAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartDefinition <em>Datamart Definition</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartDefinition
	 * @generated
	 */
	public Adapter createDatamartDefinitionAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartSource <em>Datamart Source</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartSource
	 * @generated
	 */
	public Adapter createDatamartSourceAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartRole <em>Datamart Role</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartRole
	 * @generated
	 */
	public Adapter createDatamartRoleAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartTask <em>Datamart Task</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartTask
	 * @generated
	 */
	public Adapter createDatamartTaskAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartCube <em>Datamart Cube</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartCube
	 * @generated
	 */
	public Adapter createDatamartCubeAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartEntity <em>Datamart Entity</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartEntity
	 * @generated
	 */
	public Adapter createDatamartEntityAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartColumn <em>Datamart Column</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartColumn
	 * @generated
	 */
	public Adapter createDatamartColumnAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartTaskFilter <em>Datamart Task Filter</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartTaskFilter
	 * @generated
	 */
	public Adapter createDatamartTaskFilterAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartNavigation <em>Datamart Navigation</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartNavigation
	 * @generated
	 */
	public Adapter createDatamartNavigationAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartOwner <em>Datamart Owner</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartOwner
	 * @generated
	 */
	public Adapter createDatamartOwnerAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartMember <em>Datamart Member</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartMember
	 * @generated
	 */
	public Adapter createDatamartMemberAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartAxis <em>Datamart Axis</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartAxis
	 * @generated
	 */
	public Adapter createDatamartAxisAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartAttributeBase <em>Datamart Attribute Base</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartAttributeBase
	 * @generated
	 */
	public Adapter createDatamartAttributeBaseAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartAttribute <em>Datamart Attribute</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartAttribute
	 * @generated
	 */
	public Adapter createDatamartAttributeAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.Expression <em>Expression</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.Expression
	 * @generated
	 */
	public Adapter createExpressionAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartCondition <em>Datamart Condition</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartCondition
	 * @generated
	 */
	public Adapter createDatamartConditionAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartOrder <em>Datamart Order</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartOrder
	 * @generated
	 */
	public Adapter createDatamartOrderAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartCubeElement <em>Datamart Cube Element</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartCubeElement
	 * @generated
	 */
	public Adapter createDatamartCubeElementAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartDefineDerivedMeasure <em>Datamart Define Derived Measure</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartDefineDerivedMeasure
	 * @generated
	 */
	public Adapter createDatamartDefineDerivedMeasureAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartFunctionInterface <em>Datamart Function Interface</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartFunctionInterface
	 * @generated
	 */
	public Adapter createDatamartFunctionInterfaceAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartFunction <em>Datamart Function</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartFunction
	 * @generated
	 */
	public Adapter createDatamartFunctionAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartParameterFunction <em>Datamart Parameter Function</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartParameterFunction
	 * @generated
	 */
	public Adapter createDatamartParameterFunctionAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartFunctionIntParameter <em>Datamart Function Int Parameter</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartFunctionIntParameter
	 * @generated
	 */
	public Adapter createDatamartFunctionIntParameterAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartSetFunctionInterface <em>Datamart Set Function Interface</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartSetFunctionInterface
	 * @generated
	 */
	public Adapter createDatamartSetFunctionInterfaceAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartSetFunction <em>Datamart Set Function</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartSetFunction
	 * @generated
	 */
	public Adapter createDatamartSetFunctionAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartSetParameterFunction <em>Datamart Set Parameter Function</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartSetParameterFunction
	 * @generated
	 */
	public Adapter createDatamartSetParameterFunctionAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartAggregationFunctionInterface <em>Datamart Aggregation Function Interface</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartAggregationFunctionInterface
	 * @generated
	 */
	public Adapter createDatamartAggregationFunctionInterfaceAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartSetAggregationFunction <em>Datamart Set Aggregation Function</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartSetAggregationFunction
	 * @generated
	 */
	public Adapter createDatamartSetAggregationFunctionAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartAggregationExpression <em>Datamart Aggregation Expression</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartAggregationExpression
	 * @generated
	 */
	public Adapter createDatamartAggregationExpressionAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartSetTuple <em>Datamart Set Tuple</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartSetTuple
	 * @generated
	 */
	public Adapter createDatamartSetTupleAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartSetAggregation <em>Datamart Set Aggregation</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartSetAggregation
	 * @generated
	 */
	public Adapter createDatamartSetAggregationAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartAggregation <em>Datamart Aggregation</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartAggregation
	 * @generated
	 */
	public Adapter createDatamartAggregationAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartMemberTuple <em>Datamart Member Tuple</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartMemberTuple
	 * @generated
	 */
	public Adapter createDatamartMemberTupleAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartAggregationFunction <em>Datamart Aggregation Function</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartAggregationFunction
	 * @generated
	 */
	public Adapter createDatamartAggregationFunctionAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartSlicer <em>Datamart Slicer</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartSlicer
	 * @generated
	 */
	public Adapter createDatamartSlicerAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartCubeAxis <em>Datamart Cube Axis</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartCubeAxis
	 * @generated
	 */
	public Adapter createDatamartCubeAxisAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartElement <em>Datamart Element</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartElement
	 * @generated
	 */
	public Adapter createDatamartElementAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartDerivedMeasure <em>Datamart Derived Measure</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartDerivedMeasure
	 * @generated
	 */
	public Adapter createDatamartDerivedMeasureAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartMeasure <em>Datamart Measure</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartMeasure
	 * @generated
	 */
	public Adapter createDatamartMeasureAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartHierarchy <em>Datamart Hierarchy</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartHierarchy
	 * @generated
	 */
	public Adapter createDatamartHierarchyAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.Calculation <em>Calculation</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.Calculation
	 * @generated
	 */
	public Adapter createCalculationAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.DatamartReference <em>Datamart Reference</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.DatamartReference
	 * @generated
	 */
	public Adapter createDatamartReferenceAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.Addition <em>Addition</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.Addition
	 * @generated
	 */
	public Adapter createAdditionAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.Division <em>Division</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.Division
	 * @generated
	 */
	public Adapter createDivisionAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.Multiplication <em>Multiplication</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.Multiplication
	 * @generated
	 */
	public Adapter createMultiplicationAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.Subtraction <em>Subtraction</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.Subtraction
	 * @generated
	 */
	public Adapter createSubtractionAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.Conjunction <em>Conjunction</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.Conjunction
	 * @generated
	 */
	public Adapter createConjunctionAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.Disjunction <em>Disjunction</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.Disjunction
	 * @generated
	 */
	public Adapter createDisjunctionAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.ConditionalExpression <em>Conditional Expression</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.ConditionalExpression
	 * @generated
	 */
	public Adapter createConditionalExpressionAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.AttributeFillerData <em>Attribute Filler Data</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.AttributeFillerData
	 * @generated
	 */
	public Adapter createAttributeFillerDataAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.AttributeFillerType <em>Attribute Filler Type</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.AttributeFillerType
	 * @generated
	 */
	public Adapter createAttributeFillerTypeAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.AttributeFillerDateType <em>Attribute Filler Date Type</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.AttributeFillerDateType
	 * @generated
	 */
	public Adapter createAttributeFillerDateTypeAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.AttributeFillerDoubleType <em>Attribute Filler Double Type</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.AttributeFillerDoubleType
	 * @generated
	 */
	public Adapter createAttributeFillerDoubleTypeAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.AttributeFillerIntegerType <em>Attribute Filler Integer Type</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.AttributeFillerIntegerType
	 * @generated
	 */
	public Adapter createAttributeFillerIntegerTypeAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.AttributeFillerTextType <em>Attribute Filler Text Type</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.AttributeFillerTextType
	 * @generated
	 */
	public Adapter createAttributeFillerTextTypeAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.AttributeFillerDateFuture <em>Attribute Filler Date Future</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.AttributeFillerDateFuture
	 * @generated
	 */
	public Adapter createAttributeFillerDateFutureAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.AttributeFillerDatePast <em>Attribute Filler Date Past</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.AttributeFillerDatePast
	 * @generated
	 */
	public Adapter createAttributeFillerDatePastAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.AttributeFillerDateRange <em>Attribute Filler Date Range</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.AttributeFillerDateRange
	 * @generated
	 */
	public Adapter createAttributeFillerDateRangeAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.AttributeFillerSignedDoubleRange <em>Attribute Filler Signed Double Range</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.AttributeFillerSignedDoubleRange
	 * @generated
	 */
	public Adapter createAttributeFillerSignedDoubleRangeAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.AttributeFillerSignedDoubleRandom <em>Attribute Filler Signed Double Random</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.AttributeFillerSignedDoubleRandom
	 * @generated
	 */
	public Adapter createAttributeFillerSignedDoubleRandomAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.AttributeFillerSignedIntegerRange <em>Attribute Filler Signed Integer Range</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.AttributeFillerSignedIntegerRange
	 * @generated
	 */
	public Adapter createAttributeFillerSignedIntegerRangeAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.AttributeFillerSignedIntegerRandom <em>Attribute Filler Signed Integer Random</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.AttributeFillerSignedIntegerRandom
	 * @generated
	 */
	public Adapter createAttributeFillerSignedIntegerRandomAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.AttributeFillerTextRandom <em>Attribute Filler Text Random</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.AttributeFillerTextRandom
	 * @generated
	 */
	public Adapter createAttributeFillerTextRandomAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.AttributeFillerTextParagraphs <em>Attribute Filler Text Paragraphs</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.AttributeFillerTextParagraphs
	 * @generated
	 */
	public Adapter createAttributeFillerTextParagraphsAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.AttributeFillerTextSentences <em>Attribute Filler Text Sentences</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.AttributeFillerTextSentences
	 * @generated
	 */
	public Adapter createAttributeFillerTextSentencesAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.AttributeFillerTextWords <em>Attribute Filler Text Words</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.AttributeFillerTextWords
	 * @generated
	 */
	public Adapter createAttributeFillerTextWordsAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.AttributeFillerUnsignedDoubleRange <em>Attribute Filler Unsigned Double Range</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.AttributeFillerUnsignedDoubleRange
	 * @generated
	 */
	public Adapter createAttributeFillerUnsignedDoubleRangeAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.AttributeFillerUnsignedDoubleRandom <em>Attribute Filler Unsigned Double Random</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.AttributeFillerUnsignedDoubleRandom
	 * @generated
	 */
	public Adapter createAttributeFillerUnsignedDoubleRandomAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.AttributeFillerUnsignedIntegerRange <em>Attribute Filler Unsigned Integer Range</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.AttributeFillerUnsignedIntegerRange
	 * @generated
	 */
	public Adapter createAttributeFillerUnsignedIntegerRangeAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.datamartdsl.AttributeFillerUnsignedIntegerRandom <em>Attribute Filler Unsigned Integer Random</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.xtext.datamartdsl.AttributeFillerUnsignedIntegerRandom
	 * @generated
	 */
	public Adapter createAttributeFillerUnsignedIntegerRandomAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.dsl.semantic.common.types.LLazyResolver <em>LLazy Resolver</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.dsl.semantic.common.types.LLazyResolver
	 * @generated
	 */
	public Adapter createLLazyResolverAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.dsl.semantic.common.types.LPackage <em>LPackage</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.osbp.dsl.semantic.common.types.LPackage
	 * @generated
	 */
	public Adapter createLPackageAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for the default case.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @generated
	 */
	public Adapter createEObjectAdapter() {
		return null;
	}

} //DatamartDSLAdapterFactory
