| /******************************************************************************* |
| * Copyright (c) 2009, 2014, 2018 Xored Software Inc 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: |
| * Xored Software Inc - initial API and implementation and/or initial documentation |
| *******************************************************************************/ |
| package org.eclipse.rcptt.ecl.operations.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.rcptt.ecl.core.Command; |
| import org.eclipse.rcptt.ecl.operations.Abs; |
| import org.eclipse.rcptt.ecl.operations.And; |
| import org.eclipse.rcptt.ecl.operations.AssertEmpty; |
| import org.eclipse.rcptt.ecl.operations.AssertNonEmpty; |
| import org.eclipse.rcptt.ecl.operations.AssertTrue; |
| import org.eclipse.rcptt.ecl.operations.Between; |
| import org.eclipse.rcptt.ecl.operations.BinaryOp; |
| import org.eclipse.rcptt.ecl.operations.Bool; |
| import org.eclipse.rcptt.ecl.operations.Concat; |
| import org.eclipse.rcptt.ecl.operations.Convert; |
| import org.eclipse.rcptt.ecl.operations.Div; |
| import org.eclipse.rcptt.ecl.operations.Each; |
| import org.eclipse.rcptt.ecl.operations.Emit; |
| import org.eclipse.rcptt.ecl.operations.Entry; |
| import org.eclipse.rcptt.ecl.operations.Eq; |
| import org.eclipse.rcptt.ecl.operations.FindAll; |
| import org.eclipse.rcptt.ecl.operations.Format; |
| import org.eclipse.rcptt.ecl.operations.FormatTime; |
| import org.eclipse.rcptt.ecl.operations.GetTime; |
| import org.eclipse.rcptt.ecl.operations.Gt; |
| import org.eclipse.rcptt.ecl.operations.Int; |
| import org.eclipse.rcptt.ecl.operations.Length; |
| import org.eclipse.rcptt.ecl.operations.List; |
| import org.eclipse.rcptt.ecl.operations.Loop; |
| import org.eclipse.rcptt.ecl.operations.Lt; |
| import org.eclipse.rcptt.ecl.operations.Map; |
| import org.eclipse.rcptt.ecl.operations.Minus; |
| import org.eclipse.rcptt.ecl.operations.Mod; |
| import org.eclipse.rcptt.ecl.operations.Mult; |
| import org.eclipse.rcptt.ecl.operations.Not; |
| import org.eclipse.rcptt.ecl.operations.NotEq; |
| import org.eclipse.rcptt.ecl.operations.OperationsPackage; |
| import org.eclipse.rcptt.ecl.operations.Or; |
| import org.eclipse.rcptt.ecl.operations.ParseTime; |
| import org.eclipse.rcptt.ecl.operations.Plus; |
| import org.eclipse.rcptt.ecl.operations.Recur; |
| import org.eclipse.rcptt.ecl.operations.Repeat; |
| import org.eclipse.rcptt.ecl.operations.RepeatWith; |
| import org.eclipse.rcptt.ecl.operations.Split; |
| import org.eclipse.rcptt.ecl.operations.Str; |
| import org.eclipse.rcptt.ecl.operations.ThrowError; |
| import org.eclipse.rcptt.ecl.operations.ToList; |
| import org.eclipse.rcptt.ecl.operations.Try; |
| |
| /** |
| * <!-- 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.rcptt.ecl.operations.OperationsPackage |
| * @generated |
| */ |
| public class OperationsAdapterFactory extends AdapterFactoryImpl { |
| /** |
| * The cached model package. |
| * <!-- begin-user-doc --> <!-- end-user-doc --> |
| * @generated |
| */ |
| protected static OperationsPackage modelPackage; |
| |
| /** |
| * Creates an instance of the adapter factory. |
| * <!-- begin-user-doc --> <!-- |
| * end-user-doc --> |
| * @generated |
| */ |
| public OperationsAdapterFactory() { |
| if (modelPackage == null) { |
| modelPackage = OperationsPackage.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 OperationsSwitch<Adapter> modelSwitch = new OperationsSwitch<Adapter>() { |
| @Override |
| public Adapter caseEq(Eq object) { |
| return createEqAdapter(); |
| } |
| @Override |
| public Adapter caseInt(Int object) { |
| return createIntAdapter(); |
| } |
| @Override |
| public Adapter caseLong(org.eclipse.rcptt.ecl.operations.Long object) { |
| return createLongAdapter(); |
| } |
| @Override |
| public Adapter caseFloat(org.eclipse.rcptt.ecl.operations.Float object) { |
| return createFloatAdapter(); |
| } |
| @Override |
| public Adapter caseBool(Bool object) { |
| return createBoolAdapter(); |
| } |
| @Override |
| public Adapter caseStr(Str object) { |
| return createStrAdapter(); |
| } |
| @Override |
| public Adapter caseConvert(Convert object) { |
| return createConvertAdapter(); |
| } |
| @Override |
| public Adapter caseAssertTrue(AssertTrue object) { |
| return createAssertTrueAdapter(); |
| } |
| @Override |
| public Adapter caseLength(Length object) { |
| return createLengthAdapter(); |
| } |
| @Override |
| public Adapter caseNotEq(NotEq object) { |
| return createNotEqAdapter(); |
| } |
| @Override |
| public Adapter caseGt(Gt object) { |
| return createGtAdapter(); |
| } |
| @Override |
| public Adapter caseLt(Lt object) { |
| return createLtAdapter(); |
| } |
| @Override |
| public Adapter caseNot(Not object) { |
| return createNotAdapter(); |
| } |
| @Override |
| public Adapter caseTry(Try object) { |
| return createTryAdapter(); |
| } |
| @Override |
| public Adapter caseFormat(Format object) { |
| return createFormatAdapter(); |
| } |
| @Override |
| public Adapter caseEmit(Emit object) { |
| return createEmitAdapter(); |
| } |
| @Override |
| public Adapter caseRepeatWith(RepeatWith object) { |
| return createRepeatWithAdapter(); |
| } |
| @Override |
| public Adapter caseRepeat(Repeat object) { |
| return createRepeatAdapter(); |
| } |
| @Override |
| public Adapter caseAssertEmpty(AssertEmpty object) { |
| return createAssertEmptyAdapter(); |
| } |
| @Override |
| public Adapter caseAssertNonEmpty(AssertNonEmpty object) { |
| return createAssertNonEmptyAdapter(); |
| } |
| @Override |
| public Adapter caseConcat(Concat object) { |
| return createConcatAdapter(); |
| } |
| @Override |
| public Adapter caseOr(Or object) { |
| return createOrAdapter(); |
| } |
| @Override |
| public Adapter caseAnd(And object) { |
| return createAndAdapter(); |
| } |
| @Override |
| public Adapter caseGetTime(GetTime object) { |
| return createGetTimeAdapter(); |
| } |
| @Override |
| public Adapter caseFormatTime(FormatTime object) { |
| return createFormatTimeAdapter(); |
| } |
| @Override |
| public Adapter caseBinaryOp(BinaryOp object) { |
| return createBinaryOpAdapter(); |
| } |
| @Override |
| public Adapter casePlus(Plus object) { |
| return createPlusAdapter(); |
| } |
| @Override |
| public Adapter caseMinus(Minus object) { |
| return createMinusAdapter(); |
| } |
| @Override |
| public Adapter caseDiv(Div object) { |
| return createDivAdapter(); |
| } |
| @Override |
| public Adapter caseMult(Mult object) { |
| return createMultAdapter(); |
| } |
| @Override |
| public Adapter caseAbs(Abs object) { |
| return createAbsAdapter(); |
| } |
| @Override |
| public Adapter caseMod(Mod object) { |
| return createModAdapter(); |
| } |
| @Override |
| public Adapter caseBetween(Between object) { |
| return createBetweenAdapter(); |
| } |
| @Override |
| public Adapter caseEntry(Entry object) { |
| return createEntryAdapter(); |
| } |
| @Override |
| public Adapter caseMap(Map object) { |
| return createMapAdapter(); |
| } |
| @Override |
| public Adapter caseList(List object) { |
| return createListAdapter(); |
| } |
| @Override |
| public Adapter caseLoop(Loop object) { |
| return createLoopAdapter(); |
| } |
| @Override |
| public Adapter caseRecur(Recur object) { |
| return createRecurAdapter(); |
| } |
| @Override |
| public Adapter caseToList(ToList object) { |
| return createToListAdapter(); |
| } |
| @Override |
| public Adapter caseEach(Each object) { |
| return createEachAdapter(); |
| } |
| @Override |
| public Adapter caseSplit(Split object) { |
| return createSplitAdapter(); |
| } |
| @Override |
| public Adapter caseParseTime(ParseTime object) { |
| return createParseTimeAdapter(); |
| } |
| @Override |
| public Adapter caseThrowError(ThrowError object) { |
| return createThrowErrorAdapter(); |
| } |
| @Override |
| public Adapter caseFindAll(FindAll object) { |
| return createFindAllAdapter(); |
| } |
| @Override |
| public Adapter caseCommand(Command object) { |
| return createCommandAdapter(); |
| } |
| @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.rcptt.ecl.operations.Eq <em>Eq</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.rcptt.ecl.operations.Eq |
| * @generated |
| */ |
| public Adapter createEqAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.rcptt.ecl.operations.Int <em>Int</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.rcptt.ecl.operations.Int |
| * @generated |
| */ |
| public Adapter createIntAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class ' {@link org.eclipse.rcptt.ecl.operations.Long <em>Long</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.rcptt.ecl.operations.Long |
| * @generated |
| */ |
| public Adapter createLongAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class ' {@link org.eclipse.rcptt.ecl.operations.Float <em>Float</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.rcptt.ecl.operations.Float |
| * @generated |
| */ |
| public Adapter createFloatAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class ' {@link org.eclipse.rcptt.ecl.operations.Bool <em>Bool</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.rcptt.ecl.operations.Bool |
| * @generated |
| */ |
| public Adapter createBoolAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.rcptt.ecl.operations.Str <em>Str</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.rcptt.ecl.operations.Str |
| * @generated |
| */ |
| public Adapter createStrAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class ' {@link org.eclipse.rcptt.ecl.operations.Convert <em>Convert</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.rcptt.ecl.operations.Convert |
| * @generated |
| */ |
| public Adapter createConvertAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class ' {@link org.eclipse.rcptt.ecl.operations.AssertTrue <em>Assert True</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.rcptt.ecl.operations.AssertTrue |
| * @generated |
| */ |
| public Adapter createAssertTrueAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class ' {@link org.eclipse.rcptt.ecl.operations.Length <em>Length</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.rcptt.ecl.operations.Length |
| * @generated |
| */ |
| public Adapter createLengthAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class ' {@link org.eclipse.rcptt.ecl.operations.NotEq <em>Not Eq</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.rcptt.ecl.operations.NotEq |
| * @generated |
| */ |
| public Adapter createNotEqAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.rcptt.ecl.operations.Gt <em>Gt</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.rcptt.ecl.operations.Gt |
| * @generated |
| */ |
| public Adapter createGtAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.rcptt.ecl.operations.Lt <em>Lt</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.rcptt.ecl.operations.Lt |
| * @generated |
| */ |
| public Adapter createLtAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.rcptt.ecl.operations.Not <em>Not</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.rcptt.ecl.operations.Not |
| * @generated |
| */ |
| public Adapter createNotAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.rcptt.ecl.operations.Try <em>Try</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.rcptt.ecl.operations.Try |
| * @generated |
| */ |
| public Adapter createTryAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class ' {@link org.eclipse.rcptt.ecl.operations.Format <em>Format</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.rcptt.ecl.operations.Format |
| * @generated |
| */ |
| public Adapter createFormatAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class ' {@link org.eclipse.rcptt.ecl.operations.Emit <em>Emit</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.rcptt.ecl.operations.Emit |
| * @generated |
| */ |
| public Adapter createEmitAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class ' {@link org.eclipse.rcptt.ecl.operations.RepeatWith <em>Repeat With</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.rcptt.ecl.operations.RepeatWith |
| * @generated |
| */ |
| public Adapter createRepeatWithAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class ' {@link org.eclipse.rcptt.ecl.operations.Repeat <em>Repeat</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.rcptt.ecl.operations.Repeat |
| * @generated |
| */ |
| public Adapter createRepeatAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.rcptt.ecl.operations.AssertEmpty <em>Assert Empty</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.rcptt.ecl.operations.AssertEmpty |
| * @generated |
| */ |
| public Adapter createAssertEmptyAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.rcptt.ecl.operations.AssertNonEmpty <em>Assert Non Empty</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.rcptt.ecl.operations.AssertNonEmpty |
| * @generated |
| */ |
| public Adapter createAssertNonEmptyAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class ' {@link org.eclipse.rcptt.ecl.operations.Concat <em>Concat</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.rcptt.ecl.operations.Concat |
| * @generated |
| */ |
| public Adapter createConcatAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.rcptt.ecl.operations.Or <em>Or</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.rcptt.ecl.operations.Or |
| * @generated |
| */ |
| public Adapter createOrAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.rcptt.ecl.operations.And <em>And</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.rcptt.ecl.operations.And |
| * @generated |
| */ |
| public Adapter createAndAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class ' {@link org.eclipse.rcptt.ecl.operations.GetTime <em>Get Time</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.rcptt.ecl.operations.GetTime |
| * @generated |
| */ |
| public Adapter createGetTimeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class ' {@link org.eclipse.rcptt.ecl.operations.FormatTime <em>Format Time</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.rcptt.ecl.operations.FormatTime |
| * @generated |
| */ |
| public Adapter createFormatTimeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class ' {@link org.eclipse.rcptt.ecl.operations.Plus <em>Plus</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.rcptt.ecl.operations.Plus |
| * @generated |
| */ |
| public Adapter createPlusAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class ' {@link org.eclipse.rcptt.ecl.operations.Minus <em>Minus</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.rcptt.ecl.operations.Minus |
| * @generated |
| */ |
| public Adapter createMinusAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.rcptt.ecl.operations.Div <em>Div</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.rcptt.ecl.operations.Div |
| * @generated |
| */ |
| public Adapter createDivAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class ' {@link org.eclipse.rcptt.ecl.operations.Mult <em>Mult</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.rcptt.ecl.operations.Mult |
| * @generated |
| */ |
| public Adapter createMultAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.rcptt.ecl.operations.Abs <em>Abs</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.rcptt.ecl.operations.Abs |
| * @generated |
| */ |
| public Adapter createAbsAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.rcptt.ecl.operations.Mod <em>Mod</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.rcptt.ecl.operations.Mod |
| * @generated |
| */ |
| public Adapter createModAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class ' {@link org.eclipse.rcptt.ecl.operations.Between <em>Between</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.rcptt.ecl.operations.Between |
| * @generated |
| */ |
| public Adapter createBetweenAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.rcptt.ecl.operations.Entry <em>Entry</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.rcptt.ecl.operations.Entry |
| * @generated |
| */ |
| public Adapter createEntryAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.rcptt.ecl.operations.Map <em>Map</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.rcptt.ecl.operations.Map |
| * @generated |
| */ |
| public Adapter createMapAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.rcptt.ecl.operations.List <em>List</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.rcptt.ecl.operations.List |
| * @generated |
| */ |
| public Adapter createListAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.rcptt.ecl.operations.Loop <em>Loop</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.rcptt.ecl.operations.Loop |
| * @generated |
| */ |
| public Adapter createLoopAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.rcptt.ecl.operations.Recur <em>Recur</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.rcptt.ecl.operations.Recur |
| * @generated |
| */ |
| public Adapter createRecurAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.rcptt.ecl.operations.ToList <em>To List</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.rcptt.ecl.operations.ToList |
| * @generated |
| */ |
| public Adapter createToListAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.rcptt.ecl.operations.Each <em>Each</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.rcptt.ecl.operations.Each |
| * @generated |
| */ |
| public Adapter createEachAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.rcptt.ecl.operations.Split <em>Split</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.rcptt.ecl.operations.Split |
| * @generated |
| */ |
| public Adapter createSplitAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.rcptt.ecl.operations.ParseTime <em>Parse Time</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.rcptt.ecl.operations.ParseTime |
| * @generated |
| */ |
| public Adapter createParseTimeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.rcptt.ecl.operations.ThrowError <em>Throw Error</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.rcptt.ecl.operations.ThrowError |
| * @generated |
| */ |
| public Adapter createThrowErrorAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.rcptt.ecl.operations.FindAll <em>Find All</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.rcptt.ecl.operations.FindAll |
| * @generated |
| */ |
| public Adapter createFindAllAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class ' {@link org.eclipse.rcptt.ecl.operations.BinaryOp <em>Binary Op</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.rcptt.ecl.operations.BinaryOp |
| * @generated |
| */ |
| public Adapter createBinaryOpAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class ' {@link org.eclipse.rcptt.ecl.core.Command <em>Command</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.rcptt.ecl.core.Command |
| * @generated |
| */ |
| public Adapter createCommandAdapter() { |
| 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; |
| } |
| |
| } // OperationsAdapterFactory |
