Find Usages Diff Raw Download HTML Widget Stack Overflow Q&A
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
1. Constructor with all class properties or default constructor with setters?
Following are the two approaches: constructor with all the class properties Pros: I have to put an exact number of types of parameters so if I make an error the compiler warns me (by the way, is there a way to prevent the problem of having erroneously switched two Integer on the parameter list?) Cons: if I have lots of properties the instantiation line can become really long and it could ...
2. How can the type of a bean property be null?
In the book "Thinking in Java" there is an example of how to get information for a bean via Reflection/Introspection. BeanInfo bi = Introspector.getBeanInfo(Car.class, Object.class); for (PropertyDescriptor d: bi.getPropertyDescriptors()) { Class<?> p = d.getPropertyType(); if (p == null) continue; [...] } In line 4 of that sample above there is a check if the PropertyType is nul...
3. JavaBeans and introspection - messed up on boolean and indexed properties?
A former colleague of mine started a discussion half an hour ago about javabeans, and why they didn't quite work the way he wants in JSF. The particular case is about boolean properties. 1. For a boolean property named isUrl Eclipse generates this private boolean isUrl; public boolean isUrl() {..} public boolean setUrl(boolean url) {..} But this does not work in JSF. He made it work by add...
4. Does Java bean's setter permit return this?
can I define setter method to return this rather than void? Like: ClassA setItem1() { return this; } ClassA setItem2() { return this; } then I can use new ClassA().setItem1().setItem2()
5. Has the JavaBean spec been updated to reflect the existence of annotations
I thought this should be obvious but I can't find it. Now that fields can have annotations, I thought this should be reflected in the JavaBean spec, but I can't find it. What I mean: JavaBean is a specification that allows you to treat objects in an uniform way by discovering their properties, and then reading and writing them. As POJOs properties can now be annotated (as in Hibernate anno...
6. Get bean property getter or setter by reflection?
Suppose I have a handle on an object of type , and I'm told by configuration that it has a bean property of type int with the name age. How can I retrieve the getter for this document? Is there a better way than prepending "get" and capitalizing the "a" in age, and looking for a method of that name via reflection?
7. How to copy properties from one Java bean to another?
I have a simple Java POJO that I would copy properties to another instance of same POJO class. I know I can do that with BeanUtils.copyProperties() but I would like to avoid use of a third-party library. So, how to do that simply, the proper and safer way ? By the way, I'm using Java 6.
8. Add listener vs set listener
What is the difference between adding a listener and setting a listener. e.g. addTextChangedListener(textWatcher); setOnClickListener(clickListener); Answer: After aioobe's answer i have tested this in my project. So we can do this. editText.addTextChangedListener(textWatcher1); editText.addTextChangedListener(textWatcher2); but we can't do this.(It will set only the last listener in t...
9. What's the bean pattern name when used in other languages
Java has the concept of a "bean", which is a class with a no-arg constructor and getter/setter methods. Does this pattern have a more generic name so that, if we're talking to programmers who have never used Java, we can avoid using the term "bean"?
10. JSP custom tag attribute type integer
I want to create a custom tag library but in the handler class I would like to have integer attributes. In the tld file I have the following code: <tag> <name>circle</name> <tag-class>draw.Circle</tag-class> <body-content>jsp</body-content> <attribute> <name>x</name> <require...
11. How to get value from POJO using reflection?
I am just create a One generic method using Method Reflection API. In This Method I am trying to get a particulate method(getter method / setter method) value but I am stuck I don't know how to do this. I am Abel to get all the method Name using Method Reflection API but not Abel to get value of that method. So please help me. here is my code...... /* propertyNames List is contain...
12. Creating bean PropertyDescriptor using JRuby
I'm trying to port some java to jruby, and it uses a beans PropertyDescriptor. The original code is: new PropertyDescriptor("splitEvaluator", CrossValidationResultProducer.class) which I've tried to port to: PropertyDescriptor.new("splitEvaluator", CrossValidationResultProducer) However, I get the error: no constructor with arguments matching [class org.jruby.RubyString, class org.jruby....
13. Java Unified Expression Language sub-expressions
I have a datatable which provides objects from a list. Within this data table I would like to use a tag like p:columns(primefaces) which provides strings from a list that represent the name of a field. I will now need a subexpression to be able to use the dynamic field name like: #{entry.#[column.fieldName}} Is there any possibility to do this in JSF2?
14. Validation framework
In an interview my friend was asked to design a validation framework, can any one give me idea how to design a efficient framework Our approach was an interface having all method and class implementaion of all methods 
1
  /*
2
   * Copyright 1996-2004 Sun Microsystems, Inc.  All Rights Reserved.
3
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4
   *
5
   * This code is free software; you can redistribute it and/or modify it
6
   * under the terms of the GNU General Public License version 2 only, as
7
   * published by the Free Software Foundation.  Sun designates this
8
   * particular file as subject to the "Classpath" exception as provided
9
   * by Sun in the LICENSE file that accompanied this code.
10
  *
11
  * This code is distributed in the hope that it will be useful, but WITHOUT
12
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14
  * version 2 for more details (a copy is included in the LICENSE file that
15
  * accompanied this code).
16
  *
17
  * You should have received a copy of the GNU General Public License version
18
  * 2 along with this work; if not, write to the Free Software Foundation,
19
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20
  *
21
  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22
  * CA 95054 USA or visit www.sun.com if you need additional information or
23
  * have any questions.
24
  */
25
 
26
 package java.beans;
27
 
29
 
A PropertyDescriptor describes one property that a Java Bean exports via a pair of accessor methods. 
36
 
37
 public class PropertyDescriptor extends FeatureDescriptor {
38
 
39
     private Reference<Class> propertyTypeRef;
40
     private Reference<Method> readMethodRef;
41
     private Reference<Method> writeMethodRef;
43
 
44
     private boolean bound;
45
     private boolean constrained;
46
 
47
     // The base name of the method name which will be prefixed with the
48
     // read and write method. If name == "foo" then the baseName is "Foo"
49
     private String baseName;
50
 
51
     private String writeMethodName;
52
     private String readMethodName;

    
Constructs a PropertyDescriptor for a property that follows the standard Java convention by having getFoo and setFoo accessor methods. Thus if the argument name is "fred", it will assume that the writer method is "setFred" and the reader method is "getFred" (or "isFred" for a boolean property). Note that the property name should start with a lower case character, which will be capitalized in the method names.

Parameters:
propertyName The programmatic name of the property.
beanClass The Class object for the target bean. For example sun.beans.OurButton.class.
Throws:
IntrospectionException if an exception occurs during introspection.
68
 
69
     public PropertyDescriptor(String propertyName, Class<?> beanClass)
70
                 throws IntrospectionException {
71
         this(propertyName, beanClass,
72
              . + NameGenerator.capitalize(propertyName),
73
              . + NameGenerator.capitalize(propertyName));
74
     }

    
This constructor takes the name of a simple property, and method names for reading and writing the property.

Parameters:
propertyName The programmatic name of the property.
beanClass The Class object for the target bean. For example sun.beans.OurButton.class.
readMethodName The name of the method used for reading the property value. May be null if the property is write-only.
writeMethodName The name of the method used for writing the property value. May be null if the property is read-only.
Throws:
IntrospectionException if an exception occurs during introspection.
89
 
90
     public PropertyDescriptor(String propertyName, Class<?> beanClass,
91
                 String readMethodName, String writeMethodName)
92
                 throws IntrospectionException {
93
         if (beanClass == null) {
94
             throw new IntrospectionException("Target Bean class is null");
95
         }
96
         if (propertyName == null || propertyName.length() == 0) {
97
             throw new IntrospectionException("bad property name");
98
         }
99
         if ("".equals(readMethodName) || "".equals(writeMethodName)) {
100
            throw new IntrospectionException("read or write method name should not be the empty string");
101
        }
102
        setName(propertyName);
103
        setClass0(beanClass);
105
        this. = readMethodName;
106
        if (readMethodName != null && getReadMethod() == null) {
107
            throw new IntrospectionException("Method not found: " + readMethodName);
108
        }
109
        this. = writeMethodName;
110
        if (writeMethodName != null && getWriteMethod() == null) {
111
            throw new IntrospectionException("Method not found: " + writeMethodName);
112
        }
113
        // If this class or one of its base classes allow PropertyChangeListener,
114
        // then we assume that any properties we discover are "bound".
115
        // See Introspector.getTargetPropertyInfo() method.
116
        String name = "addPropertyChangeListener";
117
        Class[] args = {PropertyChangeListener.class};
118
        this. = (null != Introspector.findMethod(beanClass, name, args.length, args));
119
    }

    
This constructor takes the name of a simple property, and Method objects for reading and writing the property.

Parameters:
propertyName The programmatic name of the property.
readMethod The method used for reading the property value. May be null if the property is write-only.
writeMethod The method used for writing the property value. May be null if the property is read-only.
Throws:
IntrospectionException if an exception occurs during introspection.
133
    public PropertyDescriptor(String propertyName, Method readMethod, Method writeMethod)
134
                throws IntrospectionException {
135
        if (propertyName == null || propertyName.length() == 0) {
136
            throw new IntrospectionException("bad property name");
137
        }
138
        setName(propertyName);
139
        setReadMethod(readMethod);
140
        setWriteMethod(writeMethod);
141
    }

    
Creates PropertyDescriptor for the specified bean with the specified name and methods to read/write the property value.

Parameters:
bean the type of the target bean
base the base name of the property (the rest of the method name)
read the method used for reading the property value
write the method used for writing the property value
Throws:
IntrospectionException if an exception occurs during introspection
Since:
1.7
155
    PropertyDescriptor(Class<?> bean, String base, Method read, Method write) throws IntrospectionException {
156
        if (bean == null) {
157
            throw new IntrospectionException("Target Bean class is null");
158
        }
159
        setClass0(bean);
160
        setName(Introspector.decapitalize(base));
161
        setReadMethod(read);
162
        setWriteMethod(write);
163
        this. = base;
164
    }

    
Gets the Class object for the property.

Returns:
The Java type info for the property. Note that the "Class" object may describe a built-in Java type such as "int". The result may be "null" if this is an indexed property that does not support non-indexed access.

This is the type that will be returned by the ReadMethod.

176
    public synchronized Class<?> getPropertyType() {
177
        Class type = getPropertyType0();
178
        if (type  == null) {
179
            try {
180
                type = findPropertyType(getReadMethod(), getWriteMethod());
181
                setPropertyType(type);
182
            } catch (IntrospectionException ex) {
183
                // Fall
184
            }
185
        }
186
        return type;
187
    }
189
    private void setPropertyType(Class type) {
190
        this. = getWeakReference(type);
191
    }
193
    private Class getPropertyType0() {
194
        return (this. != null)
195
                ? this..get()
196
                : null;
197
    }

    
Gets the method that should be used to read the property value.

Returns:
The method that should be used to read the property value. May return null if the property can't be read.
205
    public synchronized Method getReadMethod() {
206
        Method readMethod = getReadMethod0();
207
        if (readMethod == null) {
208
            Class cls = getClass0();
209
            if (cls == null || ( == null &&  == null)) {
210
                // The read method was explicitly set to null.
211
                return null;
212
            }
213
            if ( == null) {
214
                Class type = getPropertyType0();
215
                if (type == boolean.class || type == null) {
216
                     = . + getBaseName();
217
                } else {
218
                     = . + getBaseName();
219
                }
220
            }
222
            // Since there can be multiple write methods but only one getter
223
            // method, find the getter method first so that you know what the
224
            // property type is.  For booleans, there can be "is" and "get"
225
            // methods.  If an "is" method exists, this is the official
226
            // reader method so look for this one first.
227
            readMethod = Introspector.findMethod(cls, , 0);
228
            if (readMethod == null) {
229
                 = . + getBaseName();
230
                readMethod = Introspector.findMethod(cls, , 0);
231
            }
232
            try {
233
                setReadMethod(readMethod);
234
            } catch (IntrospectionException ex) {
235
                // fall
236
            }
237
        }
238
        return readMethod;
239
    }

    
Sets the method that should be used to read the property value.

Parameters:
readMethod The new read method.
246
    public synchronized void setReadMethod(Method readMethod)
247
                                throws IntrospectionException {
248
        if (readMethod == null) {
249
             = null;
250
             = null;
251
            return;
252
        }
253
        // The property type is determined by the read method.
254
        setPropertyType(findPropertyType(readMethod, getWriteMethod0()));
255
        setClass0(readMethod.getDeclaringClass());
257
         = readMethod.getName();
258
        this. = getSoftReference(readMethod);
259
    }

    
Gets the method that should be used to write the property value.

Returns:
The method that should be used to write the property value. May return null if the property can't be written.
267
    public synchronized Method getWriteMethod() {
268
        Method writeMethod = getWriteMethod0();
269
        if (writeMethod == null) {
270
            Class cls = getClass0();
271
            if (cls == null || ( == null &&  == null)) {
272
                // The write method was explicitly set to null.
273
                return null;
274
            }
276
            // We need the type to fetch the correct method.
277
            Class type = getPropertyType0();
278
            if (type == null) {
279
                try {
280
                    // Can't use getPropertyType since it will lead to recursive loop.
281
                    type = findPropertyType(getReadMethod(), null);
282
                    setPropertyType(type);
283
                } catch (IntrospectionException ex) {
284
                    // Without the correct property type we can't be guaranteed
285
                    // to find the correct method.
286
                    return null;
287
                }
288
            }
290
            if ( == null) {
291
                 = . + getBaseName();
292
            }
294
            writeMethod = Introspector.findMethod(cls, , 1,
295
                          (type == null) ? null : new Class[] { type });
296
            try {
297
                setWriteMethod(writeMethod);
298
            } catch (IntrospectionException ex) {
299
                // fall through
300
            }
301
        }
302
        return writeMethod;
303
    }

    
Sets the method that should be used to write the property value.

Parameters:
writeMethod The new write method.
310
    public synchronized void setWriteMethod(Method writeMethod)
311
                                throws IntrospectionException {
312
        if (writeMethod == null) {
313
             = null;
314
             = null;
315
            return;
316
        }
317
        // Set the property type - which validates the method
318
        setPropertyType(findPropertyType(getReadMethod(), writeMethod));
319
        setClass0(writeMethod.getDeclaringClass());
321
         = writeMethod.getName();
322
        this. = getSoftReference(writeMethod);
324
    }
326
    private Method getReadMethod0() {
327
        return (this. != null)
328
                ? this..get()
329
                : null;
330
    }
332
    private Method getWriteMethod0() {
333
        return (this. != null)
334
                ? this..get()
335
                : null;
336
    }

    
Overridden to ensure that a super class doesn't take precedent 
341
    void setClass0(Class clz) {
342
        if (getClass0() != null && clz.isAssignableFrom(getClass0())) {
343
            // dont replace a subclass with a superclass
344
            return;
345
        }
346
        super.setClass0(clz);
347
    }

    
Updates to "bound" properties will cause a "PropertyChange" event to get fired when the property is changed.

Returns:
True if this is a bound property.
355
    public boolean isBound() {
356
        return ;
357
    }

    
Updates to "bound" properties will cause a "PropertyChange" event to get fired when the property is changed.

Parameters:
bound True if this is a bound property.
365
    public void setBound(boolean bound) {
366
        this. = bound;
367
    }

    
Attempted updates to "Constrained" properties will cause a "VetoableChange" event to get fired when the property is changed.

Returns:
True if this is a constrained property.
375
    public boolean isConstrained() {
376
        return ;
377
    }

    
Attempted updates to "Constrained" properties will cause a "VetoableChange" event to get fired when the property is changed.

Parameters:
constrained True if this is a constrained property.
385
    public void setConstrained(boolean constrained) {
386
        this. = constrained;
387
    }


    
Normally PropertyEditors will be found using the PropertyEditorManager. However if for some reason you want to associate a particular PropertyEditor with a given property, then you can do it with this method.

Parameters:
propertyEditorClass The Class for the desired PropertyEditor.
398
    public void setPropertyEditorClass(Class<?> propertyEditorClass) {
399
        this. = getWeakReference((Class)propertyEditorClass);
400
    }

    
Gets any explicit PropertyEditor Class that has been registered for this property.

Returns:
Any explicit PropertyEditor Class that has been registered for this property. Normally this will return "null", indicating that no special editor has been registered, so the PropertyEditorManager should be used to locate a suitable PropertyEditor.
412
    public Class<?> getPropertyEditorClass() {
413
        return (this. != null)
414
                ? this..get()
415
                : null;
416
    }

    
Constructs an instance of a property editor using the current property editor class.

If the property editor class has a public constructor that takes an Object argument then it will be invoked using the bean parameter as the argument. Otherwise, the default constructor will be invoked.

Parameters:
bean the source object
Returns:
a property editor instance or null if a property editor has not been defined or cannot be created
Since:
1.5
431
    public PropertyEditor createPropertyEditor(Object bean) {
432
        Object editor = null;
434
        Class cls = getPropertyEditorClass();
435
        if (cls != null) {
436
            Constructor ctor = null;
437
            if (bean != null) {
438
                try {
439
                    ctor = cls.getConstructor(new Class[] { Object.class });
440
                } catch (Exception ex) {
441
                    // Fall through
442
                }
443
            }
444
            try {
445
                if (ctor == null) {
446
                    editor = cls.newInstance();
447
                } else {
448
                    editor = ctor.newInstance(new Object[] { bean });
449
                }
450
            } catch (Exception ex) {
451
                // A serious error has occured.
452
                // Proably due to an invalid property editor.
453
                throw new RuntimeException("PropertyEditor not instantiated",
454
                                           ex);
455
            }
456
        }
457
        return (PropertyEditor)editor;
458
    }


    
Compares this PropertyDescriptor against the specified object. Returns true if the objects are the same. Two PropertyDescriptors are the same if the read, write, property types, property editor and flags are equivalent.

Since:
1.4
469
    public boolean equals(Object obj) {
470
        if (this == obj) {
471
            return true;
472
        }
473
        if (obj != null && obj instanceof PropertyDescriptor) {
474
            PropertyDescriptor other = (PropertyDescriptor)obj;
475
            Method otherReadMethod = other.getReadMethod();
476
            Method otherWriteMethod = other.getWriteMethod();
478
            if (!compareMethods(getReadMethod(), otherReadMethod)) {
479
                return false;
480
            }
482
            if (!compareMethods(getWriteMethod(), otherWriteMethod)) {
483
                return false;
484
            }
486
            if (getPropertyType() == other.getPropertyType() &&
487
                getPropertyEditorClass() == other.getPropertyEditorClass() &&
488
                 == other.isBound() &&  == other.isConstrained() &&
489
                 == other.writeMethodName &&
490
                 == other.readMethodName) {
491
                return true;
492
            }
493
        }
494
        return false;
495
    }

    
Package private helper method for Descriptor .equals methods.

Parameters:
a first method to compare
b second method to compare
Returns:
boolean to indicate that the methods are equivalent
504
    boolean compareMethods(Method a, Method b) {
505
        // Note: perhaps this should be a protected method in FeatureDescriptor
506
        if ((a == null) != (b == null)) {
507
            return false;
508
        }
510
        if (a != null && b != null) {
511
            if (!a.equals(b)) {
512
                return false;
513
            }
514
        }
515
        return true;
516
    }

    
Package-private constructor. Merge two property descriptors. Where they conflict, give the second argument (y) priority over the first argument (x).

Parameters:
x The first (lower priority) PropertyDescriptor
y The second (higher priority) PropertyDescriptor
527
        super(x,y);
529
        if (y.baseName != null) {
530
             = y.baseName;
531
        } else {
532
             = x.baseName;
533
        }
535
        if (y.readMethodName != null) {
536
             = y.readMethodName;
537
        } else {
538
             = x.readMethodName;
539
        }
541
        if (y.writeMethodName != null) {
542
             = y.writeMethodName;
543
        } else {
544
             = x.writeMethodName;
545
        }
547
        if (y.propertyTypeRef != null) {
548
             = y.propertyTypeRef;
549
        } else {
550
             = x.propertyTypeRef;
551
        }
553
        // Figure out the merged read method.
554
        Method xr = x.getReadMethod();
555
        Method yr = y.getReadMethod();
557
        // Normally give priority to y's readMethod.
558
        try {
559
            if (yr != null && yr.getDeclaringClass() == getClass0()) {
560
                setReadMethod(yr);
561
            } else {
562
                setReadMethod(xr);
563
            }
564
        } catch (IntrospectionException ex) {
565
            // fall through
566
        }
568
        // However, if both x and y reference read methods in the same class,
569
        // give priority to a boolean "is" method over a boolean "get" method.
570
        if (xr != null && yr != null &&
571
                   xr.getDeclaringClass() == yr.getDeclaringClass() &&
572
                   getReturnType(getClass0(), xr) == boolean.class &&
573
                   getReturnType(getClass0(), yr) == boolean.class &&
574
                   xr.getName().indexOf(.) == 0 &&
575
                   yr.getName().indexOf(.) == 0) {
576
            try {
577
                setReadMethod(xr);
578
            } catch (IntrospectionException ex) {
579
                // fall through
580
            }
581
        }
583
        Method xw = x.getWriteMethod();
584
        Method yw = y.getWriteMethod();
586
        try {
587
            if (yw != null && yw.getDeclaringClass() == getClass0()) {
588
                setWriteMethod(yw);
589
            } else {
590
                setWriteMethod(xw);
591
            }
592
        } catch (IntrospectionException ex) {
593
            // Fall through
594
        }
596
        if (y.getPropertyEditorClass() != null) {
598
        } else {
600
        }
603
         = x.bound | y.bound;
604
         = x.constrained | y.constrained;
605
    }
607
    /*
608
     * Package-private dup constructor.
609
     * This must isolate the new object from any changes to the old object.
610
     */
612
        super(old);
613
         = old.propertyTypeRef;
614
         = old.readMethodRef;
615
         = old.writeMethodRef;
616
         = old.propertyEditorClassRef;
618
         = old.writeMethodName;
619
         = old.readMethodName;
620
         = old.baseName;
622
         = old.bound;
623
         = old.constrained;
624
    }

    
Returns the property type that corresponds to the read and write method. The type precedence is given to the readMethod.

Returns:
the type of the property descriptor or null if both read and write methods are null.
Throws:
IntrospectionException if the read or write method is invalid
634
    private Class findPropertyType(Method readMethod, Method writeMethod)
635
        throws IntrospectionException {
636
        Class propertyType = null;
637
        try {
638
            if (readMethod != null) {
639
                Class[] params = getParameterTypes(getClass0(), readMethod);
640
                if (params.length != 0) {
641
                    throw new IntrospectionException("bad read method arg count: "
642
                                                     + readMethod);
643
                }
644
                propertyType = getReturnType(getClass0(), readMethod);
645
                if (propertyType == .) {
646
                    throw new IntrospectionException("read method " +
647
                                        readMethod.getName() + " returns void");
648
                }
649
            }
650
            if (writeMethod != null) {
651
                Class params[] = getParameterTypes(getClass0(), writeMethod);
652
                if (params.length != 1) {
653
                    throw new IntrospectionException("bad write method arg count: "
654
                                                     + writeMethod);
655
                }
656
                if (propertyType != null && propertyType != params[0]) {
657
                    throw new IntrospectionException("type mismatch between read and write methods");
658
                }
659
                propertyType = params[0];
660
            }
661
        } catch (IntrospectionException ex) {
662
            throw ex;
663
        }
664
        return propertyType;
665
    }


    
Returns a hash code value for the object. See java.lang.Object.hashCode() for a complete description.

Returns:
a hash code value for this object.
Since:
1.5
675
    public int hashCode() {
676
        int result = 7;
678
        result = 37 * result + ((getPropertyType() == null) ? 0 :
679
                                getPropertyType().hashCode());
680
        result = 37 * result + ((getReadMethod() == null) ? 0 :
681
                                getReadMethod().hashCode());
682
        result = 37 * result + ((getWriteMethod() == null) ? 0 :
683
                                getWriteMethod().hashCode());
684
        result = 37 * result + ((getPropertyEditorClass() == null) ? 0 :
685
                                getPropertyEditorClass().hashCode());
686
        result = 37 * result + (( == null) ? 0 :
687
                                .hashCode());
688
        result = 37 * result + (( == null) ? 0 :
689
                                .hashCode());
690
        result = 37 * result + getName().hashCode();
691
        result = 37 * result + (( == false) ? 0 : 1);
692
        result = 37 * result + (( == false) ? 0 : 1);
694
        return result;
695
    }
697
    // Calculate once since capitalize() is expensive.
698
    String getBaseName() {
699
        if ( == null) {
700
             = NameGenerator.capitalize(getName());
701
        }
702
        return ;
703
    }
705
    /*
706
    public String toString() {
707
        String message = "name=" + getName();
708
        message += ", class=" + getClass0();
709
        message += ", type=" + getPropertyType();
711
        message += ", writeMethod=";
712
        message += writeMethodName;
714
        message += ", readMethod=";
715
        message += readMethodName;
717
        message += ", bound=" + bound;
718
        message += ", constrained=" + constrained;
720
        return message;
721
    }
722
    */
New to GrepCode? Check out our FAQ X