KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > sun > enterprise > tools > common > dd > webapp > ConstraintField


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 ConstraintField matches the schema element constraint-field
26  *
27  * Generated on Tue Sep 02 18:08:42 PDT 2003
28  */

29
30 package com.sun.enterprise.tools.common.dd.webapp;
31
32 import org.w3c.dom.*;
33 import org.netbeans.modules.schema2beans.*;
34 import java.beans.*;
35 import java.util.*;
36
37 // BEGIN_NOI18N
38

39 public class ConstraintField extends com.sun.enterprise.tools.common.dd.SunBaseBean
40 {
41
42     static Vector comparators = new Vector();
43
44     static public final String JavaDoc NAME = "Name"; // NOI18N
45
static public final String JavaDoc SCOPE = "Scope"; // NOI18N
46
static public final String JavaDoc CACHEONMATCH = "CacheOnMatch"; // NOI18N
47
static public final String JavaDoc CACHEONMATCHFAILURE = "CacheOnMatchFailure"; // NOI18N
48
static public final String JavaDoc CONSTRAINT_FIELD_VALUE = "ConstraintFieldValue"; // NOI18N
49
static public final String JavaDoc CONSTRAINTFIELDVALUEMATCHEXPR = "ConstraintFieldValueMatchExpr"; // NOI18N
50
static public final String JavaDoc CONSTRAINTFIELDVALUECACHEONMATCH = "ConstraintFieldValueCacheOnMatch"; // NOI18N
51
static public final String JavaDoc CONSTRAINTFIELDVALUECACHEONMATCHFAILURE = "ConstraintFieldValueCacheOnMatchFailure"; // NOI18N
52

53     public ConstraintField() {
54         this(Common.USE_DEFAULT_VALUES);
55     }
56
57     public ConstraintField(int options)
58     {
59         super(comparators, new org.netbeans.modules.schema2beans.Version(1, 2, 0));
60         // Properties (see root bean comments for the bean graph)
61
this.createProperty("constraint-field-value", // NOI18N
62
CONSTRAINT_FIELD_VALUE,
63             Common.TYPE_0_N | Common.TYPE_STRING | Common.TYPE_KEY,
64             String JavaDoc.class);
65         this.createAttribute(CONSTRAINT_FIELD_VALUE, "match-expr", "MatchExpr",
66                         AttrProp.CDATA,
67                         null, "equals");
68         this.createAttribute(CONSTRAINT_FIELD_VALUE, "cache-on-match", "CacheOnMatch",
69                         AttrProp.CDATA,
70                         null, "true");
71         this.createAttribute(CONSTRAINT_FIELD_VALUE, "cache-on-match-failure", "CacheOnMatchFailure",
72                         AttrProp.CDATA,
73                         null, "false");
74         this.initialize(options);
75     }
76
77     // Setting the default values of the properties
78
void initialize(int options)
79     {
80         
81     }
82
83     // This attribute is mandatory
84
public void setName(java.lang.String JavaDoc value) {
85         setAttributeValue(NAME, value);
86     }
87
88     //
89
public java.lang.String JavaDoc getName() {
90         return getAttributeValue(NAME);
91     }
92
93     // This attribute is mandatory
94
public void setScope(java.lang.String JavaDoc value) {
95         setAttributeValue(SCOPE, value);
96     }
97
98     //
99
public java.lang.String JavaDoc getScope() {
100         return getAttributeValue(SCOPE);
101     }
102
103     // This attribute is mandatory
104
public void setCacheOnMatch(java.lang.String JavaDoc value) {
105         setAttributeValue(CACHEONMATCH, value);
106     }
107
108     //
109
public java.lang.String JavaDoc getCacheOnMatch() {
110         return getAttributeValue(CACHEONMATCH);
111     }
112
113     // This attribute is mandatory
114
public void setCacheOnMatchFailure(java.lang.String JavaDoc value) {
115         setAttributeValue(CACHEONMATCHFAILURE, value);
116     }
117
118     //
119
public java.lang.String JavaDoc getCacheOnMatchFailure() {
120         return getAttributeValue(CACHEONMATCHFAILURE);
121     }
122
123     // This attribute is an array, possibly empty
124
public void setConstraintFieldValue(int index, String JavaDoc value) {
125         this.setValue(CONSTRAINT_FIELD_VALUE, index, value);
126     }
127
128     //
129
public String JavaDoc getConstraintFieldValue(int index) {
130         return (String JavaDoc)this.getValue(CONSTRAINT_FIELD_VALUE, index);
131     }
132
133     // This attribute is an array, possibly empty
134
public void setConstraintFieldValue(String JavaDoc[] value) {
135         this.setValue(CONSTRAINT_FIELD_VALUE, value);
136     }
137
138     //
139
public String JavaDoc[] getConstraintFieldValue() {
140         return (String JavaDoc[])this.getValues(CONSTRAINT_FIELD_VALUE);
141     }
142
143     // Return the number of properties
144
public int sizeConstraintFieldValue() {
145         return this.size(CONSTRAINT_FIELD_VALUE);
146     }
147
148     // Add a new element returning its index in the list
149
public int addConstraintFieldValue(String JavaDoc value) {
150         return this.addValue(CONSTRAINT_FIELD_VALUE, value);
151     }
152
153     //
154
// Remove an element using its reference
155
// Returns the index the element had in the list
156
//
157
public int removeConstraintFieldValue(String JavaDoc value) {
158         return this.removeValue(CONSTRAINT_FIELD_VALUE, value);
159     }
160
161     // This attribute is an array, possibly empty
162
public void setConstraintFieldValueMatchExpr(int index, java.lang.String JavaDoc value) {
163         // Make sure we've got a place to put this attribute.
164
if (size(CONSTRAINT_FIELD_VALUE) == 0) {
165             addValue(CONSTRAINT_FIELD_VALUE, "");
166         }
167         setAttributeValue(CONSTRAINT_FIELD_VALUE, index, "MatchExpr", value);
168     }
169
170     //
171
public java.lang.String JavaDoc getConstraintFieldValueMatchExpr(int index) {
172         // If our element does not exist, then the attribute does not exist.
173
if (size(CONSTRAINT_FIELD_VALUE) == 0) {
174             return null;
175         } else {
176             return getAttributeValue(CONSTRAINT_FIELD_VALUE, index, "MatchExpr");
177         }
178     }
179
180     // This attribute is an array, possibly empty
181
public void setConstraintFieldValueCacheOnMatch(int index, java.lang.String JavaDoc value) {
182         // Make sure we've got a place to put this attribute.
183
if (size(CONSTRAINT_FIELD_VALUE) == 0) {
184             addValue(CONSTRAINT_FIELD_VALUE, "");
185         }
186         setAttributeValue(CONSTRAINT_FIELD_VALUE, index, "CacheOnMatch", value);
187     }
188
189     //
190
public java.lang.String JavaDoc getConstraintFieldValueCacheOnMatch(int index) {
191         // If our element does not exist, then the attribute does not exist.
192
if (size(CONSTRAINT_FIELD_VALUE) == 0) {
193             return null;
194         } else {
195             return getAttributeValue(CONSTRAINT_FIELD_VALUE, index, "CacheOnMatch");
196         }
197     }
198
199     // This attribute is an array, possibly empty
200
public void setConstraintFieldValueCacheOnMatchFailure(int index, java.lang.String JavaDoc value) {
201         // Make sure we've got a place to put this attribute.
202
if (size(CONSTRAINT_FIELD_VALUE) == 0) {
203             addValue(CONSTRAINT_FIELD_VALUE, "");
204         }
205         setAttributeValue(CONSTRAINT_FIELD_VALUE, index, "CacheOnMatchFailure", value);
206     }
207
208     //
209
public java.lang.String JavaDoc getConstraintFieldValueCacheOnMatchFailure(int index) {
210         // If our element does not exist, then the attribute does not exist.
211
if (size(CONSTRAINT_FIELD_VALUE) == 0) {
212             return null;
213         } else {
214             return getAttributeValue(CONSTRAINT_FIELD_VALUE, index, "CacheOnMatchFailure");
215         }
216     }
217
218     //
219
public static void addComparator(org.netbeans.modules.schema2beans.BeanComparator c) {
220         comparators.add(c);
221     }
222
223     //
224
public static void removeComparator(org.netbeans.modules.schema2beans.BeanComparator c) {
225         comparators.remove(c);
226     }
227     public void validate() throws org.netbeans.modules.schema2beans.ValidateException {
228         boolean restrictionFailure = false;
229         // Validating property name
230
if (getName() == null) {
231             throw new org.netbeans.modules.schema2beans.ValidateException("getName() == null", "name", this); // NOI18N
232
}
233         // Validating property scope
234
if (getScope() == null) {
235             throw new org.netbeans.modules.schema2beans.ValidateException("getScope() == null", "scope", this); // NOI18N
236
}
237         // Validating property cacheOnMatch
238
if (getCacheOnMatch() == null) {
239             throw new org.netbeans.modules.schema2beans.ValidateException("getCacheOnMatch() == null", "cacheOnMatch", this); // NOI18N
240
}
241         // Validating property cacheOnMatchFailure
242
if (getCacheOnMatchFailure() == null) {
243             throw new org.netbeans.modules.schema2beans.ValidateException("getCacheOnMatchFailure() == null", "cacheOnMatchFailure", this); // NOI18N
244
}
245         // Validating property constraintFieldValue
246
for (int _index = 0; _index < sizeConstraintFieldValue();
247             ++_index) {
248             String JavaDoc element = getConstraintFieldValue(_index);
249             if (element != null) {
250             }
251         }
252         // Validating property constraintFieldValueMatchExpr
253
// Validating property constraintFieldValueCacheOnMatch
254
// Validating property constraintFieldValueCacheOnMatchFailure
255
}
256
257     // Dump the content of this bean returning it as a String
258
public void dump(StringBuffer JavaDoc str, String JavaDoc indent){
259         String JavaDoc s;
260         Object JavaDoc o;
261         org.netbeans.modules.schema2beans.BaseBean n;
262         str.append(indent);
263         str.append("ConstraintFieldValue["+this.sizeConstraintFieldValue()+"]"); // NOI18N
264
for(int i=0; i<this.sizeConstraintFieldValue(); i++)
265         {
266             str.append(indent+"\t");
267             str.append("#"+i+":");
268             str.append(indent+"\t"); // NOI18N
269
str.append("<"); // NOI18N
270
s = this.getConstraintFieldValue(i);
271             str.append((s==null?"null":s.trim())); // NOI18N
272
str.append(">\n"); // NOI18N
273
this.dumpAttributes(CONSTRAINT_FIELD_VALUE, i, str, indent);
274         }
275
276     }
277     public String JavaDoc dumpBeanNode(){
278         StringBuffer JavaDoc str = new StringBuffer JavaDoc();
279         str.append("ConstraintField\n"); // NOI18N
280
this.dump(str, "\n "); // NOI18N
281
return str.toString();
282     }}
283
284 // END_NOI18N
285

286
287 /*
288         The following schema file has been used for generation:
289
290 <!--
291   XML DTD for Sun ONE Application Server specific Web Application
292   deployment descriptor. This is a companion DTD for web-app_2_4.xsd
293
294   $Revision: 1.3 $
295 -->
296
297 <!-- root element for vendor specific web application (module) configuration -->
298 <!ELEMENT sun-web-app (context-root?, security-role-mapping*, servlet*, session-config?,
299                        ejb-ref*, resource-ref*, resource-env-ref*, service-ref*,
300                        cache?, class-loader?,
301                        jsp-config?, locale-charset-info?, property*,
302                    message-destination*, webservice-description*)>
303
304 <!--
305  Context Root for the web application when the war file is a standalone module.
306  When the war module is part of the J2EE Application, use the application.xml
307 -->
308 <!ELEMENT context-root (#PCDATA)>
309
310 <!ELEMENT security-role-mapping (role-name, (principal-name | group-name)+)>
311 <!ELEMENT role-name (#PCDATA)>
312
313 <!ELEMENT principal-name (#PCDATA)>
314 <!ELEMENT group-name (#PCDATA)>
315
316 <!ELEMENT servlet (servlet-name, principal-name?, webservice-endpoint*)>
317
318 <!ELEMENT session-config (session-manager?, session-properties?, cookie-properties?)>
319
320 <!ELEMENT session-manager (manager-properties?, store-properties?)>
321 <!ATTLIST session-manager persistence-type CDATA "memory">
322
323 <!ELEMENT manager-properties (property*)>
324 <!ELEMENT store-properties (property*)>
325 <!ELEMENT session-properties (property*)>
326 <!ELEMENT cookie-properties (property*)>
327
328 <!ELEMENT jndi-name (#PCDATA)>
329
330 <!ELEMENT resource-env-ref (resource-env-ref-name, jndi-name)>
331 <!ELEMENT resource-env-ref-name (#PCDATA)>
332            
333 <!ELEMENT resource-ref (res-ref-name, jndi-name, default-resource-principal?)>
334 <!ELEMENT res-ref-name (#PCDATA)>
335
336 <!ELEMENT default-resource-principal ( name, password)>
337
338 <!--
339 This node holds information about a logical message destination
340 -->
341 <!ELEMENT message-destination (message-destination-name, jndi-name)>
342
343 <!--
344 This node holds the name of a logical message destination
345 -->
346 <!ELEMENT message-destination-name (#PCDATA)>
347
348 <!--
349 This text nodes holds a name string.
350 -->
351 <!ELEMENT name (#PCDATA)>
352
353 <!--
354 This element holds password text.
355 -->
356 <!ELEMENT password (#PCDATA)>
357
358
359 <!ELEMENT ejb-ref (ejb-ref-name, jndi-name)>
360 <!ELEMENT ejb-ref-name (#PCDATA)>
361
362 <!-- cache element configures the cache for web application. iAS 7.0 web container
363      supports one such cache object per application: i.e. <cache> is a sub element
364      of <ias-web-app>. A cache can have zero or more cache-mapping elements and
365      zero or more customizable cache-helper classes.
366                                                                                    
367         max-entries Maximum number of entries this cache may hold. [4096]
368         timeout-in-seconds Default timeout for the cache entries in seconds. [30]
369         enabled Is this cache enabled? [false]
370 -->
371 <!ELEMENT cache (cache-helper*, default-helper?, property*, cache-mapping*)>
372 <!ATTLIST cache max-entries CDATA "4096"
373                  timeout-in-seconds CDATA "30"
374                  enabled CDATA "false">
375
376 <!-- cache-helper specifies customizable class which implements CacheHelper interface.
377
378      name Unique name for the helper class; this is referenced in
379                               the cache-mapping elements (see below).
380                               "default" is reserved for the built-in default helper.
381      class-name Fully qualified class name of the cache-helper; this class
382                               must extend the com.sun.appserv.web.CacheHelper class.
383 -->
384 <!ELEMENT cache-helper (property*)>
385 <!ATTLIST cache-helper name CDATA #REQUIRED
386                        class-name CDATA #REQUIRED>
387
388 <!--
389 Default, built-in cache-helper properties
390 -->
391 <!ELEMENT default-helper (property*)>
392
393 <!--
394 cache-mapping element defines what to be cached, the key to be used, any other
395 constraints to be applied and a customizable cache-helper to programmatically
396 hook this information.
397 -->
398 <!ELEMENT cache-mapping ((servlet-name | url-pattern),
399                         (cache-helper-ref |
400                         (timeout?, refresh-field?, http-method*, key-field*, constraint-field*)))>
401
402 <!--
403 servlet-name element defines a named servlet to which this caching is enabled.
404 the specified name must be present in the web application deployment descriptor
405 (web.xml)
406 -->
407 <!ELEMENT servlet-name (#PCDATA)>
408
409 <!--
410 url-pattern element specifies the url pattern to which caching is to be enabled.
411 See Servlet 2.3 specification section SRV. 11.2 for the applicable patterns.
412 -->
413 <!ELEMENT url-pattern (#PCDATA)>
414
415 <!--
416 cache-helper-ref s a reference to the cache-helper used by this cache-mapping
417 -->
418 <!ELEMENT cache-helper-ref (#PCDATA)>
419
420 <!--
421 timeout element defines the cache timeout in seconds applicable for this mapping.
422 default is to use cache object's timeout. The timeout value is specified statically
423 ere (e.g. <timeout> 60 </timeout> or dynamically via fields in the relevant scope.
424
425    name Name of the field where this timeout could be found
426    scope Scope of the field. default scope is request attribute.
427 -->
428 <!ELEMENT timeout (#PCDATA)>
429 <!ATTLIST timeout name CDATA #REQUIRED
430                    scope CDATA 'request.attribute'>
431
432 <!--
433 http-method specifies HTTP method eligible for caching default is GET.
434 -->
435 <!ELEMENT http-method (#PCDATA)>
436
437 <!--
438 specifies the request parameter name that triggers refresh. the cached entry
439 is refreshed when there such a request parameter is set to "true"
440 example:
441 <cache-mapping>
442     <url-pattern> /quote </url-pattern>
443     <refresh-field name="refresh" scope="request.parameter"/>
444 </cache-mapping>
445 -->
446 <!ELEMENT refresh-field EMPTY>
447 <!ATTLIST refresh-field name CDATA #REQUIRED
448                         scope CDATA 'request.parameter'>
449 <!--
450 key-field specifies a component of the key; container looks for the named
451 field in the given scope to access the cached entry. Default is to use
452 the Servlet Path (the path section that corresponds to the servlet mapping
453 which activated this request). See Servlet 2.3 specification section SRV 4.4
454 on Servlet Path.
455
456   name Name of the field to look for in the given scope
457   scope Scope of the field. default scope is request parameter.
458 -->
459 <!ELEMENT key-field EMPTY>
460 <!ATTLIST key-field name CDATA #REQUIRED
461                     scope CDATA 'request.parameter'>
462
463 <!--
464 constraint-field specifies a field whose value is used as a cacheability constraint.
465   
466   name Name of the field to look for in the given scope
467   scope Scope of the field. Default scope is request parameter.
468   cache-on-match Should this constraint check pass, is the response cacheable?
469                            Default is true (i.e. cache the response on success match).
470                            Useful to turn off caching when there is an attribute in the
471                            scope (e.g. don't cache when there is an attribute called UID
472                            in the session.attribute scope).
473   cache-on-match-failure Should the constraint check fail, is response not cacheable?
474                            Default is false (i.e. a failure in enforcing the constraint
475                            would negate caching). Useful to turn on caching when the
476                            an an attribute is not present (e.g. turn on caching
477                            when there is no session or session attribute called UID).
478
479   Example 1: don't cache when there is a session attribute
480   <constraint-field name="UID" scope="session.attribute" cache-on-match="false">
481
482   Example 2: do cache only when there is no session attribute
483   <constraint-field name="UID" scope="session.attribute"
484                     cache-on-match-failure="false">
485 -->
486 <!ELEMENT constraint-field (constraint-field-value*)>
487 <!ATTLIST constraint-field name CDATA #REQUIRED
488                             scope CDATA 'request.parameter'
489                             cache-on-match CDATA 'true'
490                             cache-on-match-failure CDATA 'false'>
491
492 <!--
493 value element specifies the applicable value and a matching expression for a constraint-field
494   match-expr Expression used to match the value. Default is 'equals'.
495
496   Example 1: cache when the category matches with any value other than a specific value
497   <constraint-field name="category" scope="request.parameter>
498     <value match-expr="equals" cache-on-match-failure="true">
499          bogus
500     </value>
501   </constraint-field>
502 -->
503 <!ELEMENT constraint-field-value (#PCDATA)>
504 <!ATTLIST constraint-field-value match-expr CDATA 'equals'
505                             cache-on-match CDATA 'true'
506                             cache-on-match-failure CDATA 'false'>
507
508 <!ELEMENT class-loader EMPTY>
509 <!ATTLIST class-loader extra-class-path CDATA #IMPLIED
510                        delegate CDATA 'true'>
511
512 <!ELEMENT jsp-config (property*)>
513
514 <!ELEMENT locale-charset-info (locale-charset-map+, parameter-encoding?)>
515 <!ATTLIST locale-charset-info default-locale CDATA #REQUIRED>
516
517 <!ELEMENT locale-charset-map (description?)>
518 <!ATTLIST locale-charset-map locale CDATA #REQUIRED
519                              agent CDATA #IMPLIED
520                              charset CDATA #REQUIRED>
521
522 <!ELEMENT parameter-encoding EMPTY>
523 <!ATTLIST parameter-encoding form-hint-field CDATA #IMPLIED
524                  default-charset CDATA #IMPLIED>
525
526 <!--
527 Syntax for supplying properties as name value pairs
528 -->
529 <!ELEMENT property (description?)>
530 <!ATTLIST property name CDATA #REQUIRED
531                    value CDATA #REQUIRED>
532
533 <!ELEMENT description (#PCDATA)>
534
535 <!--
536 This text nodes holds a value string.
537 -->
538 <!ELEMENT value (#PCDATA)>
539
540
541 <!--
542                     W E B S E R V I C E S
543 -->
544 <!--
545 Runtime settings for a web service reference. In the simplest case,
546 there is no runtime information required for a service ref. Runtime info
547 is only needed in the following cases :
548  * to define the port that should be used to resolve a container-managed port
549  * to define default Stub/Call property settings for Stub objects
550  * to define the URL of a final WSDL document to be used instead of
551 the one packaged with a service-ref
552 -->
553 <!ELEMENT service-ref ( service-ref-name, port-info*, call-property*, wsdl-override?, service-impl-class?, service-qname? )>
554
555 <!--
556 Coded name (relative to java:comp/env) for a service-reference
557 -->
558 <!ELEMENT service-ref-name ( #PCDATA )>
559
560 <!--
561 Information for a port within a service-reference.
562
563 Either service-endpoint-interface or wsdl-port or both
564 (service-endpoint-interface and wsdl-port) should be specified.
565
566 If both are specified, wsdl-port represents the
567 port the container should choose for container-managed port selection.
568
569 The same wsdl-port value must not appear in
570 more than one port-info entry within the same service-ref.
571
572 If a particular service-endpoint-interface is using container-managed port
573 selection, it must not appear in more than one port-info entry
574 within the same service-ref.
575
576 -->
577 <!ELEMENT port-info ( service-endpoint-interface?, wsdl-port?, stub-property*, call-property* )>
578
579 <!--
580 Fully qualified name of service endpoint interface
581 -->
582 <!ELEMENT service-endpoint-interface ( #PCDATA )>
583 <!--
584 Port used in port-info.
585 -->
586 <!ELEMENT wsdl-port ( namespaceURI, localpart )>
587
588 <!--
589 JAXRPC property values that should be set on a stub before it's returned to
590 to the web service client. The property names can be any properties supported
591 by the JAXRPC Stub implementation. See javadoc for javax.xml.rpc.Stub
592 -->
593 <!ELEMENT stub-property ( name, value )>
594
595 <!--
596 JAXRPC property values that should be set on a Call object before it's
597 returned to the web service client. The property names can be any
598 properties supported by the JAXRPC Call implementation. See javadoc
599 for javax.xml.rpc.Call
600 -->
601 <!ELEMENT call-property ( name, value )>
602
603 <!--
604 This is a valid URL pointing to a final WSDL document. It is optional.
605 If specified, the WSDL document at this URL will be used during
606 deployment instead of the WSDL document associated with the
607 service-ref in the standard deployment descriptor.
608
609 Examples :
610
611   // available via HTTP
612   <wsdl-override>http://localhost:8000/myservice/myport?WSDL</wsdl-override>
613
614   // in a file
615   <wsdl-override>file:/home/user1/myfinalwsdl.wsdl</wsdl-override>
616
617 -->
618 <!ELEMENT wsdl-override ( #PCDATA )>
619
620 <!--
621 Name of generated service implementation class. This is not set by the
622 deployer. It is derived during deployment.
623 -->
624 <!ELEMENT service-impl-class ( #PCDATA )>
625
626 <!--
627 The service-qname element declares the specific WSDL service
628 element that is being refered to. It is not set by the deployer.
629 It is derived during deployment.
630 -->
631 <!ELEMENT service-qname (namespaceURI, localpart)>
632
633 <!--
634 Runtime information about a web service.
635
636 wsdl-publish-location is optionally used to specify
637 where the final wsdl and any dependent files should be stored. This location
638 resides on the file system from which deployment is initiated.
639
640 -->
641 <!ELEMENT webservice-description ( webservice-description-name, wsdl-publish-location? )>
642
643 <!--
644 Unique name of a webservice within a module
645 -->
646 <!ELEMENT webservice-description-name ( #PCDATA )>
647
648 <!--
649 file: URL of a directory to which a web-service-description's wsdl should be
650 published during deployment. Any required files will be published to this
651 directory, preserving their location relative to the module-specific
652 wsdl directory(META-INF/wsdl or WEB-INF/wsdl).
653
654 Example :
655
656   For an ejb.jar whose webservices.xml wsdl-file element contains
657     META-INF/wsdl/a/Foo.wsdl
658
659   <wsdl-publish-location>file:/home/user1/publish
660   </wsdl-publish-location>
661
662   The final wsdl will be stored in /home/user1/publish/a/Foo.wsdl
663
664 -->
665 <!ELEMENT wsdl-publish-location ( #PCDATA )>
666
667 <!--
668 Information about a web service endpoint.
669 -->
670 <!ELEMENT webservice-endpoint ( port-component-name, endpoint-address-uri?, login-config?, transport-guarantee?, service-qname?, tie-class?, servlet-impl-class? )>
671
672 <!--
673 Unique name of a port component within a module
674 -->
675 <!ELEMENT port-component-name ( #PCDATA )>
676
677 <!--
678 Relative path combined with web server root to form fully qualified
679 endpoint address for a web service endpoint. For servlet endpoints, this
680 value is relative to the servlet's web application context root. In
681 all cases, this value must be a fixed pattern(i.e. no "*" allowed).
682 If the web service endpoint is a servlet that only implements a single
683 endpoint has only one url-pattern, it is not necessary to set
684 this value since the container can derive it from web.xml.
685 -->
686 <!ELEMENT endpoint-address-uri ( #PCDATA )>
687
688 <!--
689 The name of tie implementation class for a port-component. This is
690 not specified by the deployer. It is derived during deployment.
691 -->
692 <!ELEMENT tie-class (#PCDATA)>
693
694 <!--
695 Optional authentication configuration for an EJB web service endpoint.
696 Not needed for servet web service endpoints. Their security configuration
697 is contained in the standard web application descriptor.
698 -->
699 <!ELEMENT login-config ( auth-method )>
700
701 <!--
702 The auth-method element is used to configure the authentication
703 mechanism for the web application. As a prerequisite to gaining access
704 to any web resources which are protected by an authorization
705 constraint, a user must have authenticated using the configured
706 mechanism.
707 -->
708
709 <!ELEMENT auth-method (#PCDATA)>
710
711 <!--
712 Name of application-written servlet impl class contained in deployed war.
713 This is not set by the deployer. It is derived by the container
714 during deployment.
715 -->
716 <!ELEMENT servlet-impl-class (#PCDATA)>
717
718 <!--
719 The transport-guarantee element specifies that the communication
720 between client and server should be NONE, INTEGRAL, or
721 CONFIDENTIAL. NONE means that the application does not require any
722 transport guarantees. A value of INTEGRAL means that the application
723 requires that the data sent between the client and server be sent in
724 such a way that it can't be changed in transit. CONFIDENTIAL means
725 that the application requires that the data be transmitted in a
726 fashion that prevents other entities from observing the contents of
727 the transmission. In most cases, the presence of the INTEGRAL or
728 CONFIDENTIAL flag will indicate that the use of SSL is required.
729 -->
730
731 <!ELEMENT transport-guarantee (#PCDATA)>
732
733 <!--
734 Runtime settings for a web service reference. In the simplest case,
735 there is no runtime information required for a service ref. Runtime info
736 is only needed in the following cases :
737  * to define the port that should be used to resolve a container-managed port
738  * to define default Stub/Call property settings for Stub objects
739  * to define the URL of a final WSDL document to be used instead of
740 the one packaged with a service-ref
741 -->
742
743 <!--
744 The localpart element indicates the local part of a QNAME.
745 -->
746 <!ELEMENT localpart (#PCDATA)>
747
748 <!--
749 The namespaceURI element indicates a URI.
750 -->
751 <!ELEMENT namespaceURI (#PCDATA)>
752
753 */

754
Popular Tags