001: /*
002: * Jacareto Copyright (c) 2002-2005
003: * Applied Computer Science Research Group, Darmstadt University of
004: * Technology, Institute of Mathematics & Computer Science,
005: * Ludwigsburg University of Education, and Computer Based
006: * Learning Research Group, Aachen University. All rights reserved.
007: *
008: * Jacareto is free software; you can redistribute it and/or
009: * modify it under the terms of the GNU General Public
010: * License as published by the Free Software Foundation; either
011: * version 2 of the License, or (at your option) any later version.
012: *
013: * Jacareto is distributed in the hope that it will be useful,
014: * but WITHOUT ANY WARRANTY; without even the implied warranty of
015: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
016: * General Public License for more details.
017: *
018: * You should have received a copy of the GNU General Public
019: * License along with Jacareto; if not, write to the Free
020: * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
021: *
022: */
023:
024: package jacareto.convert.interactionmodel;
025:
026: import jacareto.convert.RecursiveInteractionModelConverter;
027: import jacareto.convert.SelectionInteractionModelConverter;
028: import jacareto.interactionmodel.InteractionModelElement;
029: import jacareto.interactionmodel.UseCaseElement;
030: import jacareto.system.Environment;
031:
032: import org.jdom.Element;
033:
034: import java.util.Iterator;
035: import java.util.Vector;
036:
037: /**
038: * A converter which is able to convert use-case element to xml representations, and vice versa.
039: *
040: * @author <a href="mailto:markus.bois@web.de">Markus Bois</a>
041: * @version 1.02
042: */
043: public class UseCaseConverter extends
044: RecursiveInteractionModelConverter {
045: /**
046: * Creates a new converter.
047: *
048: * @param env DOCUMENT ME!
049: */
050: public UseCaseConverter(Environment env) {
051: super (env);
052: setSelectionInteractionModelConverter(new SelectionInteractionModelConverter(
053: env, "InteractionModelElements.Converters",
054: SelectionInteractionModelConverter.INIT_CUSTOM));
055: }
056:
057: /**
058: * Creates a new recursive converter
059: *
060: * @param env the enviroment
061: * @param selectionInteractionModelConverter the available converters
062: */
063: public UseCaseConverter(
064: Environment env,
065: SelectionInteractionModelConverter selectionInteractionModelConverter) {
066: super (env);
067: setSelectionInteractionModelConverter(selectionInteractionModelConverter);
068: }
069:
070: /**
071: * Returns whether this converter is able to transform the specified interaction-model element
072: * to an internal structure representation. This converter is responsible for the given
073: * interaction-model element if it is of type {@link
074: * jacareto.interactionmodel.UseCaseElement}.
075: *
076: * @param element the interaction-model element
077: *
078: * @return <code>true</code> if this converter is responsible for the given interaction-model
079: * element; otherwise <code>false</code>.
080: */
081: public boolean handlesElement(InteractionModelElement element) {
082: return (element != null) && element instanceof UseCaseElement;
083: }
084:
085: /**
086: * Converts the specified object to a structure object, if this converter is responsible for
087: * it. For responsibility see {@link #handlesElement(InteractionModelElement)}.
088: *
089: * @param element the interaction-model element to convert
090: *
091: * @return the structure object (which is a xml element)
092: */
093: public Object convertElement(InteractionModelElement element) {
094: UseCaseElement useCaseElement = (UseCaseElement) element;
095: Iterator it = useCaseElement.children();
096:
097: Element result = new Element("use-case");
098: Element name = new Element("name");
099:
100: name.setText(useCaseElement.getName());
101: result.addContent(name);
102:
103: while (it.hasNext()) {
104: InteractionModelElement next = null;
105: next = (InteractionModelElement) it.next();
106:
107: if ((next != null) && !(next instanceof UseCaseElement)) {
108: if (selectionInteractionModelConverter
109: .handlesElement(next)) {
110: Object toAdd = selectionInteractionModelConverter
111: .convertElement(next);
112:
113: if ((toAdd != null)
114: && !(next instanceof UseCaseElement)) {
115: result.addContent((Element) toAdd);
116: }
117: }
118: }
119: }
120:
121: return result;
122: }
123:
124: /**
125: * Returns whether this converter is able to transform the specified other representation (here
126: * a xml element) to a interaction-model element. This converter is responsible if the other
127: * representation is of type <code>jdom.org.Element</code> and the name of the element is
128: * "use-case"
129: *
130: * @param other the other representation
131: *
132: * @return <code>true</code> if this converter is responsible for the specified other
133: * representation; otherwise <code>false</code>.
134: */
135: public boolean handlesOther(Object other) {
136: try {
137: Element e = (Element) other;
138:
139: return e.getName().equals("use-case");
140: } catch (Throwable t) {
141: return false;
142: }
143: }
144:
145: /**
146: * Converts the specified other representation to a structure element, if this converter is
147: * responsible for it (reverses {@link #convertElement(InteractionModelElement)}). For
148: * responsibility see {@link #handlesOther(Object)}.
149: *
150: * @param other the other representation to convert
151: *
152: * @return the interaction-model-element element (of type {@link
153: * jacareto.interactionmodel.UseCaseElement})
154: */
155: public InteractionModelElement convertOther(Object other) {
156: Element element = (Element) other;
157: Vector children = new Vector();
158: Element nameElement = element.getChild("name");
159: String name = "";
160: String id = element.getAttributeValue("id", "");
161:
162: if (nameElement != null) {
163: name = nameElement.getText();
164: }
165:
166: Iterator iterator = element.getChildren("dynamics").iterator();
167:
168: while (iterator.hasNext()) {
169: Object internalRepresentation = iterator.next();
170:
171: if (selectionInteractionModelConverter
172: .handlesOther(internalRepresentation)) {
173: InteractionModelElement toAdd = selectionInteractionModelConverter
174: .convertOther(internalRepresentation);
175:
176: if (toAdd != null) {
177: children.addAll(InteractionModelElement
178: .arrayToVector(toAdd.getChildren()));
179: }
180: }
181: }
182:
183: return new UseCaseElement(env, name, InteractionModelElement
184: .vectorToArray(children), id);
185: }
186: }
|