KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > sun > enterprise > config > serverbeans > ConnectorConnectionPool


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 ConnectorConnectionPool matches the DTD element connector-connection-pool
26  *
27  */

28
29 package com.sun.enterprise.config.serverbeans;
30
31 import org.w3c.dom.*;
32 import org.netbeans.modules.schema2beans.*;
33 import java.beans.*;
34 import java.util.*;
35 import java.io.Serializable JavaDoc;
36 import com.sun.enterprise.config.ConfigBean;
37 import com.sun.enterprise.config.ConfigException;
38 import com.sun.enterprise.config.StaleWriteConfigException;
39 import com.sun.enterprise.util.i18n.StringManager;
40
41 // BEGIN_NOI18N
42

43 public class ConnectorConnectionPool extends ConfigBean implements Serializable JavaDoc
44 {
45
46     static Vector comparators = new Vector();
47     private static final org.netbeans.modules.schema2beans.Version runtimeVersion = new org.netbeans.modules.schema2beans.Version(4, 2, 0);
48
49     static public final String JavaDoc DESCRIPTION = "Description";
50     static public final String JavaDoc SECURITY_MAP = "SecurityMap";
51     static public final String JavaDoc ELEMENT_PROPERTY = "ElementProperty";
52
53     public ConnectorConnectionPool() {
54         this(Common.USE_DEFAULT_VALUES);
55     }
56
57     public ConnectorConnectionPool(int options)
58     {
59         super(comparators, runtimeVersion);
60         // Properties (see root bean comments for the bean graph)
61
initPropertyTables(3);
62         this.createProperty("description", DESCRIPTION,
63             Common.TYPE_0_1 | Common.TYPE_STRING | Common.TYPE_KEY,
64             String JavaDoc.class);
65         this.createProperty("security-map", SECURITY_MAP,
66             Common.TYPE_0_N | Common.TYPE_BEAN | Common.TYPE_KEY,
67             SecurityMap.class);
68         this.createAttribute(SECURITY_MAP, "name", "Name",
69                         AttrProp.CDATA | AttrProp.REQUIRED,
70                         null, null);
71         this.createProperty("property", ELEMENT_PROPERTY,
72             Common.TYPE_0_N | Common.TYPE_BEAN | Common.TYPE_KEY,
73             ElementProperty.class);
74         this.createAttribute(ELEMENT_PROPERTY, "name", "Name",
75                         AttrProp.CDATA | AttrProp.REQUIRED,
76                         null, null);
77         this.createAttribute(ELEMENT_PROPERTY, "value", "Value",
78                         AttrProp.CDATA | AttrProp.REQUIRED,
79                         null, null);
80         this.initialize(options);
81     }
82
83     // Setting the default values of the properties
84
void initialize(int options) {
85
86     }
87
88     /**
89     * Return the Description of the Element connector-connection-pool
90     */

91     public String JavaDoc getDescription() {
92         return (String JavaDoc) getValue(ServerTags.DESCRIPTION);
93     }
94     /**
95     * Modify the Description of the Element connector-connection-pool
96     * @param v the new value
97     */

98     public void setDescription(String JavaDoc v){
99         setValue(ServerTags.DESCRIPTION, (null != v ? v.trim() : null));
100         }
101     // This attribute is an array, possibly empty
102
public void setSecurityMap(int index, SecurityMap value) {
103         this.setValue(SECURITY_MAP, index, value);
104     }
105
106     // Get Method
107
public SecurityMap getSecurityMap(int index) {
108         return (SecurityMap)this.getValue(SECURITY_MAP, index);
109     }
110
111     // This attribute is an array, possibly empty
112
public void setSecurityMap(SecurityMap[] value) {
113         this.setValue(SECURITY_MAP, value);
114     }
115
116     // Getter Method
117
public SecurityMap[] getSecurityMap() {
118         return (SecurityMap[])this.getValues(SECURITY_MAP);
119     }
120
121     // Return the number of properties
122
public int sizeSecurityMap() {
123         return this.size(SECURITY_MAP);
124     }
125
126     // Add a new element returning its index in the list
127
public int addSecurityMap(SecurityMap value)
128             throws ConfigException{
129         return addSecurityMap(value, true);
130     }
131
132     // Add a new element returning its index in the list with a boolean flag
133
public int addSecurityMap(SecurityMap value, boolean overwrite)
134             throws ConfigException{
135         SecurityMap old = getSecurityMapByName(value.getName());
136         if(old != null) {
137             throw new ConfigException(StringManager.getManager(ConnectorConnectionPool.class).getString("cannotAddDuplicate", "SecurityMap"));
138         }
139         return this.addValue(SECURITY_MAP, value, overwrite);
140     }
141
142     //
143
// Remove an element using its reference
144
// Returns the index the element had in the list
145
//
146
public int removeSecurityMap(SecurityMap value){
147         return this.removeValue(SECURITY_MAP, value);
148     }
149
150     //
151
// Remove an element using its reference
152
// Returns the index the element had in the list
153
// with boolean overwrite
154
//
155
public int removeSecurityMap(SecurityMap value, boolean overwrite)
156             throws StaleWriteConfigException{
157         return this.removeValue(SECURITY_MAP, value, overwrite);
158     }
159
160     public SecurityMap getSecurityMapByName(String JavaDoc id) {
161      if (null != id) { id = id.trim(); }
162     SecurityMap[] o = getSecurityMap();
163      if (o == null) return null;
164
165      for (int i=0; i < o.length; i++) {
166          if(o[i].getAttributeValue(Common.convertName(ServerTags.NAME)).equals(id)) {
167              return o[i];
168          }
169      }
170
171         return null;
172         
173     }
174     // This attribute is an array, possibly empty
175
public void setElementProperty(int index, ElementProperty value) {
176         this.setValue(ELEMENT_PROPERTY, index, value);
177     }
178
179     // Get Method
180
public ElementProperty getElementProperty(int index) {
181         return (ElementProperty)this.getValue(ELEMENT_PROPERTY, index);
182     }
183
184     // This attribute is an array, possibly empty
185
public void setElementProperty(ElementProperty[] value) {
186         this.setValue(ELEMENT_PROPERTY, value);
187     }
188
189     // Getter Method
190
public ElementProperty[] getElementProperty() {
191         return (ElementProperty[])this.getValues(ELEMENT_PROPERTY);
192     }
193
194     // Return the number of properties
195
public int sizeElementProperty() {
196         return this.size(ELEMENT_PROPERTY);
197     }
198
199     // Add a new element returning its index in the list
200
public int addElementProperty(ElementProperty value)
201             throws ConfigException{
202         return addElementProperty(value, true);
203     }
204
205     // Add a new element returning its index in the list with a boolean flag
206
public int addElementProperty(ElementProperty value, boolean overwrite)
207             throws ConfigException{
208         ElementProperty old = getElementPropertyByName(value.getName());
209         if(old != null) {
210             throw new ConfigException(StringManager.getManager(ConnectorConnectionPool.class).getString("cannotAddDuplicate", "ElementProperty"));
211         }
212         return this.addValue(ELEMENT_PROPERTY, value, overwrite);
213     }
214
215     //
216
// Remove an element using its reference
217
// Returns the index the element had in the list
218
//
219
public int removeElementProperty(ElementProperty value){
220         return this.removeValue(ELEMENT_PROPERTY, value);
221     }
222
223     //
224
// Remove an element using its reference
225
// Returns the index the element had in the list
226
// with boolean overwrite
227
//
228
public int removeElementProperty(ElementProperty value, boolean overwrite)
229             throws StaleWriteConfigException{
230         return this.removeValue(ELEMENT_PROPERTY, value, overwrite);
231     }
232
233     public ElementProperty getElementPropertyByName(String JavaDoc id) {
234      if (null != id) { id = id.trim(); }
235     ElementProperty[] o = getElementProperty();
236      if (o == null) return null;
237
238      for (int i=0; i < o.length; i++) {
239          if(o[i].getAttributeValue(Common.convertName(ServerTags.NAME)).equals(id)) {
240              return o[i];
241          }
242      }
243
244         return null;
245         
246     }
247     /**
248     * Getter for Name of the Element connector-connection-pool
249     * @return the Name of the Element connector-connection-pool
250     */

251     public String JavaDoc getName() {
252         return getAttributeValue(ServerTags.NAME);
253     }
254     /**
255     * Modify the Name of the Element connector-connection-pool
256     * @param v the new value
257     * @throws StaleWriteConfigException if overwrite is false and file changed on disk
258     */

259     public void setName(String JavaDoc v, boolean overwrite) throws StaleWriteConfigException {
260         setAttributeValue(ServerTags.NAME, v, overwrite);
261     }
262     /**
263     * Modify the Name of the Element connector-connection-pool
264     * @param v the new value
265     */

266     public void setName(String JavaDoc v) {
267         setAttributeValue(ServerTags.NAME, v);
268     }
269     /**
270     * Getter for ResourceAdapterName of the Element connector-connection-pool
271     * @return the ResourceAdapterName of the Element connector-connection-pool
272     */

273     public String JavaDoc getResourceAdapterName() {
274         return getAttributeValue(ServerTags.RESOURCE_ADAPTER_NAME);
275     }
276     /**
277     * Modify the ResourceAdapterName of the Element connector-connection-pool
278     * @param v the new value
279     * @throws StaleWriteConfigException if overwrite is false and file changed on disk
280     */

281     public void setResourceAdapterName(String JavaDoc v, boolean overwrite) throws StaleWriteConfigException {
282         setAttributeValue(ServerTags.RESOURCE_ADAPTER_NAME, v, overwrite);
283     }
284     /**
285     * Modify the ResourceAdapterName of the Element connector-connection-pool
286     * @param v the new value
287     */

288     public void setResourceAdapterName(String JavaDoc v) {
289         setAttributeValue(ServerTags.RESOURCE_ADAPTER_NAME, v);
290     }
291     /**
292     * Getter for ConnectionDefinitionName of the Element connector-connection-pool
293     * @return the ConnectionDefinitionName of the Element connector-connection-pool
294     */

295     public String JavaDoc getConnectionDefinitionName() {
296         return getAttributeValue(ServerTags.CONNECTION_DEFINITION_NAME);
297     }
298     /**
299     * Modify the ConnectionDefinitionName of the Element connector-connection-pool
300     * @param v the new value
301     * @throws StaleWriteConfigException if overwrite is false and file changed on disk
302     */

303     public void setConnectionDefinitionName(String JavaDoc v, boolean overwrite) throws StaleWriteConfigException {
304         setAttributeValue(ServerTags.CONNECTION_DEFINITION_NAME, v, overwrite);
305     }
306     /**
307     * Modify the ConnectionDefinitionName of the Element connector-connection-pool
308     * @param v the new value
309     */

310     public void setConnectionDefinitionName(String JavaDoc v) {
311         setAttributeValue(ServerTags.CONNECTION_DEFINITION_NAME, v);
312     }
313     /**
314     * Getter for SteadyPoolSize of the Element connector-connection-pool
315     * @return the SteadyPoolSize of the Element connector-connection-pool
316     */

317     public String JavaDoc getSteadyPoolSize() {
318         return getAttributeValue(ServerTags.STEADY_POOL_SIZE);
319     }
320     /**
321     * Modify the SteadyPoolSize of the Element connector-connection-pool
322     * @param v the new value
323     * @throws StaleWriteConfigException if overwrite is false and file changed on disk
324     */

325     public void setSteadyPoolSize(String JavaDoc v, boolean overwrite) throws StaleWriteConfigException {
326         setAttributeValue(ServerTags.STEADY_POOL_SIZE, v, overwrite);
327     }
328     /**
329     * Modify the SteadyPoolSize of the Element connector-connection-pool
330     * @param v the new value
331     */

332     public void setSteadyPoolSize(String JavaDoc v) {
333         setAttributeValue(ServerTags.STEADY_POOL_SIZE, v);
334     }
335     /**
336     * Get the default value of SteadyPoolSize from dtd
337     */

338     public static String JavaDoc getDefaultSteadyPoolSize() {
339         return "8".trim();
340     }
341     /**
342     * Getter for MaxPoolSize of the Element connector-connection-pool
343     * @return the MaxPoolSize of the Element connector-connection-pool
344     */

345     public String JavaDoc getMaxPoolSize() {
346         return getAttributeValue(ServerTags.MAX_POOL_SIZE);
347     }
348     /**
349     * Modify the MaxPoolSize of the Element connector-connection-pool
350     * @param v the new value
351     * @throws StaleWriteConfigException if overwrite is false and file changed on disk
352     */

353     public void setMaxPoolSize(String JavaDoc v, boolean overwrite) throws StaleWriteConfigException {
354         setAttributeValue(ServerTags.MAX_POOL_SIZE, v, overwrite);
355     }
356     /**
357     * Modify the MaxPoolSize of the Element connector-connection-pool
358     * @param v the new value
359     */

360     public void setMaxPoolSize(String JavaDoc v) {
361         setAttributeValue(ServerTags.MAX_POOL_SIZE, v);
362     }
363     /**
364     * Get the default value of MaxPoolSize from dtd
365     */

366     public static String JavaDoc getDefaultMaxPoolSize() {
367         return "32".trim();
368     }
369     /**
370     * Getter for MaxWaitTimeInMillis of the Element connector-connection-pool
371     * @return the MaxWaitTimeInMillis of the Element connector-connection-pool
372     */

373     public String JavaDoc getMaxWaitTimeInMillis() {
374         return getAttributeValue(ServerTags.MAX_WAIT_TIME_IN_MILLIS);
375     }
376     /**
377     * Modify the MaxWaitTimeInMillis of the Element connector-connection-pool
378     * @param v the new value
379     * @throws StaleWriteConfigException if overwrite is false and file changed on disk
380     */

381     public void setMaxWaitTimeInMillis(String JavaDoc v, boolean overwrite) throws StaleWriteConfigException {
382         setAttributeValue(ServerTags.MAX_WAIT_TIME_IN_MILLIS, v, overwrite);
383     }
384     /**
385     * Modify the MaxWaitTimeInMillis of the Element connector-connection-pool
386     * @param v the new value
387     */

388     public void setMaxWaitTimeInMillis(String JavaDoc v) {
389         setAttributeValue(ServerTags.MAX_WAIT_TIME_IN_MILLIS, v);
390     }
391     /**
392     * Get the default value of MaxWaitTimeInMillis from dtd
393     */

394     public static String JavaDoc getDefaultMaxWaitTimeInMillis() {
395         return "60000".trim();
396     }
397     /**
398     * Getter for PoolResizeQuantity of the Element connector-connection-pool
399     * @return the PoolResizeQuantity of the Element connector-connection-pool
400     */

401     public String JavaDoc getPoolResizeQuantity() {
402         return getAttributeValue(ServerTags.POOL_RESIZE_QUANTITY);
403     }
404     /**
405     * Modify the PoolResizeQuantity of the Element connector-connection-pool
406     * @param v the new value
407     * @throws StaleWriteConfigException if overwrite is false and file changed on disk
408     */

409     public void setPoolResizeQuantity(String JavaDoc v, boolean overwrite) throws StaleWriteConfigException {
410         setAttributeValue(ServerTags.POOL_RESIZE_QUANTITY, v, overwrite);
411     }
412     /**
413     * Modify the PoolResizeQuantity of the Element connector-connection-pool
414     * @param v the new value
415     */

416     public void setPoolResizeQuantity(String JavaDoc v) {
417         setAttributeValue(ServerTags.POOL_RESIZE_QUANTITY, v);
418     }
419     /**
420     * Get the default value of PoolResizeQuantity from dtd
421     */

422     public static String JavaDoc getDefaultPoolResizeQuantity() {
423         return "2".trim();
424     }
425     /**
426     * Getter for IdleTimeoutInSeconds of the Element connector-connection-pool
427     * @return the IdleTimeoutInSeconds of the Element connector-connection-pool
428     */

429     public String JavaDoc getIdleTimeoutInSeconds() {
430         return getAttributeValue(ServerTags.IDLE_TIMEOUT_IN_SECONDS);
431     }
432     /**
433     * Modify the IdleTimeoutInSeconds of the Element connector-connection-pool
434     * @param v the new value
435     * @throws StaleWriteConfigException if overwrite is false and file changed on disk
436     */

437     public void setIdleTimeoutInSeconds(String JavaDoc v, boolean overwrite) throws StaleWriteConfigException {
438         setAttributeValue(ServerTags.IDLE_TIMEOUT_IN_SECONDS, v, overwrite);
439     }
440     /**
441     * Modify the IdleTimeoutInSeconds of the Element connector-connection-pool
442     * @param v the new value
443     */

444     public void setIdleTimeoutInSeconds(String JavaDoc v) {
445         setAttributeValue(ServerTags.IDLE_TIMEOUT_IN_SECONDS, v);
446     }
447     /**
448     * Get the default value of IdleTimeoutInSeconds from dtd
449     */

450     public static String JavaDoc getDefaultIdleTimeoutInSeconds() {
451         return "300".trim();
452     }
453     /**
454     * Getter for FailAllConnections of the Element connector-connection-pool
455     * @return the FailAllConnections of the Element connector-connection-pool
456     */

457     public boolean isFailAllConnections() {
458         return toBoolean(getAttributeValue(ServerTags.FAIL_ALL_CONNECTIONS));
459     }
460     /**
461     * Modify the FailAllConnections of the Element connector-connection-pool
462     * @param v the new value
463     * @throws StaleWriteConfigException if overwrite is false and file changed on disk
464     */

465     public void setFailAllConnections(boolean v, boolean overwrite) throws StaleWriteConfigException {
466         setAttributeValue(ServerTags.FAIL_ALL_CONNECTIONS, ""+(v==true), overwrite);
467     }
468     /**
469     * Modify the FailAllConnections of the Element connector-connection-pool
470     * @param v the new value
471     */

472     public void setFailAllConnections(boolean v) {
473         setAttributeValue(ServerTags.FAIL_ALL_CONNECTIONS, ""+(v==true));
474     }
475     /**
476     * Get the default value of FailAllConnections from dtd
477     */

478     public static String JavaDoc getDefaultFailAllConnections() {
479         return "false".trim();
480     }
481     /**
482     * Getter for TransactionSupport of the Element connector-connection-pool
483     * @return the TransactionSupport of the Element connector-connection-pool
484     */

485     public String JavaDoc getTransactionSupport() {
486             return getAttributeValue(ServerTags.TRANSACTION_SUPPORT);
487     }
488     /**
489     * Modify the TransactionSupport of the Element connector-connection-pool
490     * @param v the new value
491     * @throws StaleWriteConfigException if overwrite is false and file changed on disk
492     */

493     public void setTransactionSupport(String JavaDoc v, boolean overwrite) throws StaleWriteConfigException {
494         setAttributeValue(ServerTags.TRANSACTION_SUPPORT, v, overwrite);
495     }
496     /**
497     * Modify the TransactionSupport of the Element connector-connection-pool
498     * @param v the new value
499     */

500     public void setTransactionSupport(String JavaDoc v) {
501         setAttributeValue(ServerTags.TRANSACTION_SUPPORT, v);
502     }
503     /**
504     * Getter for IsConnectionValidationRequired of the Element connector-connection-pool
505     * @return the IsConnectionValidationRequired of the Element connector-connection-pool
506     */

507     public boolean isIsConnectionValidationRequired() {
508         return toBoolean(getAttributeValue(ServerTags.IS_CONNECTION_VALIDATION_REQUIRED));
509     }
510     /**
511     * Modify the IsConnectionValidationRequired of the Element connector-connection-pool
512     * @param v the new value
513     * @throws StaleWriteConfigException if overwrite is false and file changed on disk
514     */

515     public void setIsConnectionValidationRequired(boolean v, boolean overwrite) throws StaleWriteConfigException {
516         setAttributeValue(ServerTags.IS_CONNECTION_VALIDATION_REQUIRED, ""+(v==true), overwrite);
517     }
518     /**
519     * Modify the IsConnectionValidationRequired of the Element connector-connection-pool
520     * @param v the new value
521     */

522     public void setIsConnectionValidationRequired(boolean v) {
523         setAttributeValue(ServerTags.IS_CONNECTION_VALIDATION_REQUIRED, ""+(v==true));
524     }
525     /**
526     * Get the default value of IsConnectionValidationRequired from dtd
527     */

528     public static String JavaDoc getDefaultIsConnectionValidationRequired() {
529         return "false".trim();
530     }
531     /**
532      * Create a new bean using it's default constructor.
533      * This does not add it to any bean graph.
534      */

535     public SecurityMap newSecurityMap() {
536         return new SecurityMap();
537     }
538
539     /**
540      * Create a new bean using it's default constructor.
541      * This does not add it to any bean graph.
542      */

543     public ElementProperty newElementProperty() {
544         return new ElementProperty();
545     }
546
547     /**
548     * get the xpath representation for this element
549     * returns something like abc[@name='value'] or abc
550     * depending on the type of the bean
551     */

552     protected String JavaDoc getRelativeXPath() {
553         String JavaDoc ret = null;
554         ret = "connector-connection-pool" + (canHaveSiblings() ? "[@name='" + getAttributeValue("name") +"']" : "") ;
555         return (null != ret ? ret.trim() : null);
556     }
557
558     /*
559     * generic method to get default value from dtd
560     */

561     public static String JavaDoc getDefaultAttributeValue(String JavaDoc attr) {
562         if(attr == null) return null;
563         attr = attr.trim();
564         if(attr.equals(ServerTags.STEADY_POOL_SIZE)) return "8".trim();
565         if(attr.equals(ServerTags.MAX_POOL_SIZE)) return "32".trim();
566         if(attr.equals(ServerTags.MAX_WAIT_TIME_IN_MILLIS)) return "60000".trim();
567         if(attr.equals(ServerTags.POOL_RESIZE_QUANTITY)) return "2".trim();
568         if(attr.equals(ServerTags.IDLE_TIMEOUT_IN_SECONDS)) return "300".trim();
569         if(attr.equals(ServerTags.FAIL_ALL_CONNECTIONS)) return "false".trim();
570         if(attr.equals(ServerTags.IS_CONNECTION_VALIDATION_REQUIRED)) return "false".trim();
571     return null;
572     }
573     //
574
public static void addComparator(org.netbeans.modules.schema2beans.BeanComparator c) {
575         comparators.add(c);
576     }
577
578     //
579
public static void removeComparator(org.netbeans.modules.schema2beans.BeanComparator c) {
580         comparators.remove(c);
581     }
582     public void validate() throws org.netbeans.modules.schema2beans.ValidateException {
583     }
584
585     // Dump the content of this bean returning it as a String
586
public void dump(StringBuffer JavaDoc str, String JavaDoc indent){
587         String JavaDoc s;
588         Object JavaDoc o;
589         org.netbeans.modules.schema2beans.BaseBean n;
590         str.append(indent);
591         str.append("Description"); // NOI18N
592
str.append(indent+"\t"); // NOI18N
593
str.append("<"); // NOI18N
594
o = this.getDescription();
595         str.append((o==null?"null":o.toString().trim())); // NOI18N
596
str.append(">\n"); // NOI18N
597
this.dumpAttributes(DESCRIPTION, 0, str, indent);
598
599         str.append(indent);
600         str.append("SecurityMap["+this.sizeSecurityMap()+"]"); // NOI18N
601
for(int i=0; i<this.sizeSecurityMap(); i++)
602         {
603             str.append(indent+"\t");
604             str.append("#"+i+":");
605             n = (org.netbeans.modules.schema2beans.BaseBean) this.getSecurityMap(i);
606             if (n != null)
607                 n.dump(str, indent + "\t"); // NOI18N
608
else
609                 str.append(indent+"\tnull"); // NOI18N
610
this.dumpAttributes(SECURITY_MAP, i, str, indent);
611         }
612
613         str.append(indent);
614         str.append("ElementProperty["+this.sizeElementProperty()+"]"); // NOI18N
615
for(int i=0; i<this.sizeElementProperty(); i++)
616         {
617             str.append(indent+"\t");
618             str.append("#"+i+":");
619             n = (org.netbeans.modules.schema2beans.BaseBean) this.getElementProperty(i);
620             if (n != null)
621                 n.dump(str, indent + "\t"); // NOI18N
622
else
623                 str.append(indent+"\tnull"); // NOI18N
624
this.dumpAttributes(ELEMENT_PROPERTY, i, str, indent);
625         }
626
627     }
628     public String JavaDoc dumpBeanNode(){
629         StringBuffer JavaDoc str = new StringBuffer JavaDoc();
630         str.append("ConnectorConnectionPool\n"); // NOI18N
631
this.dump(str, "\n "); // NOI18N
632
return str.toString();
633     }}
634
635 // END_NOI18N
636

637
Popular Tags