KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > netbeans > modules > xml > wsdl > model > impl > WSDLModelImpl


1 /*
2  * The contents of this file are subject to the terms of the Common Development
3  * and Distribution License (the License). You may not use this file except in
4  * compliance with the License.
5  *
6  * You can obtain a copy of the License at http://www.netbeans.org/cddl.html
7  * or http://www.netbeans.org/cddl.txt.
8  *
9  * When distributing Covered Code, include this CDDL Header Notice in each file
10  * and include the License file at http://www.netbeans.org/cddl.txt.
11  * If applicable, add the following below the CDDL Header, with the fields
12  * enclosed by brackets [] replaced by your own identifying information:
13  * "Portions Copyrighted [year] [name of copyright owner]"
14  *
15  * The Original Software is NetBeans. The Initial Developer of the Original
16  * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
17  * Microsystems, Inc. All Rights Reserved.
18  */

19
20 package org.netbeans.modules.xml.wsdl.model.impl;
21
22 import java.util.ArrayList JavaDoc;
23 import java.util.Collection JavaDoc;
24 import java.util.Collections JavaDoc;
25 import java.util.List JavaDoc;
26 import java.util.Set JavaDoc;
27 import java.util.logging.Level JavaDoc;
28 import java.util.logging.Logger JavaDoc;
29 import javax.xml.namespace.QName JavaDoc;
30 import org.netbeans.modules.xml.schema.model.Schema;
31 import org.netbeans.modules.xml.schema.model.SchemaModel;
32 import org.netbeans.modules.xml.wsdl.model.spi.GenericExtensibilityElement;
33 import org.netbeans.modules.xml.xam.ModelSource;
34 import org.netbeans.modules.xml.wsdl.model.Definitions;
35 import org.netbeans.modules.xml.wsdl.model.Documentation;
36 import org.netbeans.modules.xml.wsdl.model.ExtensibilityElement;
37 import org.netbeans.modules.xml.wsdl.model.Import;
38 import org.netbeans.modules.xml.wsdl.model.ReferenceableWSDLComponent;
39 import org.netbeans.modules.xml.wsdl.model.Types;
40 import org.netbeans.modules.xml.wsdl.model.WSDLComponent;
41 import org.netbeans.modules.xml.wsdl.model.WSDLComponentFactory;
42 import org.netbeans.modules.xml.wsdl.model.WSDLModel;
43 import org.netbeans.modules.xml.wsdl.model.extensions.xsd.WSDLSchema;
44 import org.netbeans.modules.xml.wsdl.model.visitor.FindReferencedVisitor;
45 import org.netbeans.modules.xml.xam.dom.AbstractDocumentComponent;
46 import org.netbeans.modules.xml.xam.dom.AbstractDocumentModel;
47 import org.netbeans.modules.xml.xam.dom.DocumentComponent;
48 import org.netbeans.modules.xml.xam.ComponentUpdater;
49 import org.netbeans.modules.xml.xam.dom.ChangeInfo;
50 import org.netbeans.modules.xml.xam.dom.SyncUnit;
51 import org.w3c.dom.Element JavaDoc;
52 import org.w3c.dom.Node JavaDoc;
53
54 /**
55  *
56  * @author rico
57  * @author Nam Nguyen
58  */

59 public class WSDLModelImpl extends WSDLModel {
60     private Definitions definitions;
61     private WSDLComponentFactory wcf;
62     
63     public WSDLModelImpl(ModelSource source) {
64         super(source);
65         wcf = new WSDLComponentFactoryImpl(this);
66     }
67         
68     public WSDLComponent createRootComponent(Element root) {
69         DefinitionsImpl newDefinitions = null;
70         QName JavaDoc q = root == null ? null : AbstractDocumentComponent.getQName(root);
71         if (root != null && WSDLQNames.DEFINITIONS.getQName().equals(q)) {
72             newDefinitions = new DefinitionsImpl(this, root);
73             setDefinitions(newDefinitions);
74         } else {
75             return null;
76         }
77         
78         return getDefinitions();
79     }
80     
81     public WSDLComponent getRootComponent() {
82         return definitions;
83     }
84     
85     public WSDLComponent createComponent(WSDLComponent parent, Element element) {
86         return getFactory().create(element, parent);
87     }
88     
89     protected ComponentUpdater<WSDLComponent> getComponentUpdater() {
90         return new ChildComponentUpdateVisitor<WSDLComponent>();
91     }
92     
93     public WSDLComponentFactory getFactory() {
94         return wcf;
95     }
96     
97     public void setDefinitions(Definitions def){
98         assert (def instanceof DefinitionsImpl) ;
99         definitions = DefinitionsImpl.class.cast(def);
100     }
101     
102     public Definitions getDefinitions(){
103         return definitions;
104     }
105
106     ElementFactoryRegistry getElementRegistry() {
107         return ElementFactoryRegistry.getDefault();
108     }
109     
110     public List JavaDoc<WSDLModel> getImportedWSDLModels() {
111         List JavaDoc<WSDLModel> ret = new ArrayList JavaDoc<WSDLModel>();
112         Collection JavaDoc<Import> imports = getDefinitions().getImports();
113         for (Import i:imports) {
114             try {
115                 WSDLModel m = i.getImportedWSDLModel();
116                 if (m != null) {
117                     ret.add(m);
118                 }
119             } catch(Exception JavaDoc e) {
120                 Logger.getLogger(this.getClass().getName()).log(Level.FINE, "getImportedWSDLModels", e);
121             }
122         }
123         return ret;
124     }
125
126     public List JavaDoc<SchemaModel> getImportedSchemaModels() {
127         List JavaDoc<SchemaModel> ret = new ArrayList JavaDoc<SchemaModel>();
128         Collection JavaDoc<Import> imports = getDefinitions().getImports();
129         for (Import i:imports) {
130             try {
131                 SchemaModel m = ((ImportImpl)i).resolveToSchemaModel();
132                 if (m != null) {
133                     ret.add(m);
134                 }
135             } catch(Exception JavaDoc e) {
136                 Logger.getLogger(this.getClass().getName()).log(Level.FINE, "getImportedSchemaModels", e); //NOI18N
137
}
138         }
139         return ret;
140     }
141
142     public List JavaDoc<SchemaModel> getEmbeddedSchemaModels() {
143         List JavaDoc<SchemaModel> ret = new ArrayList JavaDoc<SchemaModel>();
144         Types types = getDefinitions().getTypes();
145         List JavaDoc<WSDLSchema> embeddedSchemas = Collections.emptyList();
146         if (types != null) {
147             embeddedSchemas = types.getExtensibilityElements(WSDLSchema.class);
148         }
149         for (WSDLSchema wschema : embeddedSchemas) {
150             ret.add(wschema.getSchemaModel());
151         }
152         return ret;
153     }
154     
155     public List JavaDoc<WSDLModel> findWSDLModel(String JavaDoc namespace) {
156         if (namespace == null) {
157             return Collections.emptyList();
158         }
159         
160         List JavaDoc<WSDLModel> models = getImportedWSDLModels();
161         models.add(0, this);
162
163         List JavaDoc<WSDLModel> ret = new ArrayList JavaDoc<WSDLModel>();
164         for (WSDLModel m : models) {
165             String JavaDoc targetNamespace = m.getDefinitions().getTargetNamespace();
166             if (namespace.equals(targetNamespace)) {
167                 ret.add(m);
168             }
169         }
170         return ret;
171     }
172
173     public List JavaDoc<Schema> findSchemas(String JavaDoc namespace) {
174         List JavaDoc<Schema> ret = new ArrayList JavaDoc<Schema>();
175         for (SchemaModel sm : getEmbeddedSchemaModels()) {
176             try {
177                 ret.addAll(sm.findSchemas(namespace));
178             } catch(Exception JavaDoc ex) {
179                 Logger.getLogger(this.getClass().getName()).log(Level.FINE, "findSchemas", ex);
180             }
181         }
182         SchemaModel sm = findSchemaModelFromImports(namespace);
183         if (sm != null) {
184             ret.add(sm.getSchema());
185         }
186         return ret;
187     }
188     
189     private SchemaModel findSchemaModelFromImports(String JavaDoc namespace) {
190         if (namespace == null) {
191             return null;
192         }
193         
194         List JavaDoc<SchemaModel> models = getImportedSchemaModels();
195         for (SchemaModel m : models) {
196             String JavaDoc targetNamespace = m.getSchema().getTargetNamespace();
197             if (namespace.equals(targetNamespace)) {
198                 return m;
199             }
200         }
201         return null;
202     }
203
204     public <T extends ReferenceableWSDLComponent> T findComponentByName(String JavaDoc name, Class JavaDoc<T> type) {
205         return type.cast(new FindReferencedVisitor(getDefinitions()).find(name, type));
206     }
207     
208     public <T extends ReferenceableWSDLComponent> T findComponentByName(QName JavaDoc name, Class JavaDoc<T> type) {
209         String JavaDoc namespace = name.getNamespaceURI();
210         if (namespace == null) {
211             return findComponentByName(name.getLocalPart(), type);
212         } else {
213             for (WSDLModel targetModel : findWSDLModel(namespace)) {
214                 T found = targetModel.findComponentByName(name.getLocalPart(), type);
215                 if (found != null) {
216                     return found;
217                 }
218             }
219         }
220         return null;
221     }
222     
223     public Set JavaDoc<QName JavaDoc> getQNames() {
224         return getElementRegistry().getKnownQNames();
225     }
226
227     public Set JavaDoc<String JavaDoc> getElementNames() {
228         return getElementRegistry().getKnownElementNames();
229     }
230     
231     public ChangeInfo prepareChangeInfo(List JavaDoc<Node JavaDoc> pathToRoot) {
232         ChangeInfo change = super.prepareChangeInfo(pathToRoot);
233         DocumentComponent parentComponent = findComponent(change.getRootToParentPath());
234         if (parentComponent == null) {
235             return change;
236         }
237         if (! (parentComponent.getModel() instanceof WSDLModel))
238         {
239             getElementRegistry().addEmbeddedModelQNames((AbstractDocumentModel)parentComponent.getModel());
240             change = super.prepareChangeInfo(pathToRoot);
241         } else if (isDomainElement(parentComponent.getPeer()) &&
242                 ! change.isDomainElement() && change.getChangedElement() != null)
243         {
244             if (change.getOtherNonDomainElementNodes() == null ||
245                 change.getOtherNonDomainElementNodes().isEmpty())
246             {
247                 // case add or remove generic extensibility element
248
change.setDomainElement(true);
249                 change.setParentComponent(null);
250             } else if (! (parentComponent instanceof Documentation)) {
251                 List JavaDoc<Element> rootToChanged = new ArrayList JavaDoc<Element>(change.getRootToParentPath());
252                 rootToChanged.add(change.getChangedElement());
253                 DocumentComponent changedComponent = findComponent(rootToChanged);
254                 if (changedComponent != null &&
255                     changedComponent.getClass().isAssignableFrom(GenericExtensibilityElement.class)) {
256                     // case generic extensibility element changed
257
change.markNonDomainChildAsChanged();
258                     change.setParentComponent(null);
259                 }
260             }
261         } else {
262             change.setParentComponent(parentComponent);
263         }
264         return change;
265     }
266     
267     public SyncUnit prepareSyncUnit(ChangeInfo changes, SyncUnit unit) {
268         unit = super.prepareSyncUnit(changes, unit);
269         if (unit != null) {
270             return new SyncReviewVisitor().review(unit);
271         }
272         return null;
273     }
274     
275     public AbstractDocumentComponent findComponent(
276             AbstractDocumentComponent current,
277             List JavaDoc<org.w3c.dom.Element JavaDoc> pathFromRoot,
278             int iCurrent) {
279         
280         if (current instanceof ExtensibilityElement.EmbeddedModel) {
281             ExtensibilityElement.EmbeddedModel emb = (ExtensibilityElement.EmbeddedModel) current;
282             AbstractDocumentModel axm = (AbstractDocumentModel) emb.getEmbeddedModel();
283             AbstractDocumentComponent embedded = (AbstractDocumentComponent) axm.getRootComponent();
284             return axm.findComponent(embedded, pathFromRoot, iCurrent);
285         } else {
286             return super.findComponent(current, pathFromRoot, iCurrent);
287         }
288     }
289 }
290
Popular Tags