001: /**
002: * <copyright>
003: * </copyright>
004: *
005: * $Id$
006: */package newprocess.util;
007:
008: import newprocess.Actor;
009: import newprocess.AndOperator;
010: import newprocess.AsyncActivity;
011: import newprocess.Conclusion;
012: import newprocess.Condition;
013: import newprocess.ConditionProxy;
014: import newprocess.ConditionTerm;
015: import newprocess.Element;
016: import newprocess.EnvEntry;
017: import newprocess.Event;
018: import newprocess.Expansion;
019: import newprocess.Expression;
020: import newprocess.Globals;
021: import newprocess.Listener;
022: import newprocess.Loader;
023: import newprocess.Message;
024: import newprocess.NewprocessPackage;
025: import newprocess.OperatorTerm;
026: import newprocess.OrOperator;
027: import newprocess.Root;
028: import newprocess.SyncActivity;
029: import newprocess.Term;
030:
031: import org.eclipse.emf.common.notify.Adapter;
032: import org.eclipse.emf.common.notify.Notifier;
033:
034: import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
035:
036: import org.eclipse.emf.ecore.EObject;
037:
038: /**
039: * <!-- begin-user-doc -->
040: * The <b>Adapter Factory</b> for the model.
041: * It provides an adapter <code>createXXX</code> method for each class of the model.
042: * <!-- end-user-doc -->
043: * @see newprocess.NewprocessPackage
044: * @generated
045: */
046: public class NewprocessAdapterFactory extends AdapterFactoryImpl {
047: /**
048: * The cached model package.
049: * <!-- begin-user-doc -->
050: * <!-- end-user-doc -->
051: * @generated
052: */
053: protected static NewprocessPackage modelPackage;
054:
055: /**
056: * Creates an instance of the adapter factory.
057: * <!-- begin-user-doc -->
058: * <!-- end-user-doc -->
059: * @generated
060: */
061: public NewprocessAdapterFactory() {
062: if (modelPackage == null) {
063: modelPackage = NewprocessPackage.eINSTANCE;
064: }
065: }
066:
067: /**
068: * Returns whether this factory is applicable for the type of the object.
069: * <!-- begin-user-doc -->
070: * This implementation returns <code>true</code> if the object is either the model's package or is an instance object of the model.
071: * <!-- end-user-doc -->
072: * @return whether this factory is applicable for the type of the object.
073: * @generated
074: */
075: @Override
076: public boolean isFactoryForType(Object object) {
077: if (object == modelPackage) {
078: return true;
079: }
080: if (object instanceof EObject) {
081: return ((EObject) object).eClass().getEPackage() == modelPackage;
082: }
083: return false;
084: }
085:
086: /**
087: * The switch the delegates to the <code>createXXX</code> methods.
088: * <!-- begin-user-doc -->
089: * <!-- end-user-doc -->
090: * @generated
091: */
092: protected NewprocessSwitch<Adapter> modelSwitch = new NewprocessSwitch<Adapter>() {
093: @Override
094: public Adapter caseProcess(newprocess.Process object) {
095: return createProcessAdapter();
096: }
097:
098: @Override
099: public Adapter caseCondition(Condition object) {
100: return createConditionAdapter();
101: }
102:
103: @Override
104: public Adapter caseElement(Element object) {
105: return createElementAdapter();
106: }
107:
108: @Override
109: public Adapter caseSyncActivity(SyncActivity object) {
110: return createSyncActivityAdapter();
111: }
112:
113: @Override
114: public Adapter caseLoader(Loader object) {
115: return createLoaderAdapter();
116: }
117:
118: @Override
119: public Adapter caseAsyncActivity(AsyncActivity object) {
120: return createAsyncActivityAdapter();
121: }
122:
123: @Override
124: public Adapter caseEvent(Event object) {
125: return createEventAdapter();
126: }
127:
128: @Override
129: public Adapter caseActor(Actor object) {
130: return createActorAdapter();
131: }
132:
133: @Override
134: public Adapter caseListener(Listener object) {
135: return createListenerAdapter();
136: }
137:
138: @Override
139: public Adapter caseEnvEntry(EnvEntry object) {
140: return createEnvEntryAdapter();
141: }
142:
143: @Override
144: public Adapter caseMessage(Message object) {
145: return createMessageAdapter();
146: }
147:
148: @Override
149: public Adapter caseConditionProxy(ConditionProxy object) {
150: return createConditionProxyAdapter();
151: }
152:
153: @Override
154: public Adapter caseConclusion(Conclusion object) {
155: return createConclusionAdapter();
156: }
157:
158: @Override
159: public Adapter caseExpansion(Expansion object) {
160: return createExpansionAdapter();
161: }
162:
163: @Override
164: public Adapter caseExpression(Expression object) {
165: return createExpressionAdapter();
166: }
167:
168: @Override
169: public Adapter caseTerm(Term object) {
170: return createTermAdapter();
171: }
172:
173: @Override
174: public Adapter caseConditionTerm(ConditionTerm object) {
175: return createConditionTermAdapter();
176: }
177:
178: @Override
179: public Adapter caseOperatorTerm(OperatorTerm object) {
180: return createOperatorTermAdapter();
181: }
182:
183: @Override
184: public Adapter caseOrOperator(OrOperator object) {
185: return createOrOperatorAdapter();
186: }
187:
188: @Override
189: public Adapter caseAndOperator(AndOperator object) {
190: return createAndOperatorAdapter();
191: }
192:
193: @Override
194: public Adapter caseRoot(Root object) {
195: return createRootAdapter();
196: }
197:
198: @Override
199: public Adapter caseGlobals(Globals object) {
200: return createGlobalsAdapter();
201: }
202:
203: @Override
204: public Adapter defaultCase(EObject object) {
205: return createEObjectAdapter();
206: }
207: };
208:
209: /**
210: * Creates an adapter for the <code>target</code>.
211: * <!-- begin-user-doc -->
212: * <!-- end-user-doc -->
213: * @param target the object to adapt.
214: * @return the adapter for the <code>target</code>.
215: * @generated
216: */
217: @Override
218: public Adapter createAdapter(Notifier target) {
219: return modelSwitch.doSwitch((EObject) target);
220: }
221:
222: /**
223: * Creates a new adapter for an object of class '{@link newprocess.Process <em>Process</em>}'.
224: * <!-- begin-user-doc -->
225: * This default implementation returns null so that we can easily ignore cases;
226: * it's useful to ignore a case when inheritance will catch all the cases anyway.
227: * <!-- end-user-doc -->
228: * @return the new adapter.
229: * @see newprocess.Process
230: * @generated
231: */
232: public Adapter createProcessAdapter() {
233: return null;
234: }
235:
236: /**
237: * Creates a new adapter for an object of class '{@link newprocess.Condition <em>Condition</em>}'.
238: * <!-- begin-user-doc -->
239: * This default implementation returns null so that we can easily ignore cases;
240: * it's useful to ignore a case when inheritance will catch all the cases anyway.
241: * <!-- end-user-doc -->
242: * @return the new adapter.
243: * @see newprocess.Condition
244: * @generated
245: */
246: public Adapter createConditionAdapter() {
247: return null;
248: }
249:
250: /**
251: * Creates a new adapter for an object of class '{@link newprocess.Element <em>Element</em>}'.
252: * <!-- begin-user-doc -->
253: * This default implementation returns null so that we can easily ignore cases;
254: * it's useful to ignore a case when inheritance will catch all the cases anyway.
255: * <!-- end-user-doc -->
256: * @return the new adapter.
257: * @see newprocess.Element
258: * @generated
259: */
260: public Adapter createElementAdapter() {
261: return null;
262: }
263:
264: /**
265: * Creates a new adapter for an object of class '{@link newprocess.SyncActivity <em>Sync Activity</em>}'.
266: * <!-- begin-user-doc -->
267: * This default implementation returns null so that we can easily ignore cases;
268: * it's useful to ignore a case when inheritance will catch all the cases anyway.
269: * <!-- end-user-doc -->
270: * @return the new adapter.
271: * @see newprocess.SyncActivity
272: * @generated
273: */
274: public Adapter createSyncActivityAdapter() {
275: return null;
276: }
277:
278: /**
279: * Creates a new adapter for an object of class '{@link newprocess.Loader <em>Loader</em>}'.
280: * <!-- begin-user-doc -->
281: * This default implementation returns null so that we can easily ignore cases;
282: * it's useful to ignore a case when inheritance will catch all the cases anyway.
283: * <!-- end-user-doc -->
284: * @return the new adapter.
285: * @see newprocess.Loader
286: * @generated
287: */
288: public Adapter createLoaderAdapter() {
289: return null;
290: }
291:
292: /**
293: * Creates a new adapter for an object of class '{@link newprocess.AsyncActivity <em>Async Activity</em>}'.
294: * <!-- begin-user-doc -->
295: * This default implementation returns null so that we can easily ignore cases;
296: * it's useful to ignore a case when inheritance will catch all the cases anyway.
297: * <!-- end-user-doc -->
298: * @return the new adapter.
299: * @see newprocess.AsyncActivity
300: * @generated
301: */
302: public Adapter createAsyncActivityAdapter() {
303: return null;
304: }
305:
306: /**
307: * Creates a new adapter for an object of class '{@link newprocess.Event <em>Event</em>}'.
308: * <!-- begin-user-doc -->
309: * This default implementation returns null so that we can easily ignore cases;
310: * it's useful to ignore a case when inheritance will catch all the cases anyway.
311: * <!-- end-user-doc -->
312: * @return the new adapter.
313: * @see newprocess.Event
314: * @generated
315: */
316: public Adapter createEventAdapter() {
317: return null;
318: }
319:
320: /**
321: * Creates a new adapter for an object of class '{@link newprocess.Actor <em>Actor</em>}'.
322: * <!-- begin-user-doc -->
323: * This default implementation returns null so that we can easily ignore cases;
324: * it's useful to ignore a case when inheritance will catch all the cases anyway.
325: * <!-- end-user-doc -->
326: * @return the new adapter.
327: * @see newprocess.Actor
328: * @generated
329: */
330: public Adapter createActorAdapter() {
331: return null;
332: }
333:
334: /**
335: * Creates a new adapter for an object of class '{@link newprocess.Listener <em>Listener</em>}'.
336: * <!-- begin-user-doc -->
337: * This default implementation returns null so that we can easily ignore cases;
338: * it's useful to ignore a case when inheritance will catch all the cases anyway.
339: * <!-- end-user-doc -->
340: * @return the new adapter.
341: * @see newprocess.Listener
342: * @generated
343: */
344: public Adapter createListenerAdapter() {
345: return null;
346: }
347:
348: /**
349: * Creates a new adapter for an object of class '{@link newprocess.EnvEntry <em>Env Entry</em>}'.
350: * <!-- begin-user-doc -->
351: * This default implementation returns null so that we can easily ignore cases;
352: * it's useful to ignore a case when inheritance will catch all the cases anyway.
353: * <!-- end-user-doc -->
354: * @return the new adapter.
355: * @see newprocess.EnvEntry
356: * @generated
357: */
358: public Adapter createEnvEntryAdapter() {
359: return null;
360: }
361:
362: /**
363: * Creates a new adapter for an object of class '{@link newprocess.Message <em>Message</em>}'.
364: * <!-- begin-user-doc -->
365: * This default implementation returns null so that we can easily ignore cases;
366: * it's useful to ignore a case when inheritance will catch all the cases anyway.
367: * <!-- end-user-doc -->
368: * @return the new adapter.
369: * @see newprocess.Message
370: * @generated
371: */
372: public Adapter createMessageAdapter() {
373: return null;
374: }
375:
376: /**
377: * Creates a new adapter for an object of class '{@link newprocess.ConditionProxy <em>Condition Proxy</em>}'.
378: * <!-- begin-user-doc -->
379: * This default implementation returns null so that we can easily ignore cases;
380: * it's useful to ignore a case when inheritance will catch all the cases anyway.
381: * <!-- end-user-doc -->
382: * @return the new adapter.
383: * @see newprocess.ConditionProxy
384: * @generated
385: */
386: public Adapter createConditionProxyAdapter() {
387: return null;
388: }
389:
390: /**
391: * Creates a new adapter for an object of class '{@link newprocess.Conclusion <em>Conclusion</em>}'.
392: * <!-- begin-user-doc -->
393: * This default implementation returns null so that we can easily ignore cases;
394: * it's useful to ignore a case when inheritance will catch all the cases anyway.
395: * <!-- end-user-doc -->
396: * @return the new adapter.
397: * @see newprocess.Conclusion
398: * @generated
399: */
400: public Adapter createConclusionAdapter() {
401: return null;
402: }
403:
404: /**
405: * Creates a new adapter for an object of class '{@link newprocess.Expansion <em>Expansion</em>}'.
406: * <!-- begin-user-doc -->
407: * This default implementation returns null so that we can easily ignore cases;
408: * it's useful to ignore a case when inheritance will catch all the cases anyway.
409: * <!-- end-user-doc -->
410: * @return the new adapter.
411: * @see newprocess.Expansion
412: * @generated
413: */
414: public Adapter createExpansionAdapter() {
415: return null;
416: }
417:
418: /**
419: * Creates a new adapter for an object of class '{@link newprocess.Expression <em>Expression</em>}'.
420: * <!-- begin-user-doc -->
421: * This default implementation returns null so that we can easily ignore cases;
422: * it's useful to ignore a case when inheritance will catch all the cases anyway.
423: * <!-- end-user-doc -->
424: * @return the new adapter.
425: * @see newprocess.Expression
426: * @generated
427: */
428: public Adapter createExpressionAdapter() {
429: return null;
430: }
431:
432: /**
433: * Creates a new adapter for an object of class '{@link newprocess.Term <em>Term</em>}'.
434: * <!-- begin-user-doc -->
435: * This default implementation returns null so that we can easily ignore cases;
436: * it's useful to ignore a case when inheritance will catch all the cases anyway.
437: * <!-- end-user-doc -->
438: * @return the new adapter.
439: * @see newprocess.Term
440: * @generated
441: */
442: public Adapter createTermAdapter() {
443: return null;
444: }
445:
446: /**
447: * Creates a new adapter for an object of class '{@link newprocess.ConditionTerm <em>Condition Term</em>}'.
448: * <!-- begin-user-doc -->
449: * This default implementation returns null so that we can easily ignore cases;
450: * it's useful to ignore a case when inheritance will catch all the cases anyway.
451: * <!-- end-user-doc -->
452: * @return the new adapter.
453: * @see newprocess.ConditionTerm
454: * @generated
455: */
456: public Adapter createConditionTermAdapter() {
457: return null;
458: }
459:
460: /**
461: * Creates a new adapter for an object of class '{@link newprocess.OperatorTerm <em>Operator Term</em>}'.
462: * <!-- begin-user-doc -->
463: * This default implementation returns null so that we can easily ignore cases;
464: * it's useful to ignore a case when inheritance will catch all the cases anyway.
465: * <!-- end-user-doc -->
466: * @return the new adapter.
467: * @see newprocess.OperatorTerm
468: * @generated
469: */
470: public Adapter createOperatorTermAdapter() {
471: return null;
472: }
473:
474: /**
475: * Creates a new adapter for an object of class '{@link newprocess.OrOperator <em>Or Operator</em>}'.
476: * <!-- begin-user-doc -->
477: * This default implementation returns null so that we can easily ignore cases;
478: * it's useful to ignore a case when inheritance will catch all the cases anyway.
479: * <!-- end-user-doc -->
480: * @return the new adapter.
481: * @see newprocess.OrOperator
482: * @generated
483: */
484: public Adapter createOrOperatorAdapter() {
485: return null;
486: }
487:
488: /**
489: * Creates a new adapter for an object of class '{@link newprocess.AndOperator <em>And Operator</em>}'.
490: * <!-- begin-user-doc -->
491: * This default implementation returns null so that we can easily ignore cases;
492: * it's useful to ignore a case when inheritance will catch all the cases anyway.
493: * <!-- end-user-doc -->
494: * @return the new adapter.
495: * @see newprocess.AndOperator
496: * @generated
497: */
498: public Adapter createAndOperatorAdapter() {
499: return null;
500: }
501:
502: /**
503: * Creates a new adapter for an object of class '{@link newprocess.Root <em>Root</em>}'.
504: * <!-- begin-user-doc -->
505: * This default implementation returns null so that we can easily ignore cases;
506: * it's useful to ignore a case when inheritance will catch all the cases anyway.
507: * <!-- end-user-doc -->
508: * @return the new adapter.
509: * @see newprocess.Root
510: * @generated
511: */
512: public Adapter createRootAdapter() {
513: return null;
514: }
515:
516: /**
517: * Creates a new adapter for an object of class '{@link newprocess.Globals <em>Globals</em>}'.
518: * <!-- begin-user-doc -->
519: * This default implementation returns null so that we can easily ignore cases;
520: * it's useful to ignore a case when inheritance will catch all the cases anyway.
521: * <!-- end-user-doc -->
522: * @return the new adapter.
523: * @see newprocess.Globals
524: * @generated
525: */
526: public Adapter createGlobalsAdapter() {
527: return null;
528: }
529:
530: /**
531: * Creates a new adapter for the default case.
532: * <!-- begin-user-doc -->
533: * This default implementation returns null.
534: * <!-- end-user-doc -->
535: * @return the new adapter.
536: * @generated
537: */
538: public Adapter createEObjectAdapter() {
539: return null;
540: }
541:
542: } //NewprocessAdapterFactory
|