Coverage Report

Coverage Report - org.argouml.model.euml.ModelManagementHelperEUMLImpl

Classes in this File

Line Coverage

Branch Coverage

Complexity

ModelManagementHelperEUMLImpl

0/85

0/48

2.636

 // $Id: ModelManagementHelperEUMLImpl.java 19103 2011-03-03 21:02:51Z thn $
 /*******************************************************************************
  * 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.ArrayList;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;
 
 import org.argouml.model.ModelManagementHelper;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.uml2.uml.Classifier;
 import org.eclipse.uml2.uml.Collaboration;
 import org.eclipse.uml2.uml.Element;
 import org.eclipse.uml2.uml.Model;
 import org.eclipse.uml2.uml.NamedElement;
 import org.eclipse.uml2.uml.Namespace;
 import org.eclipse.uml2.uml.PackageableElement;
 import org.eclipse.uml2.uml.VisibilityKind;
 
 /**
  * The implementation of the ModelManagementHelper for EUML2.
  */
 class ModelManagementHelperEUMLImpl implements ModelManagementHelper {
 
     /**
      * The model implementation.
      */
     private EUMLModelImplementation modelImpl;
 
     /**
      * Constructor.
      * 
      * @param implementation
      *                The ModelImplementation.
      */
     public ModelManagementHelperEUMLImpl(
             EUMLModelImplementation implementation) {
         modelImpl = implementation;
     }
 
     public Collection getAllBehavioralFeatures(Object ns) {
         return modelImpl.getCoreHelper().getAllBehavioralFeatures(ns);
     }
 
     @SuppressWarnings("unchecked")
     public Collection getAllContents(Object element) {
         if (!(element instanceof Element)) {
             throw new IllegalArgumentException(
                     "The argument must be instance of Element"); //$NON-NLS-1$
         }
         Collection result = new HashSet();
         if (element instanceof Collaboration) {
             // TODO: implement
         }
         if (element instanceof Classifier) {
             result.addAll(((Classifier) element).allFeatures());
         }
         if (element instanceof Namespace) {
             result.addAll(((Namespace) element).getMembers());
         }
         if (element instanceof org.eclipse.uml2.uml.Package) {
             result.addAll(((org.eclipse.uml2.uml.Package) element).getPackagedElements());
             org.eclipse.uml2.uml.Package p = ((org.eclipse.uml2.uml.Package) element).getNestingPackage();
             while (p != null) {
                 for (PackageableElement e : p.getPackagedElements()) {
                     if (e.getVisibility() == VisibilityKind.PUBLIC_LITERAL) {
                         result.add(e);
                     }
                 }
                 p = p.getNestingPackage();
             }
         }
         return result;
     }
 
     public Collection getAllImportedElements(Object pack) {
         // TODO: Auto-generated method stub
         return null;
     }
 
     public Collection getAllModelElementsOfKind(Object nsa, Object type) {
         if (!(nsa instanceof Element)) {
             return new ArrayList<Element>();
         }
         Class theType = null;
         if (type instanceof String) {
             try {
                 theType = Class.forName((String) type);
             } catch (ClassNotFoundException e) {
                 throw new IllegalArgumentException(e);
             }
         } else if (type instanceof Class) {
             theType = (Class) type;
         } else {
             throw new IllegalArgumentException(
                     "type must be instance of Class or String"); //$NON-NLS-1$
         }
         if (!Element.class.isAssignableFrom(theType)) {
             throw new IllegalArgumentException(
                     "type must represent an Element"); //$NON-NLS-1$
         }
 
         Collection<Element> result = new ArrayList<Element>();
 
         for (Element element : ((Namespace) nsa).allOwnedElements()) {
             if (theType.isAssignableFrom(element.getClass())) {
                 result.add(element);
             }
         }
         
         return result;
     }
 
     public Collection getAllModelElementsOfKind(Object nsa, String kind) {
         return getAllModelElementsOfKind(nsa, kind);
     }
 
     public Collection getAllModelElementsOfKindWithModel(Object model,
             Object type) {
         if (!(model instanceof Model)) {
             throw new IllegalArgumentException(
                     "model must be instance of Model"); //$NON-NLS-1$
         }
         if (!(type instanceof Class)) {
             throw new IllegalArgumentException(
                     "type must be instance of java.lang.Class"); //$NON-NLS-1$
         }
         Class kind = (Class) type;
         Collection ret = getAllModelElementsOfKind(model, kind);
         if (kind.isAssignableFrom(model.getClass())) {
             ret = new ArrayList(ret);
             if (!ret.contains(model)) {
                 ret.add(model);
             }
         }
         return ret;
     }
 
     public Collection getAllNamespaces(Object ns) {
         return getAllModelElementsOfKind(ns, Namespace.class);
     }
 
     public Collection getAllPossibleImports(Object pack) {
         // TODO: Auto-generated method stub
         return null;
     }
 
     public Collection getAllSubSystems(Object ns) {
         // TODO: Auto-generated method stub
         return null;
     }
 
     public Collection getAllSurroundingNamespaces(Object element) {
         if (!(element instanceof NamedElement)) {
             throw new IllegalArgumentException(
                     "element must be instance of NamedElement"); //$NON-NLS-1$
         }
         return ((NamedElement) element).allNamespaces();
     }
 
     @SuppressWarnings("unchecked")
     public Collection getContents(Object element) {
         if (!(element instanceof Element)) {
             throw new IllegalArgumentException(
                     "element must be instance of Element"); //$NON-NLS-1$
         }
         Collection result = new HashSet();
         if (element instanceof Namespace) {
             result.addAll(((Namespace) element).getOwnedMembers());
             result.addAll(((Namespace) element).getImportedMembers());
         }
         if (element instanceof org.eclipse.uml2.uml.Package) {
             result.addAll(((org.eclipse.uml2.uml.Package) element).getPackagedElements());
         }
         return result;
     }
 
 
     public Object getElement(List<String> path) {
         return getElement(path, null);
     }
 
     public Object getElement(List<String> path, Object theRootNamespace) {
         // TODO: Auto-generated method stub
         return null;
     }
 
     public List<String> getPathList(Object element) {
         // TODO: Needs completing - stub implementation only! - tfm
         List<String> path = new ArrayList<String>();
         path.add(modelImpl.getFacade().getName(element));
         return path;
     }
 
     public List<Object> getRootElements(Object model) {
         if (model instanceof EObject) {
             List<Object> contents = new ArrayList<Object>();
             contents.addAll(((EObject) model).eResource().getContents());
             if (!contents.contains(model)) {
                 contents.add(model);
             }
             return contents;
         }
         throw new IllegalArgumentException(
                 "model must be instance of EObject"); //$NON-NLS-1$
     }
 
     public boolean isCyclicOwnership(Object parent, Object child) {
         // TODO: Auto-generated method stub
         return false;
     }
 
     public void removeImportedElement(Object handle, Object me) {
         // TODO: Auto-generated method stub
     }
 
     public void setAlias(Object handle, String alias) {
         // TODO: Auto-generated method stub
     }
 
     public void setImportedElements(Object pack, Collection imports) {
         // TODO: Auto-generated method stub
     }
 
     public void setSpecification(Object handle, boolean isSpecification) {
         // TODO: Auto-generated method stub
     }
 
     public boolean isReadOnly(Object element) {
         // TODO: Auto-generated method stub
         return false;
     }
 
 }

1		// $Id: ModelManagementHelperEUMLImpl.java 19103 2011-03-03 21:02:51Z thn $
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.ArrayList;
16		import java.util.Collection;
17		import java.util.HashSet;
18		import java.util.List;
19
20		import org.argouml.model.ModelManagementHelper;
21		import org.eclipse.emf.ecore.EObject;
22		import org.eclipse.uml2.uml.Classifier;
23		import org.eclipse.uml2.uml.Collaboration;
24		import org.eclipse.uml2.uml.Element;
25		import org.eclipse.uml2.uml.Model;
26		import org.eclipse.uml2.uml.NamedElement;
27		import org.eclipse.uml2.uml.Namespace;
28		import org.eclipse.uml2.uml.PackageableElement;
29		import org.eclipse.uml2.uml.VisibilityKind;
30
31		/**
32		* The implementation of the ModelManagementHelper for EUML2.
33		*/
34		class ModelManagementHelperEUMLImpl implements ModelManagementHelper {
35
36		/**
37		* The model implementation.
38		*/
39		private EUMLModelImplementation modelImpl;
40
41		/**
42		* Constructor.
43		*
44		* @param implementation
45		* The ModelImplementation.
46		*/
47		public ModelManagementHelperEUMLImpl(
48	0	EUMLModelImplementation implementation) {
49	0	modelImpl = implementation;
50	0	}
51
52		public Collection getAllBehavioralFeatures(Object ns) {
53	0	return modelImpl.getCoreHelper().getAllBehavioralFeatures(ns);
54		}
55
56		@SuppressWarnings("unchecked")
57		public Collection getAllContents(Object element) {
58	0	if (!(element instanceof Element)) {
59	0	throw new IllegalArgumentException(
60		"The argument must be instance of Element"); //$NON-NLS-1$
61		}
62	0	Collection result = new HashSet();
63	0	if (element instanceof Collaboration) {
64		// TODO: implement
65		}
66	0	if (element instanceof Classifier) {
67	0	result.addAll(((Classifier) element).allFeatures());
68		}
69	0	if (element instanceof Namespace) {
70	0	result.addAll(((Namespace) element).getMembers());
71		}
72	0	if (element instanceof org.eclipse.uml2.uml.Package) {
73	0	result.addAll(((org.eclipse.uml2.uml.Package) element).getPackagedElements());
74	0	org.eclipse.uml2.uml.Package p = ((org.eclipse.uml2.uml.Package) element).getNestingPackage();
75	0	while (p != null) {
76	0	for (PackageableElement e : p.getPackagedElements()) {
77	0	if (e.getVisibility() == VisibilityKind.PUBLIC_LITERAL) {
78	0	result.add(e);
79		}
80		}
81	0	p = p.getNestingPackage();
82		}
83		}
84	0	return result;
85		}
86
87		public Collection getAllImportedElements(Object pack) {
88		// TODO: Auto-generated method stub
89	0	return null;
90		}
91
92		public Collection getAllModelElementsOfKind(Object nsa, Object type) {
93	0	if (!(nsa instanceof Element)) {
94	0	return new ArrayList<Element>();
95		}
96	0	Class theType = null;
97	0	if (type instanceof String) {
98		try {
99	0	theType = Class.forName((String) type);
100	0	} catch (ClassNotFoundException e) {
101	0	throw new IllegalArgumentException(e);
102	0	}
103	0	} else if (type instanceof Class) {
104	0	theType = (Class) type;
105		} else {
106	0	throw new IllegalArgumentException(
107		"type must be instance of Class or String"); //$NON-NLS-1$
108		}
109	0	if (!Element.class.isAssignableFrom(theType)) {
110	0	throw new IllegalArgumentException(
111		"type must represent an Element"); //$NON-NLS-1$
112		}
113
114	0	Collection<Element> result = new ArrayList<Element>();
115
116	0	for (Element element : ((Namespace) nsa).allOwnedElements()) {
117	0	if (theType.isAssignableFrom(element.getClass())) {
118	0	result.add(element);
119		}
120		}
121
122	0	return result;
123		}
124
125		public Collection getAllModelElementsOfKind(Object nsa, String kind) {
126	0	return getAllModelElementsOfKind(nsa, kind);
127		}
128
129		public Collection getAllModelElementsOfKindWithModel(Object model,
130		Object type) {
131	0	if (!(model instanceof Model)) {
132	0	throw new IllegalArgumentException(
133		"model must be instance of Model"); //$NON-NLS-1$
134		}
135	0	if (!(type instanceof Class)) {
136	0	throw new IllegalArgumentException(
137		"type must be instance of java.lang.Class"); //$NON-NLS-1$
138		}
139	0	Class kind = (Class) type;
140	0	Collection ret = getAllModelElementsOfKind(model, kind);
141	0	if (kind.isAssignableFrom(model.getClass())) {
142	0	ret = new ArrayList(ret);
143	0	if (!ret.contains(model)) {
144	0	ret.add(model);
145		}
146		}
147	0	return ret;
148		}
149
150		public Collection getAllNamespaces(Object ns) {
151	0	return getAllModelElementsOfKind(ns, Namespace.class);
152		}
153
154		public Collection getAllPossibleImports(Object pack) {
155		// TODO: Auto-generated method stub
156	0	return null;
157		}
158
159		public Collection getAllSubSystems(Object ns) {
160		// TODO: Auto-generated method stub
161	0	return null;
162		}
163
164		public Collection getAllSurroundingNamespaces(Object element) {
165	0	if (!(element instanceof NamedElement)) {
166	0	throw new IllegalArgumentException(
167		"element must be instance of NamedElement"); //$NON-NLS-1$
168		}
169	0	return ((NamedElement) element).allNamespaces();
170		}
171
172		@SuppressWarnings("unchecked")
173		public Collection getContents(Object element) {
174	0	if (!(element instanceof Element)) {
175	0	throw new IllegalArgumentException(
176		"element must be instance of Element"); //$NON-NLS-1$
177		}
178	0	Collection result = new HashSet();
179	0	if (element instanceof Namespace) {
180	0	result.addAll(((Namespace) element).getOwnedMembers());
181	0	result.addAll(((Namespace) element).getImportedMembers());
182		}
183	0	if (element instanceof org.eclipse.uml2.uml.Package) {
184	0	result.addAll(((org.eclipse.uml2.uml.Package) element).getPackagedElements());
185		}
186	0	return result;
187		}
188
189
190		public Object getElement(List<String> path) {
191	0	return getElement(path, null);
192		}
193
194		public Object getElement(List<String> path, Object theRootNamespace) {
195		// TODO: Auto-generated method stub
196	0	return null;
197		}
198
199		public List<String> getPathList(Object element) {
200		// TODO: Needs completing - stub implementation only! - tfm
201	0	List<String> path = new ArrayList<String>();
202	0	path.add(modelImpl.getFacade().getName(element));
203	0	return path;
204		}
205
206		public List<Object> getRootElements(Object model) {
207	0	if (model instanceof EObject) {
208	0	List<Object> contents = new ArrayList<Object>();
209	0	contents.addAll(((EObject) model).eResource().getContents());
210	0	if (!contents.contains(model)) {
211	0	contents.add(model);
212		}
213	0	return contents;
214		}
215	0	throw new IllegalArgumentException(
216		"model must be instance of EObject"); //$NON-NLS-1$
217		}
218
219		public boolean isCyclicOwnership(Object parent, Object child) {
220		// TODO: Auto-generated method stub
221	0	return false;
222		}
223
224		public void removeImportedElement(Object handle, Object me) {
225		// TODO: Auto-generated method stub
226	0	}
227
228		public void setAlias(Object handle, String alias) {
229		// TODO: Auto-generated method stub
230	0	}
231
232		public void setImportedElements(Object pack, Collection imports) {
233		// TODO: Auto-generated method stub
234	0	}
235
236		public void setSpecification(Object handle, boolean isSpecification) {
237		// TODO: Auto-generated method stub
238	0	}
239
240		public boolean isReadOnly(Object element) {
241		// TODO: Auto-generated method stub
242	0	return false;
243		}
244
245		}