Coverage Report

 // $Id: UseCasesHelperEUMLImpl.java 18220 2010-04-08 20:37:15Z tfmorris $
 /*******************************************************************************
  * Copyright (c) 2007,2010 Tom Morris and other contributors
  * 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:
  *    Tom Morris - initial framework
  *    Bogdan Pistol - initial implementation 
  *******************************************************************************/
 package org.argouml.model.euml;
 
 import java.util.Collection;
 import java.util.HashSet;
 
 import org.argouml.model.UseCasesHelper;
 import org.eclipse.emf.edit.command.CommandParameter;
 import org.eclipse.uml2.uml.Actor;
 import org.eclipse.uml2.uml.Extend;
 import org.eclipse.uml2.uml.ExtensionPoint;
 import org.eclipse.uml2.uml.Include;
 import org.eclipse.uml2.uml.UseCase;
 
 /**
  * The implementation of the UseCasesHelper for EUML2.
  */
 class UseCasesHelperEUMLImpl implements UseCasesHelper {
 
     /**
      * The model implementation.
      */
     private EUMLModelImplementation modelImpl;
 
     /**
      * Constructor.
      * 
      * @param implementation
      *            The ModelImplementation.
      */
     public UseCasesHelperEUMLImpl(EUMLModelImplementation implementation) {
         modelImpl = implementation;
     }
 
     public void addExtend(final Object handle, final Object extend) {
         if (!(handle instanceof UseCase) && !(handle instanceof ExtensionPoint)) {
             throw new IllegalArgumentException();
         }
         if (!(extend instanceof Extend)) {
             throw new IllegalArgumentException();
         }
         RunnableClass run = new RunnableClass() {
             public void run() {
                 if (handle instanceof UseCase) {
                     ((UseCase) handle).getExtends().add((Extend) extend);
                 } else if (handle instanceof ExtensionPoint) {
                     ((Extend) extend).getExtensionLocations().add(
                             (ExtensionPoint) handle);
                 }
             }
         };
         modelImpl.getEditingDomain().getCommandStack().execute(
                 new ChangeCommand(
                         modelImpl, run, "Add the extend # to the #", extend,
                         handle));
     }
     
     public void addExtensionPoint(final Object handle,
             final Object extensionPoint) {
         addExtensionPoint(handle, CommandParameter.NO_INDEX, extensionPoint);
     }
 
     public void addExtensionPoint(final Object handle, final int position,
             final Object extensionPoint) {
         if (!(handle instanceof UseCase) && !(handle instanceof Extend)) {
             throw new IllegalArgumentException();
         }
         if (!(extensionPoint instanceof ExtensionPoint)) {
             throw new IllegalArgumentException();
         }
         RunnableClass run = new RunnableClass() {
             public void run() {
                 if (handle instanceof UseCase) {
                     ((UseCase) handle).getExtensionPoints().add(
                             position, (ExtensionPoint) extensionPoint);
                 } else if (handle instanceof Extend) {
                     ((Extend) handle).getExtensionLocations().add(
                             position, (ExtensionPoint) extensionPoint);
                 }
             }
         };
         modelImpl.getEditingDomain().getCommandStack().execute(
                 new ChangeCommand(
                         modelImpl, run, "Add the extension point # to the #",
                         extensionPoint, handle));
     }
 
     public void addInclude(final Object usecase, final Object include) {
         if (!(usecase instanceof UseCase)) {
             throw new IllegalArgumentException();
         }
         if (!(include instanceof Include)) {
             throw new IllegalArgumentException();
         }
         RunnableClass run = new RunnableClass() {
             public void run() {
                 ((UseCase) usecase).getIncludes().add((Include) include);
             }
         };
         modelImpl.getEditingDomain().getCommandStack().execute(
                 new ChangeCommand(
                         modelImpl, run, "Add the include # to the case #",
                         include, usecase));
     }
 
     public Collection getAllActors(Object ns) {
         return modelImpl.getModelManagementHelper().getAllModelElementsOfKind(
                 ns, Actor.class);
     }
 
     public Collection getAllUseCases(Object ns) {
         return modelImpl.getModelManagementHelper().getAllModelElementsOfKind(
                 ns, UseCase.class);
     }
 
     public Collection getExtendedUseCases(Object ausecase) {
         if (!(ausecase instanceof UseCase)) {
             throw new IllegalArgumentException();
         }
         Collection<UseCase> result = new HashSet<UseCase>();
         for (Extend extend : ((UseCase) ausecase).getExtends()) {
             result.add(extend.getExtension());
         }
         return result;
     }
 
     public Extend getExtends(Object abase, Object anextension) {
         if (!(abase instanceof UseCase) || !(anextension instanceof UseCase)) {
             throw new IllegalArgumentException();
         }
         return ((UseCase) anextension).getExtend(null, (UseCase) abase);
     }
 
     public Collection<UseCase> getIncludedUseCases(Object ausecase) {
         if (!(ausecase instanceof UseCase)) {
             throw new IllegalArgumentException();
         }
         Collection<UseCase> result = new HashSet<UseCase>();
         for (Include include : ((UseCase) ausecase).getIncludes() ) {
             result.add(include.getAddition());
         }
         return result;
     }
 
     public Include getIncludes(Object abase, Object aninclusion) {
         if (!(abase instanceof UseCase) || !(aninclusion instanceof UseCase)) {
             throw new IllegalArgumentException();
         }
         return ((UseCase) abase).getInclude(null, (UseCase) aninclusion);
     }
 
     public Collection getSpecificationPath(Object ausecase) {
         // TODO: Auto-generated method stub
         return null;
     }
 
     public void removeExtend(Object elem, Object extend) {
         // TODO: Auto-generated method stub
     }
 
     public void removeExtensionPoint(Object elem, Object ep) {
         // TODO: Auto-generated method stub
     }
 
     public void removeInclude(final Object usecase, final Object include) {
         if (!(usecase instanceof UseCase)) {
             throw new IllegalArgumentException();
         }
         if (!(include instanceof Include)) {
             throw new IllegalArgumentException();
         }
         RunnableClass run = new RunnableClass() {
             public void run() {
                 ((UseCase) usecase).getIncludes().remove((Include) include);
             }
         };
         modelImpl.getEditingDomain().getCommandStack().execute(
                 new ChangeCommand(
                         modelImpl, run, "Remove the include # from the case #",
                         include, usecase));
     }
 
     public void setAddition(final Object handle, final Object useCase) {
         if (!(handle instanceof Include)) {
             throw new IllegalArgumentException();
         }
         if (!(useCase instanceof UseCase)) {
             throw new IllegalArgumentException();
         }
         RunnableClass run = new RunnableClass() {
             public void run() {
                 ((Include) handle).setAddition((UseCase) useCase);
             }
         };
         modelImpl.getEditingDomain().getCommandStack().execute(
                 new ChangeCommand(
                         modelImpl, run, "Set the addition # to the include #",
                         useCase, handle));
     }
 
     public void setBase(Object extend, Object base) {
         // TODO: Auto-generated method stub
     }
 
     public void setCondition(Object handle, Object booleanExpression) {
         // TODO: Auto-generated method stub
     }
 
     public void setExtension(Object handle, Object ext) {
     }
 
     public void setExtensionPoints(final Object handle,
             final Collection extensionPoints) {
         if (!(handle instanceof UseCase) && !(handle instanceof Extend)) {
             throw new IllegalArgumentException();
         }
         if (extensionPoints == null) {
             throw new IllegalArgumentException();
         }
         for (Object o : extensionPoints) {
             if (!(o instanceof ExtensionPoint)) {
                 throw new IllegalArgumentException(o.toString());
             }
         }
         RunnableClass run = new RunnableClass() {
             public void run() {
                 if (handle instanceof Extend) {
                     ((Extend) handle).getExtensionLocations().clear();
                     for (Object o : extensionPoints) {
                         ((Extend) handle).getExtensionLocations().add(
                                 (ExtensionPoint) o);
                     }
                 } else if (handle instanceof UseCase) {
                     ((UseCase) handle).getExtensionPoints().clear();
                     for (Object o : extensionPoints) {
                         ((UseCase) handle).getExtensionPoints().add(
                                 (ExtensionPoint) o);
                     }
                 }
 
             }
         };
         modelImpl.getEditingDomain().getCommandStack().execute(
                 new ChangeCommand(
                         modelImpl, run,
                         "Set # extension points for the case #",
                         extensionPoints.size(), handle));
     }
 
     public void setIncludes(Object handle, Collection includes) {
         // TODO: Auto-generated method stub
     }
 
     public void setLocation(Object handle, String loc) {
         // TODO: Auto-generated method stub
     }
 
     public void setUseCase(Object elem, Object usecase) {
         // TODO: Auto-generated method stub
     }
 
 }

1		// $Id: UseCasesHelperEUMLImpl.java 18220 2010-04-08 20:37:15Z tfmorris $
2		/*******************************************************************************
3		* Copyright (c) 2007,2010 Tom Morris and other contributors
4		* All rights reserved. This program and the accompanying materials
5		* are made available under the terms of the Eclipse Public License v1.0
6		* which accompanies this distribution, and is available at
7		* http://www.eclipse.org/legal/epl-v10.html
8		*
9		* Contributors:
10		* Tom Morris - initial framework
11		* Bogdan Pistol - initial implementation
12		*******************************************************************************/
13		package org.argouml.model.euml;
14
15		import java.util.Collection;
16		import java.util.HashSet;
17
18		import org.argouml.model.UseCasesHelper;
19		import org.eclipse.emf.edit.command.CommandParameter;
20		import org.eclipse.uml2.uml.Actor;
21		import org.eclipse.uml2.uml.Extend;
22		import org.eclipse.uml2.uml.ExtensionPoint;
23		import org.eclipse.uml2.uml.Include;
24		import org.eclipse.uml2.uml.UseCase;
25
26		/**
27		* The implementation of the UseCasesHelper for EUML2.
28		*/
29	0	class UseCasesHelperEUMLImpl implements UseCasesHelper {
30
31		/**
32		* The model implementation.
33		*/
34		private EUMLModelImplementation modelImpl;
35
36		/**
37		* Constructor.
38		*
39		* @param implementation
40		* The ModelImplementation.
41		*/
42	0	public UseCasesHelperEUMLImpl(EUMLModelImplementation implementation) {
43	0	modelImpl = implementation;
44	0	}
45
46		public void addExtend(final Object handle, final Object extend) {
47	0	if (!(handle instanceof UseCase) && !(handle instanceof ExtensionPoint)) {
48	0	throw new IllegalArgumentException();
49		}
50	0	if (!(extend instanceof Extend)) {
51	0	throw new IllegalArgumentException();
52		}
53	0	RunnableClass run = new RunnableClass() {
54		public void run() {
55	0	if (handle instanceof UseCase) {
56	0	((UseCase) handle).getExtends().add((Extend) extend);
57	0	} else if (handle instanceof ExtensionPoint) {
58	0	((Extend) extend).getExtensionLocations().add(
59		(ExtensionPoint) handle);
60		}
61	0	}
62		};
63	0	modelImpl.getEditingDomain().getCommandStack().execute(
64		new ChangeCommand(
65		modelImpl, run, "Add the extend # to the #", extend,
66		handle));
67	0	}
68
69		public void addExtensionPoint(final Object handle,
70		final Object extensionPoint) {
71	0	addExtensionPoint(handle, CommandParameter.NO_INDEX, extensionPoint);
72	0	}
73
74		public void addExtensionPoint(final Object handle, final int position,
75		final Object extensionPoint) {
76	0	if (!(handle instanceof UseCase) && !(handle instanceof Extend)) {
77	0	throw new IllegalArgumentException();
78		}
79	0	if (!(extensionPoint instanceof ExtensionPoint)) {
80	0	throw new IllegalArgumentException();
81		}
82	0	RunnableClass run = new RunnableClass() {
83		public void run() {
84	0	if (handle instanceof UseCase) {
85	0	((UseCase) handle).getExtensionPoints().add(
86		position, (ExtensionPoint) extensionPoint);
87	0	} else if (handle instanceof Extend) {
88	0	((Extend) handle).getExtensionLocations().add(
89		position, (ExtensionPoint) extensionPoint);
90		}
91	0	}
92		};
93	0	modelImpl.getEditingDomain().getCommandStack().execute(
94		new ChangeCommand(
95		modelImpl, run, "Add the extension point # to the #",
96		extensionPoint, handle));
97	0	}
98
99		public void addInclude(final Object usecase, final Object include) {
100	0	if (!(usecase instanceof UseCase)) {
101	0	throw new IllegalArgumentException();
102		}
103	0	if (!(include instanceof Include)) {
104	0	throw new IllegalArgumentException();
105		}
106	0	RunnableClass run = new RunnableClass() {
107		public void run() {
108	0	((UseCase) usecase).getIncludes().add((Include) include);
109	0	}
110		};
111	0	modelImpl.getEditingDomain().getCommandStack().execute(
112		new ChangeCommand(
113		modelImpl, run, "Add the include # to the case #",
114		include, usecase));
115	0	}
116
117		public Collection getAllActors(Object ns) {
118	0	return modelImpl.getModelManagementHelper().getAllModelElementsOfKind(
119		ns, Actor.class);
120		}
121
122		public Collection getAllUseCases(Object ns) {
123	0	return modelImpl.getModelManagementHelper().getAllModelElementsOfKind(
124		ns, UseCase.class);
125		}
126
127		public Collection getExtendedUseCases(Object ausecase) {
128	0	if (!(ausecase instanceof UseCase)) {
129	0	throw new IllegalArgumentException();
130		}
131	0	Collection<UseCase> result = new HashSet<UseCase>();
132	0	for (Extend extend : ((UseCase) ausecase).getExtends()) {
133	0	result.add(extend.getExtension());
134		}
135	0	return result;
136		}
137
138		public Extend getExtends(Object abase, Object anextension) {
139	0	if (!(abase instanceof UseCase) \|\| !(anextension instanceof UseCase)) {
140	0	throw new IllegalArgumentException();
141		}
142	0	return ((UseCase) anextension).getExtend(null, (UseCase) abase);
143		}
144
145		public Collection<UseCase> getIncludedUseCases(Object ausecase) {
146	0	if (!(ausecase instanceof UseCase)) {
147	0	throw new IllegalArgumentException();
148		}
149	0	Collection<UseCase> result = new HashSet<UseCase>();
150	0	for (Include include : ((UseCase) ausecase).getIncludes() ) {
151	0	result.add(include.getAddition());
152		}
153	0	return result;
154		}
155
156		public Include getIncludes(Object abase, Object aninclusion) {
157	0	if (!(abase instanceof UseCase) \|\| !(aninclusion instanceof UseCase)) {
158	0	throw new IllegalArgumentException();
159		}
160	0	return ((UseCase) abase).getInclude(null, (UseCase) aninclusion);
161		}
162
163		public Collection getSpecificationPath(Object ausecase) {
164		// TODO: Auto-generated method stub
165	0	return null;
166		}
167
168		public void removeExtend(Object elem, Object extend) {
169		// TODO: Auto-generated method stub
170	0	}
171
172		public void removeExtensionPoint(Object elem, Object ep) {
173		// TODO: Auto-generated method stub
174	0	}
175
176		public void removeInclude(final Object usecase, final Object include) {
177	0	if (!(usecase instanceof UseCase)) {
178	0	throw new IllegalArgumentException();
179		}
180	0	if (!(include instanceof Include)) {
181	0	throw new IllegalArgumentException();
182		}
183	0	RunnableClass run = new RunnableClass() {
184		public void run() {
185	0	((UseCase) usecase).getIncludes().remove((Include) include);
186	0	}
187		};
188	0	modelImpl.getEditingDomain().getCommandStack().execute(
189		new ChangeCommand(
190		modelImpl, run, "Remove the include # from the case #",
191		include, usecase));
192	0	}
193
194		public void setAddition(final Object handle, final Object useCase) {
195	0	if (!(handle instanceof Include)) {
196	0	throw new IllegalArgumentException();
197		}
198	0	if (!(useCase instanceof UseCase)) {
199	0	throw new IllegalArgumentException();
200		}
201	0	RunnableClass run = new RunnableClass() {
202		public void run() {
203	0	((Include) handle).setAddition((UseCase) useCase);
204	0	}
205		};
206	0	modelImpl.getEditingDomain().getCommandStack().execute(
207		new ChangeCommand(
208		modelImpl, run, "Set the addition # to the include #",
209		useCase, handle));
210	0	}
211
212		public void setBase(Object extend, Object base) {
213		// TODO: Auto-generated method stub
214	0	}
215
216		public void setCondition(Object handle, Object booleanExpression) {
217		// TODO: Auto-generated method stub
218	0	}
219
220		public void setExtension(Object handle, Object ext) {
221	0	}
222
223		public void setExtensionPoints(final Object handle,
224		final Collection extensionPoints) {
225	0	if (!(handle instanceof UseCase) && !(handle instanceof Extend)) {
226	0	throw new IllegalArgumentException();
227		}
228	0	if (extensionPoints == null) {
229	0	throw new IllegalArgumentException();
230		}
231	0	for (Object o : extensionPoints) {
232	0	if (!(o instanceof ExtensionPoint)) {
233	0	throw new IllegalArgumentException(o.toString());
234		}
235		}
236	0	RunnableClass run = new RunnableClass() {
237		public void run() {
238	0	if (handle instanceof Extend) {
239	0	((Extend) handle).getExtensionLocations().clear();
240	0	for (Object o : extensionPoints) {
241	0	((Extend) handle).getExtensionLocations().add(
242		(ExtensionPoint) o);
243		}
244	0	} else if (handle instanceof UseCase) {
245	0	((UseCase) handle).getExtensionPoints().clear();
246	0	for (Object o : extensionPoints) {
247	0	((UseCase) handle).getExtensionPoints().add(
248		(ExtensionPoint) o);
249		}
250		}
251
252	0	}
253		};
254	0	modelImpl.getEditingDomain().getCommandStack().execute(
255		new ChangeCommand(
256		modelImpl, run,
257		"Set # extension points for the case #",
258		extensionPoints.size(), handle));
259	0	}
260
261		public void setIncludes(Object handle, Collection includes) {
262		// TODO: Auto-generated method stub
263	0	}
264
265		public void setLocation(Object handle, String loc) {
266		// TODO: Auto-generated method stub
267	0	}
268
269		public void setUseCase(Object elem, Object usecase) {
270		// TODO: Auto-generated method stub
271	0	}
272
273		}