KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > sun > enterprise > tools > common > dd > appclient > SunApplicationClient


1 /*
2  * The contents of this file are subject to the terms
3  * of the Common Development and Distribution License
4  * (the License). You may not use this file except in
5  * compliance with the License.
6  *
7  * You can obtain a copy of the license at
8  * https://glassfish.dev.java.net/public/CDDLv1.0.html or
9  * glassfish/bootstrap/legal/CDDLv1.0.txt.
10  * See the License for the specific language governing
11  * permissions and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL
14  * Header Notice in each file and include the License file
15  * at glassfish/bootstrap/legal/CDDLv1.0.txt.
16  * If applicable, add the following below the CDDL Header,
17  * with the fields enclosed by brackets [] replaced by
18  * you own identifying information:
19  * "Portions Copyrighted [year] [name of copyright owner]"
20  *
21  * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
22  */
23
24 /**
25  * This generated bean class SunApplicationClient matches the schema element sun-application-client
26  *
27  * Generated on Thu Jul 31 15:53:12 PDT 2003
28  *
29  * This class matches the root element of the DTD,
30  * and is the root of the following bean graph:
31  *
32  * sun-application-client : SunApplicationClient
33  * ejb-ref : EjbRef[0,n]
34  * ejb-ref-name : String
35  * jndi-name : String
36  * resource-ref : ResourceRef[0,n]
37  * res-ref-name : String
38  * jndi-name : String
39  * default-resource-principal : DefaultResourcePrincipal?
40  * name : String
41  * password : String
42  * resource-env-ref : ResourceEnvRef[0,n]
43  * resource-env-ref-name : String
44  * jndi-name : String
45  * service-ref : ServiceRef[0,n]
46  * service-ref-name : String
47  * port-info : PortInfo[0,n]
48  * service-endpoint-interface : String?
49  * wsdl-port : WsdlPort?
50  * namespaceURI : String
51  * localpart : String
52  * stub-property : StubProperty[0,n]
53  * name : String
54  * value : String
55  * call-property : CallProperty[0,n]
56  * name : String
57  * value : String
58  * call-property : CallProperty[0,n]
59  * name : String
60  * value : String
61  * wsdl-override : String?
62  * service-impl-class : String?
63  * service-qname : ServiceQname?
64  * namespaceURI : String
65  * localpart : String
66  * message-destination : MessageDestination[0,n]
67  * message-destination-name : String
68  * jndi-name : String
69  *
70  */
71
72 package com.sun.enterprise.tools.common.dd.appclient;
73
74 import org.w3c.dom.*;
75 import org.netbeans.modules.schema2beans.*;
76 import java.beans.*;
77 import java.util.*;
78 import java.io.*;
79 import com.sun.enterprise.tools.common.dd.EjbRef;
80 import com.sun.enterprise.tools.common.dd.ResourceEnvRef;
81 import com.sun.enterprise.tools.common.dd.ResourceRef;
82 import com.sun.enterprise.tools.common.dd.ServiceRef;
83 import com.sun.enterprise.tools.common.dd.MessageDestination;
84 import com.sun.enterprise.tools.common.dd.PluginData;
85
86 // BEGIN_NOI18N
87
88 public class SunApplicationClient extends com.sun.enterprise.tools.common.dd.SunBaseBean
89 {
90
91     static Vector comparators = new Vector();
92
93     static public final String JavaDoc EJB_REF = "EjbRef"; // NOI18N
94 static public final String JavaDoc RESOURCE_REF = "ResourceRef"; // NOI18N
95 static public final String JavaDoc RESOURCE_ENV_REF = "ResourceEnvRef"; // NOI18N
96 static public final String JavaDoc SERVICE_REF = "ServiceRef"; // NOI18N
97 static public final String JavaDoc MESSAGE_DESTINATION = "MessageDestination"; // NOI18N
98
99     public SunApplicationClient() throws org.netbeans.modules.schema2beans.Schema2BeansException {
100         this(null, Common.USE_DEFAULT_VALUES);
101     }
102
103     public SunApplicationClient(org.w3c.dom.Node JavaDoc doc, int options) throws org.netbeans.modules.schema2beans.Schema2BeansException {
104         this(Common.NO_DEFAULT_VALUES);
105         initFromNode(doc, options);
106     }
107     protected void initFromNode(org.w3c.dom.Node JavaDoc doc, int options) throws Schema2BeansException
108     {
109         if (doc == null)
110         {
111             doc = GraphManager.createRootElementNode("sun-application-client"); // NOI18N
112 if (doc == null)
113                 throw new Schema2BeansException(Common.getMessage(
114                     "CantCreateDOMRoot_msg", "sun-application-client"));
115         }
116         Node n = GraphManager.getElementNode("sun-application-client", doc); // NOI18N
117 if (n == null)
118             throw new Schema2BeansException(Common.getMessage(
119                 "DocRootNotInDOMGraph_msg", "sun-application-client", doc.getFirstChild().getNodeName()));
120
121         this.graphManager.setXmlDocument(doc);
122
123         // Entry point of the createBeans() recursive calls
124 this.createBean(n, this.graphManager());
125         this.initialize(options);
126     }
127     public SunApplicationClient(int options)
128     {
129         super(comparators, new org.netbeans.modules.schema2beans.Version(1, 2, 0));
130         initOptions(options);
131     }
132     protected void initOptions(int options)
133     {
134         // The graph manager is allocated in the bean root
135 this.graphManager = new GraphManager(this);
136         this.createRoot("sun-application-client", "SunApplicationClient", // NOI18N
137 Common.TYPE_1 | Common.TYPE_BEAN, SunApplicationClient.class);
138
139         // Properties (see root bean comments for the bean graph)
140 this.createProperty("ejb-ref", // NOI18N
141 EJB_REF,
142             Common.TYPE_0_N | Common.TYPE_BEAN | Common.TYPE_KEY,
143             EjbRef.class);
144         this.createProperty("resource-ref", // NOI18N
145 RESOURCE_REF,
146             Common.TYPE_0_N | Common.TYPE_BEAN | Common.TYPE_KEY,
147             ResourceRef.class);
148         this.createProperty("resource-env-ref", // NOI18N
149 RESOURCE_ENV_REF,
150             Common.TYPE_0_N | Common.TYPE_BEAN | Common.TYPE_KEY,
151             ResourceEnvRef.class);
152         this.createProperty("service-ref", // NOI18N
153 SERVICE_REF,
154             Common.TYPE_0_N | Common.TYPE_BEAN | Common.TYPE_KEY,
155             ServiceRef.class);
156         this.createProperty("message-destination", // NOI18N
157 MESSAGE_DESTINATION,
158             Common.TYPE_0_N | Common.TYPE_BEAN | Common.TYPE_KEY,
159             MessageDestination.class);
160         this.initialize(options);
161     }
162
163     // Setting the default values of the properties
164 void initialize(int options)
165     {
166
167     }
168
169     // This attribute is an array, possibly empty
170 public void setEjbRef(int index, EjbRef value) {
171         this.setValue(EJB_REF, index, value);
172     }
173
174     //
175 public EjbRef getEjbRef(int index) {
176         return (EjbRef)this.getValue(EJB_REF, index);
177     }
178
179     // This attribute is an array, possibly empty
180 public void setEjbRef(EjbRef[] value) {
181         this.setValue(EJB_REF, value);
182     }
183
184     //
185 public EjbRef[] getEjbRef() {
186         return (EjbRef[])this.getValues(EJB_REF);
187     }
188
189     // Return the number of properties
190 public int sizeEjbRef() {
191         return this.size(EJB_REF);
192     }
193
194     // Add a new element returning its index in the list
195 public int addEjbRef(EjbRef value) {
196         return this.addValue(EJB_REF, value);
197     }
198
199     //
200 // Remove an element using its reference
201 // Returns the index the element had in the list
202 //
203 public int removeEjbRef(EjbRef value) {
204         return this.removeValue(EJB_REF, value);
205     }
206
207     // This attribute is an array, possibly empty
208 public void setResourceRef(int index, ResourceRef value) {
209         this.setValue(RESOURCE_REF, index, value);
210     }
211
212     //
213 public ResourceRef getResourceRef(int index) {
214         return (ResourceRef)this.getValue(RESOURCE_REF, index);
215     }
216
217     // This attribute is an array, possibly empty
218 public void setResourceRef(ResourceRef[] value) {
219         this.setValue(RESOURCE_REF, value);
220     }
221
222     //
223 public ResourceRef[] getResourceRef() {
224         return (ResourceRef[])this.getValues(RESOURCE_REF);
225     }
226
227     // Return the number of properties
228 public int sizeResourceRef() {
229         return this.size(RESOURCE_REF);
230     }
231
232     // Add a new element returning its index in the list
233 public int addResourceRef(ResourceRef value) {
234         return this.addValue(RESOURCE_REF, value);
235     }
236
237     //
238 // Remove an element using its reference
239 // Returns the index the element had in the list
240 //
241 public int removeResourceRef(ResourceRef value) {
242         return this.removeValue(RESOURCE_REF, value);
243     }
244
245     // This attribute is an array, possibly empty
246 public void setResourceEnvRef(int index, ResourceEnvRef value) {
247         this.setValue(RESOURCE_ENV_REF, index, value);
248     }
249
250     //
251 public ResourceEnvRef getResourceEnvRef(int index) {
252         return (ResourceEnvRef)this.getValue(RESOURCE_ENV_REF, index);
253     }
254
255     // This attribute is an array, possibly empty
256 public void setResourceEnvRef(ResourceEnvRef[] value) {
257         this.setValue(RESOURCE_ENV_REF, value);
258     }
259
260     //
261 public ResourceEnvRef[] getResourceEnvRef() {
262         return (ResourceEnvRef[])this.getValues(RESOURCE_ENV_REF);
263     }
264
265     // Return the number of properties
266 public int sizeResourceEnvRef() {
267         return this.size(RESOURCE_ENV_REF);
268     }
269
270     // Add a new element returning its index in the list
271 public int addResourceEnvRef(ResourceEnvRef value) {
272         return this.addValue(RESOURCE_ENV_REF, value);
273     }
274
275     //
276 // Remove an element using its reference
277 // Returns the index the element had in the list
278 //
279 public int removeResourceEnvRef(ResourceEnvRef value) {
280         return this.removeValue(RESOURCE_ENV_REF, value);
281     }
282
283     // This attribute is an array, possibly empty
284 public void setServiceRef(int index, ServiceRef value) {
285         this.setValue(SERVICE_REF, index, value);
286     }
287
288     //
289 public ServiceRef getServiceRef(int index) {
290         return (ServiceRef)this.getValue(SERVICE_REF, index);
291     }
292
293     // This attribute is an array, possibly empty
294 public void setServiceRef(ServiceRef[] value) {
295         this.setValue(SERVICE_REF, value);
296     }
297
298     //
299 public ServiceRef[] getServiceRef() {
300         return (ServiceRef[])this.getValues(SERVICE_REF);
301     }
302
303     // Return the number of properties
304 public int sizeServiceRef() {
305         return this.size(SERVICE_REF);
306     }
307
308     // Add a new element returning its index in the list
309 public int addServiceRef(ServiceRef value) {
310         return this.addValue(SERVICE_REF, value);
311     }
312
313     //
314 // Remove an element using its reference
315 // Returns the index the element had in the list
316 //
317 public int removeServiceRef(ServiceRef value) {
318         return this.removeValue(SERVICE_REF, value);
319     }
320
321     // This attribute is an array, possibly empty
322 public void setMessageDestination(int index, MessageDestination value) {
323         this.setValue(MESSAGE_DESTINATION, index, value);
324     }
325
326     //
327 public MessageDestination getMessageDestination(int index) {
328         return (MessageDestination)this.getValue(MESSAGE_DESTINATION, index);
329     }
330
331     // This attribute is an array, possibly empty
332 public void setMessageDestination(MessageDestination[] value) {
333         this.setValue(MESSAGE_DESTINATION, value);
334     }
335
336     //
337 public MessageDestination[] getMessageDestination() {
338         return (MessageDestination[])this.getValues(MESSAGE_DESTINATION);
339     }
340
341     // Return the number of properties
342 public int sizeMessageDestination() {
343         return this.size(MESSAGE_DESTINATION);
344     }
345
346     // Add a new element returning its index in the list
347 public int addMessageDestination(MessageDestination value) {
348         return this.addValue(MESSAGE_DESTINATION, value);
349     }
350
351     //
352 // Remove an element using its reference
353 // Returns the index the element had in the list
354 //
355 public int removeMessageDestination(MessageDestination value) {
356         return this.removeValue(MESSAGE_DESTINATION, value);
357     }
358
359     //
360 public static void addComparator(org.netbeans.modules.schema2beans.BeanComparator c) {
361         comparators.add(c);
362     }
363
364     //
365 public static void removeComparator(org.netbeans.modules.schema2beans.BeanComparator c) {
366         comparators.remove(c);
367     }
368     //
369 // This method returns the root of the bean graph
370 // Each call creates a new bean graph from the specified DOM graph
371 //
372 public static SunApplicationClient createGraph(org.w3c.dom.Node JavaDoc doc) throws org.netbeans.modules.schema2beans.Schema2BeansException {
373         return new SunApplicationClient(doc, Common.NO_DEFAULT_VALUES);
374     }
375
376     public static SunApplicationClient createGraph(java.io.InputStream JavaDoc in) throws org.netbeans.modules.schema2beans.Schema2BeansException {
377         return createGraph(in, false);
378     }
379
380     public static SunApplicationClient createGraph(java.io.InputStream JavaDoc in, boolean validate) throws org.netbeans.modules.schema2beans.Schema2BeansException {
381         Document doc = GraphManager.createXmlDocument(in, validate);
382         return createGraph(doc);
383     }
384
385     //
386 // This method returns the root for a new empty bean graph
387 //
388 public static SunApplicationClient createGraph() {
389         try {
390             return new SunApplicationClient();
391         }
392         catch (Schema2BeansException e) {
393             throw new RuntimeException JavaDoc(e.getMessage());
394         }
395     }
396
397     public void validate() throws org.netbeans.modules.schema2beans.ValidateException {
398         boolean restrictionFailure = false;
399         // Validating property ejbRef
400 for (int _index = 0; _index < sizeEjbRef(); ++_index) {
401             EjbRef element = getEjbRef(_index);
402             if (element != null) {
403                 element.validate();
404             }
405         }
406         // Validating property resourceRef
407 for (int _index = 0; _index < sizeResourceRef(); ++_index) {
408             ResourceRef element = getResourceRef(_index);
409             if (element != null) {
410                 element.validate();
411             }
412         }
413         // Validating property resourceEnvRef
414 for (int _index = 0; _index < sizeResourceEnvRef(); ++_index) {
415             ResourceEnvRef element = getResourceEnvRef(_index);
416             if (element != null) {
417                 element.validate();
418             }
419         }
420         // Validating property serviceRef
421 for (int _index = 0; _index < sizeServiceRef(); ++_index) {
422             ServiceRef element = getServiceRef(_index);
423             if (element != null) {
424                 element.validate();
425             }
426         }
427         // Validating property messageDestination
428 for (int _index = 0; _index < sizeMessageDestination(); ++_index) {
429             MessageDestination element = getMessageDestination(_index);
430             if (element != null) {
431                 element.validate();
432             }
433         }
434     }
435
436     // Special serializer: output XML as serialization
437 private void writeObject(java.io.ObjectOutputStream JavaDoc out) throws java.io.IOException JavaDoc{
438         ByteArrayOutputStream baos = new ByteArrayOutputStream();
439         write(baos);
440         String JavaDoc str = baos.toString();;
441         // System.out.println("str='"+str+"'");
442 out.writeUTF(str);
443     }
444     // Special deserializer: read XML as deserialization
445 private void readObject(java.io.ObjectInputStream JavaDoc in) throws java.io.IOException JavaDoc, ClassNotFoundException JavaDoc{
446         try{
447             init(comparators, new org.netbeans.modules.schema2beans.Version(1, 2, 0));
448             String JavaDoc strDocument = in.readUTF();
449             // System.out.println("strDocument='"+strDocument+"'");
450 ByteArrayInputStream bais = new ByteArrayInputStream(strDocument.getBytes());
451             Document doc = GraphManager.createXmlDocument(bais, false);
452             initOptions(Common.NO_DEFAULT_VALUES);
453             initFromNode(doc, Common.NO_DEFAULT_VALUES);
454         }
455         catch (Schema2BeansException e) {
456             e.printStackTrace();
457             throw new RuntimeException JavaDoc(e.getMessage());
458         }
459     }
460
461     // Dump the content of this bean returning it as a String
462 public void dump(StringBuffer JavaDoc str, String JavaDoc indent){
463         String JavaDoc s;
464         Object JavaDoc o;
465         org.netbeans.modules.schema2beans.BaseBean n;
466         str.append(indent);
467         str.append("EjbRef["+this.sizeEjbRef()+"]"); // NOI18N
468 for(int i=0; i<this.sizeEjbRef(); i++)
469         {
470             str.append(indent+"\t");
471             str.append("#"+i+":");
472             n = (org.netbeans.modules.schema2beans.BaseBean) this.getEjbRef(i);
473             if (n != null)
474                 n.dump(str, indent + "\t"); // NOI18N
475 else
476                 str.append(indent+"\tnull"); // NOI18N
477 this.dumpAttributes(EJB_REF, i, str, indent);
478         }
479
480         str.append(indent);
481         str.append("ResourceRef["+this.sizeResourceRef()+"]"); // NOI18N
482 for(int i=0; i<this.sizeResourceRef(); i++)
483         {
484             str.append(indent+"\t");
485             str.append("#"+i+":");
486             n = (org.netbeans.modules.schema2beans.BaseBean) this.getResourceRef(i);
487             if (n != null)
488                 n.dump(str, indent + "\t"); // NOI18N
489 else
490                 str.append(indent+"\tnull"); // NOI18N
491 this.dumpAttributes(RESOURCE_REF, i, str, indent);
492         }
493
494         str.append(indent);
495         str.append("ResourceEnvRef["+this.sizeResourceEnvRef()+"]"); // NOI18N
496 for(int i=0; i<this.sizeResourceEnvRef(); i++)
497         {
498             str.append(indent+"\t");
499             str.append("#"+i+":");
500             n = (org.netbeans.modules.schema2beans.BaseBean) this.getResourceEnvRef(i);
501             if (n != null)
502                 n.dump(str, indent + "\t"); // NOI18N
503 else
504                 str.append(indent+"\tnull"); // NOI18N
505 this.dumpAttributes(RESOURCE_ENV_REF, i, str, indent);
506         }
507
508         str.append(indent);
509         str.append("ServiceRef["+this.sizeServiceRef()+"]"); // NOI18N
510 for(int i=0; i<this.sizeServiceRef(); i++)
511         {
512             str.append(indent+"\t");
513             str.append("#"+i+":");
514             n = (org.netbeans.modules.schema2beans.BaseBean) this.getServiceRef(i);
515             if (n != null)
516                 n.dump(str, indent + "\t"); // NOI18N
517 else
518                 str.append(indent+"\tnull"); // NOI18N
519 this.dumpAttributes(SERVICE_REF, i, str, indent);
520         }
521
522         str.append(indent);
523         str.append("MessageDestination["+this.sizeMessageDestination()+"]"); // NOI18N
524 for(int i=0; i<this.sizeMessageDestination(); i++)
525         {
526             str.append(indent+"\t");
527             str.append("#"+i+":");
528             n = (org.netbeans.modules.schema2beans.BaseBean) this.getMessageDestination(i);
529             if (n != null)
530                 n.dump(str, indent + "\t"); // NOI18N
531 else
532                 str.append(indent+"\tnull"); // NOI18N
533 this.dumpAttributes(MESSAGE_DESTINATION, i, str, indent);
534         }
535
536     }
537     public String JavaDoc dumpBeanNode(){
538         StringBuffer JavaDoc str = new StringBuffer JavaDoc();
539         str.append("SunApplicationClient\n"); // NOI18N
540 this.dump(str, "\n "); // NOI18N
541 return str.toString();
542     }}
543
544 // END_NOI18N
545
546
547 /*
548         The following schema file has been used for generation:
549
550 <!--
551   XML DTD for Sun ONE Application Server specific J2EE Client Application
552   deployment descriptor. This is a companion DTD to application-client_1_4.xsd
553
554   $Revision: 1.3 $
555 -->
556
557 <!--
558 application-client is the root element describing all the runtime bindings
559 of a single application client
560 -->
561 <!ELEMENT sun-application-client (ejb-ref*, resource-ref*, resource-env-ref*, service-ref*,
562     message-destination*)>
563
564 <!--
565 name of a resource reference.
566 -->
567 <!ELEMENT res-ref-name (#PCDATA)>
568
569 <!--
570 resource-env-ref holds all the runtime bindings of a resource env reference.
571 -->
572 <!ELEMENT resource-env-ref ( resource-env-ref-name, jndi-name )>
573
574 <!--
575 name of a resource env reference.
576 -->
577 <!ELEMENT resource-env-ref-name (#PCDATA)>
578
579 <!--
580 resource-ref holds the runtime bindings of a resource reference.
581 -->
582 <!ELEMENT resource-ref ( res-ref-name, jndi-name, default-resource-principal?)>
583
584 <!--
585 default-resource-principal specifies the default principal that the container
586 will use to access a resource.
587 -->
588 <!ELEMENT default-resource-principal ( name, password)>
589
590 <!--
591 name element holds the user name
592 -->
593 <!ELEMENT name (#PCDATA)>
594
595 <!--
596 password element holds a password string.
597 -->
598 <!ELEMENT password (#PCDATA)>
599
600 <!--
601 ejb-ref element which binds an ejb reference to a jndi name.
602 -->
603 <!ELEMENT ejb-ref (ejb-ref-name, jndi-name)>
604
605 <!--
606 ejb-ref-name locates the name of the ejb reference in the application.
607 -->
608 <!ELEMENT ejb-ref-name (#PCDATA)>
609
610 <!--
611 jndi name of the associated entity
612 -->
613 <!ELEMENT jndi-name (#PCDATA)>
614
615 <!--
616 This node holds information about a logical message destination
617 -->
618 <!ELEMENT message-destination (message-destination-name, jndi-name)>
619
620 <!--
621 This node holds the name of a logical message destination
622 -->
623 <!ELEMENT message-destination-name (#PCDATA)>
624
625 <!--
626 Specifies the name of a durable subscription associated with a message-driven bean's
627 destination. Required for a Topic destination, if subscription-durability is set to
628 Durable (in ejb-jar.xml)
629 -->
630
631 <!--
632             W E B S E R V I C E S
633 -->
634 <!--
635 Runtime settings for a web service reference. In the simplest case,
636 there is no runtime information required for a service ref. Runtime info
637 is only needed in the following cases :
638  * to define the port that should be used to resolve a container-managed port
639  * to define default Stub/Call property settings for Stub objects
640  * to define the URL of a final WSDL document to be used instead of
641 the one packaged with a service-ref
642 -->
643 <!ELEMENT service-ref ( service-ref-name, port-info*, call-property*,
644         wsdl-override?, service-impl-class?, service-qname? )>
645
646 <!--
647 Coded name (relative to java:comp/env) for a service-reference
648 -->
649 <!ELEMENT service-ref-name ( #PCDATA )>
650
651 <!--
652 Information for a port within a service-reference.
653
654 Either service-endpoint-interface or wsdl-port or both
655 (service-endpoint-interface and wsdl-port) should be specified.
656
657 If both are specified, wsdl-port represents the
658 port the container should choose for container-managed port selection.
659
660 The same wsdl-port value must not appear in
661 more than one port-info entry within the same service-ref.
662
663 If a particular service-endpoint-interface is using container-managed port
664 selection, it must not appear in more than one port-info entry
665 within the same service-ref.
666
667 -->
668 <!ELEMENT port-info ( service-endpoint-interface?, wsdl-port?, stub-property*, call-property* )>
669
670 <!--
671 Fully qualified name of service endpoint interface
672 -->
673 <!ELEMENT service-endpoint-interface ( #PCDATA )>
674 <!--
675 Port used in port-info.
676 -->
677 <!ELEMENT wsdl-port ( namespaceURI, localpart )>
678
679 <!--
680 JAXRPC property values that should be set on a stub before it's returned to
681 to the web service client. The property names can be any properties supported
682 by the JAXRPC Stub implementation. See javadoc for javax.xml.rpc.Stub
683 -->
684 <!ELEMENT stub-property ( name, value )>
685
686 <!--
687 JAXRPC property values that should be set on a Call object before it's
688 returned to the web service client. The property names can be any
689 properties supported by the JAXRPC Call implementation. See javadoc
690 for javax.xml.rpc.Call
691 -->
692 <!ELEMENT call-property ( name, value )>
693
694 <!--
695 This is a valid URL pointing to a final WSDL document. It is optional.
696 If specified, the WSDL document at this URL will be used during
697 deployment instead of the WSDL document associated with the
698 service-ref in the standard deployment descriptor.
699
700 Examples :
701
702   // available via HTTP
703   <wsdl-override>http://localhost:8000/myservice/myport?WSDL</wsdl-override>
704
705   // in a file
706   <wsdl-override>file:/home/user1/myfinalwsdl.wsdl</wsdl-override>
707
708 -->
709 <!ELEMENT wsdl-override ( #PCDATA )>
710
711 <!--
712 Name of generated service implementation class. This is not set by the
713 deployer. It is derived during deployment.
714 -->
715 <!ELEMENT service-impl-class ( #PCDATA )>
716
717 <!--
718 The service-qname element declares the specific WSDL service
719 element that is being refered to. It is not set by the deployer.
720 It is derived during deployment.
721 -->
722 <!ELEMENT service-qname (namespaceURI, localpart)>
723
724 <!--
725 The localpart element indicates the local part of a QNAME.
726 -->
727 <!ELEMENT localpart (#PCDATA)>
728
729 <!--
730 The namespaceURI element indicates a URI.
731 -->
732 <!ELEMENT namespaceURI (#PCDATA)>
733
734 <!--
735 This text nodes holds a value string.
736 -->
737 <!ELEMENT value (#PCDATA)>
738
739 <!-- This information is used, only by Studio-plugin;it is NOT the part of the real DTD.
740 -->
741 <!ELEMENT plugin-data ( auto-generate-sql?, client-jar-path?, client-args? )>
742 <!ELEMENT auto-generate-sql (#PCDATA)>
743 <!ELEMENT client-jar-path (#PCDATA)>
744 <!ELEMENT client-args (#PCDATA)>
745
746 */
747
Popular Tags