public DescriptorSupport() 
{
        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
            MODELMBEAN_LOGGER.logp(Level.FINEST,
                    DescriptorSupport.class.getName(),
                    "DescriptorSupport()" , "Constructor");
        }
        init(null);
}

Descriptor default constructor. Default initial descriptor size is 20. It will grow as needed.
Note that the created empty descriptor is not a valid descriptor (the method isValid returns false)

 public DescriptorSupport(int initNumFields) throws MBeanException, RuntimeOperationsException 
{
        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
            MODELMBEAN_LOGGER.logp(Level.FINEST,
                    DescriptorSupport.class.getName(),
                    "Descriptor(initNumFields = " + initNumFields + ")",
                    "Constructor");
        }
        if (initNumFields < = 0) {
            if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
                MODELMBEAN_LOGGER.logp(Level.FINEST,
                        DescriptorSupport.class.getName(),
                        "Descriptor(initNumFields)",
                        "Illegal arguments: initNumFields < = 0");
            }
            final String msg =
                "Descriptor field limit invalid: " + initNumFields;
            final RuntimeException iae = new IllegalArgumentException(msg);
            throw new RuntimeOperationsException(iae, msg);
        }
        init(null);
}

Descriptor constructor. Takes as parameter the initial capacity of the Map that stores the descriptor fields. Capacity will grow as needed.
Note that the created empty descriptor is not a valid descriptor (the method isValid returns false).

Parameters:

initNumFields - The initial capacity of the Map that stores the descriptor fields.

Throws:

RuntimeOperationsException - for illegal value for initNumFields (<= 0)

MBeanException - Wraps a distributed communication Exception.

exception: RuntimeOperationsException - for illegal value for initNumFields (<= 0)

exception: MBeanException - Wraps a distributed communication Exception.

 public DescriptorSupport(DescriptorSupport inDescr) 
{
        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
            MODELMBEAN_LOGGER.logp(Level.FINEST,
                    DescriptorSupport.class.getName(),
                    "Descriptor(Descriptor)", "Constructor");
        }
        if (inDescr == null)
            init(null);
        else
            init(inDescr.descriptorMap);
}

Descriptor constructor taking a Descriptor as parameter. Creates a new descriptor initialized to the values of the descriptor passed in parameter.

Parameters:

inDescr - the descriptor to be used to initialize the constructed descriptor. If it is null or contains no descriptor fields, an empty Descriptor will be created.

 public DescriptorSupport(String inStr) throws MBeanException, RuntimeOperationsException, XMLParseException 
{
        /* parse an XML-formatted string and populate internal
         * structure with it */
        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
            MODELMBEAN_LOGGER.logp(Level.FINEST,
                    DescriptorSupport.class.getName(),
                    "Descriptor(String = '" + inStr + "')", "Constructor");
        }
        if (inStr == null) {
            if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
                MODELMBEAN_LOGGER.logp(Level.FINEST,
                        DescriptorSupport.class.getName(),
                        "Descriptor(String = null)", "Illegal arguments");
            }
            final String msg = "String in parameter is null";
            final RuntimeException iae = new IllegalArgumentException(msg);
            throw new RuntimeOperationsException(iae, msg);
        }
        final String lowerInStr = inStr.toLowerCase();
        if (!lowerInStr.startsWith("< descriptor >")
            || !lowerInStr.endsWith("< /descriptor >")) {
            throw new XMLParseException("No < descriptor >, < /descriptor > pair");
        }
        // parse xmlstring into structures
        init(null);
        // create dummy descriptor: should have same size
        // as number of fields in xmlstring
        // loop through structures and put them in descriptor
        StringTokenizer st = new StringTokenizer(inStr, "<  > \t\n\r\f");
        boolean inFld = false;
        boolean inDesc = false;
        String fieldName = null;
        String fieldValue = null;
        while (st.hasMoreTokens()) {  // loop through tokens
            String tok = st.nextToken();
            if (tok.equalsIgnoreCase("FIELD")) {
                inFld = true;
            } else if (tok.equalsIgnoreCase("/FIELD")) {
                if ((fieldName != null) && (fieldValue != null)) {
                    fieldName =
                        fieldName.substring(fieldName.indexOf('"') + 1,
                                            fieldName.lastIndexOf('"'));
                    final Object fieldValueObject =
                        parseQuotedFieldValue(fieldValue);
                    setField(fieldName, fieldValueObject);
                }
                fieldName = null;
                fieldValue = null;
                inFld = false;
            } else if (tok.equalsIgnoreCase("DESCRIPTOR")) {
                inDesc = true;
            } else if (tok.equalsIgnoreCase("/DESCRIPTOR")) {
                inDesc = false;
                fieldName = null;
                fieldValue = null;
                inFld = false;
            } else if (inFld && inDesc) {
                // want kw=value, eg, name="myname" value="myvalue"
                int eq_separator = tok.indexOf("=");
                if (eq_separator  > 0) {
                    String kwPart = tok.substring(0,eq_separator);
                    String valPart = tok.substring(eq_separator+1);
                    if (kwPart.equalsIgnoreCase("NAME"))
                        fieldName = valPart;
                    else if (kwPart.equalsIgnoreCase("VALUE"))
                        fieldValue = valPart;
                    else {  // xml parse exception
                        final String msg =
                            "Expected `name' or `value', got `" + tok + "'";
                        throw new XMLParseException(msg);
                    }
                } else { // xml parse exception
                    final String msg =
                        "Expected `keyword=value', got `" + tok + "'";
                    throw new XMLParseException(msg);
                }
            }
        }  // while tokens
        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
            MODELMBEAN_LOGGER.logp(Level.FINEST,
                    DescriptorSupport.class.getName(),
                    "Descriptor(XMLString)", "Exit");
        }
}

Descriptor constructor taking an XML String.

The format of the XML string is not defined, but an implementation must ensure that the string returned by toXMLString() on an existing descriptor can be used to instantiate an equivalent descriptor using this constructor.

In this implementation, all field values will be created as Strings. If the field values are not Strings, the programmer will have to reset or convert these fields correctly.

Parameters:

inStr - An XML-formatted string used to populate this Descriptor. The format is not defined, but any implementation must ensure that the string returned by method toXMLString on an existing descriptor can be used to instantiate an equivalent descriptor when instantiated using this constructor.

Throws:

RuntimeOperationsException - If the String inStr passed in parameter is null

XMLParseException - XML parsing problem while parsing the input String

MBeanException - Wraps a distributed communication Exception.

exception: RuntimeOperationsException - If the String inStr passed in parameter is null

exception: XMLParseException - XML parsing problem while parsing the input String

exception: MBeanException - Wraps a distributed communication Exception.

 public DescriptorSupport(String fields) 
{
        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
            MODELMBEAN_LOGGER.logp(Level.FINEST,
                    DescriptorSupport.class.getName(),
                    "Descriptor(String... fields)", "Constructor");
        }
        init(null);
        if (( fields == null ) || ( fields.length == 0))
            return;
        init(null);
        for (int i=0; i <  fields.length; i++) {
            if ((fields[i] == null) || (fields[i].equals(""))) {
                continue;
            }
            int eq_separator = fields[i].indexOf("=");
            if (eq_separator <  0) {
                // illegal if no = or is first character
                if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
                    MODELMBEAN_LOGGER.logp(Level.FINEST,
                            DescriptorSupport.class.getName(),
                            "Descriptor(String... fields)",
                            "Illegal arguments: field does not have " +
                            "'=' as a name and value separator");
                }
                final String msg = "Field in invalid format: no equals sign";
                final RuntimeException iae = new IllegalArgumentException(msg);
                throw new RuntimeOperationsException(iae, msg);
            }
            String fieldName = fields[i].substring(0,eq_separator);
            String fieldValue = null;
            if (eq_separator <  fields[i].length()) {
                // = is not in last character
                fieldValue = fields[i].substring(eq_separator+1);
            }
            if (fieldName.equals("")) {
                if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
                    MODELMBEAN_LOGGER.logp(Level.FINEST,
                            DescriptorSupport.class.getName(),
                            "Descriptor(String... fields)",
                            "Illegal arguments: fieldName is empty");
                }
                final String msg = "Field in invalid format: no fieldName";
                final RuntimeException iae = new IllegalArgumentException(msg);
                throw new RuntimeOperationsException(iae, msg);
            }
            setField(fieldName,fieldValue);
        }
        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
            MODELMBEAN_LOGGER.logp(Level.FINEST,
                    DescriptorSupport.class.getName(),
                    "Descriptor(String... fields)", "Exit");
        }
}

Constructor taking fields in the fieldName=fieldValue format.

Parameters:

fields - String array with each element containing a field name and value. If this array is null or empty, then the default constructor will be executed. Null strings or empty strings will be ignored.

All field values should be Strings. If the field values are not Strings, the programmer will have to reset or convert these fields correctly.

Note: Each string should be of the form fieldName=fieldValue. The field name ends at the first {@code =} character; for example if the String is {@code a=b=c} then the field name is {@code a} and its value is {@code b=c}.


Throws:

RuntimeOperationsException - for illegal value for field Names or field Values. The field must contain an "=". "=fieldValue", "fieldName", and "fieldValue" are illegal. FieldName cannot be null. "fieldName=" will cause the value to be null. If the descriptor construction fails for any reason, this exception will be thrown.

exception: RuntimeOperationsException - for illegal value for field Names or field Values. The field must contain an "=". "=fieldValue", "fieldName", and "fieldValue" are illegal. FieldName cannot be null. "fieldName=" will cause the value to be null. If the descriptor construction fails for any reason, this exception will be thrown.

 public DescriptorSupport(String[] fieldNames,
    Object[] fieldValues) throws RuntimeOperationsException 
{
        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
            MODELMBEAN_LOGGER.logp(Level.FINEST,
                    DescriptorSupport.class.getName(),
                    "Descriptor(fieldNames,fieldObjects)", "Constructor");
        }
        if ((fieldNames == null) || (fieldValues == null) ||
            (fieldNames.length != fieldValues.length)) {
            if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
                MODELMBEAN_LOGGER.logp(Level.FINEST,
                        DescriptorSupport.class.getName(),
                        "Descriptor(fieldNames,fieldObjects)",
                        "Illegal arguments");
            }
            final String msg =
                "Null or invalid fieldNames or fieldValues";
            final RuntimeException iae = new IllegalArgumentException(msg);
            throw new RuntimeOperationsException(iae, msg);
        }
        /* populate internal structure with fields */
        init(null);
        for (int i=0; i <  fieldNames.length; i++) {
            // setField will throw an exception if a fieldName is be null.
            // the fieldName and fieldValue will be validated in setField.
            setField(fieldNames[i], fieldValues[i]);
        }
        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
            MODELMBEAN_LOGGER.logp(Level.FINEST,
                    DescriptorSupport.class.getName(),
                    "Descriptor(fieldNames,fieldObjects)", "Exit");
        }
}

Constructor taking field names and field values. Neither array can be null.

Parameters:

fieldNames - String array of field names. No elements of this array can be null.

fieldValues - Object array of the corresponding field values. Elements of the array can be null. The fieldValue must be valid for the fieldName (as defined in method isValid )
Note: array sizes of parameters should match. If both arrays are empty, then an empty descriptor is created.


Throws:

RuntimeOperationsException - for illegal value for field Names or field Values. The array lengths must be equal. If the descriptor construction fails for any reason, this exception will be thrown.

exception: RuntimeOperationsException - for illegal value for field Names or field Values. The array lengths must be equal. If the descriptor construction fails for any reason, this exception will be thrown.

 public synchronized Object clone() throws RuntimeOperationsException 
{
        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
            MODELMBEAN_LOGGER.logp(Level.FINEST,
                    DescriptorSupport.class.getName(),
                    "clone()", "Entry");
        }
        return(new DescriptorSupport(this));
}

Returns a new Descriptor which is a duplicate of the Descriptor.

 public synchronized boolean equals(Object o) 
{
        if (o == this)
            return true;
        if (! (o instanceof Descriptor))
            return false;
        if (o instanceof ImmutableDescriptor)
            return o.equals(this);
        return new ImmutableDescriptor(descriptorMap).equals(o);
}

Compares this descriptor to the given object. The objects are equal if the given object is also a Descriptor, and if the two Descriptors have the same field names (possibly differing in case) and the same associated values. The respective values for a field in the two Descriptors are equal if the following conditions hold:
• If one value is null then the other must be too.
• If one value is a primitive array then the other must be a primitive array of the same type with the same elements.
• If one value is an object array then the other must be too and Arrays.deepEquals must return true.
• Otherwise Object#equals(Object) must return true.

 public synchronized String[] getFieldNames() 
{
        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
            MODELMBEAN_LOGGER.logp(Level.FINEST,
                    DescriptorSupport.class.getName(),
                    "getFieldNames()", "Entry");
        }
        int numberOfEntries = descriptorMap.size();
        String[] responseFields = new String[numberOfEntries];
        Set< Map.Entry< String, Object > > returnedSet = descriptorMap.entrySet();
        int i = 0;
        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
            MODELMBEAN_LOGGER.logp(Level.FINEST,
                    DescriptorSupport.class.getName(),
                    "getFieldNames()",
                    "Returning " + numberOfEntries + " fields");
        }
        for (Iterator< Map.Entry< String, Object > > iter = returnedSet.iterator();
             iter.hasNext(); i++) {
            Map.Entry< String, Object > currElement = iter.next();
            if (( currElement == null ) || (currElement.getKey() == null)) {
                if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
                    MODELMBEAN_LOGGER.logp(Level.FINEST,
                            DescriptorSupport.class.getName(),
                            "getFieldNames()", "Field is null");
                }
            } else {
                responseFields[i] = currElement.getKey().toString();
            }
        }
        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
            MODELMBEAN_LOGGER.logp(Level.FINEST,
                    DescriptorSupport.class.getName(),
                    "getFieldNames()", "Exit");
        }
        return responseFields;
}

 public synchronized Object getFieldValue(String fieldName) throws RuntimeOperationsException 
{
        if ((fieldName == null) || (fieldName.equals(""))) {
            if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
                MODELMBEAN_LOGGER.logp(Level.FINEST,
                        DescriptorSupport.class.getName(),
                        "getFieldValue(String fieldName)",
                        "Illegal arguments: null field name");
            }
            final String msg = "Fieldname requested is null";
            final RuntimeException iae = new IllegalArgumentException(msg);
            throw new RuntimeOperationsException(iae, msg);
        }
        Object retValue = descriptorMap.get(fieldName);
        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
            MODELMBEAN_LOGGER.logp(Level.FINEST,
                    DescriptorSupport.class.getName(),
                    "getFieldValue(String fieldName = " + fieldName + ")",
                    "Returns '" + retValue + "'");
        }
        return(retValue);
}

 public synchronized Object[] getFieldValues(String fieldNames) 
{
        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
            MODELMBEAN_LOGGER.logp(Level.FINEST,
                    DescriptorSupport.class.getName(),
                    "getFieldValues(String... fieldNames)", "Entry");
        }
        // if fieldNames == null return all values
        // if fieldNames is String[0] return no values
        final int numberOfEntries =
            (fieldNames == null) ? descriptorMap.size() : fieldNames.length;
        final Object[] responseFields = new Object[numberOfEntries];
        int i = 0;
        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
            MODELMBEAN_LOGGER.logp(Level.FINEST,
                    DescriptorSupport.class.getName(),
                    "getFieldValues(String... fieldNames)",
                    "Returning " + numberOfEntries + " fields");
        }
        if (fieldNames == null) {
            for (Object value : descriptorMap.values())
                responseFields[i++] = value;
        } else {
            for (i=0; i <  fieldNames.length; i++) {
                if ((fieldNames[i] == null) || (fieldNames[i].equals(""))) {
                    responseFields[i] = null;
                } else {
                    responseFields[i] = getFieldValue(fieldNames[i]);
                }
            }
        }
        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
            MODELMBEAN_LOGGER.logp(Level.FINEST,
                    DescriptorSupport.class.getName(),
                    "getFieldValues(String... fieldNames)", "Exit");
        }
        return responseFields;
}

 public synchronized String[] getFields() 
{
        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
            MODELMBEAN_LOGGER.logp(Level.FINEST,
                    DescriptorSupport.class.getName(),
                    "getFields()", "Entry");
        }
        int numberOfEntries = descriptorMap.size();
        String[] responseFields = new String[numberOfEntries];
        Set< Map.Entry< String, Object > > returnedSet = descriptorMap.entrySet();
        int i = 0;
        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
            MODELMBEAN_LOGGER.logp(Level.FINEST,
                    DescriptorSupport.class.getName(),
                    "getFields()", "Returning " + numberOfEntries + " fields");
        }
        for (Iterator< Map.Entry< String, Object > > iter = returnedSet.iterator();
             iter.hasNext(); i++) {
            Map.Entry< String, Object > currElement = iter.next();
            if (currElement == null) {
                if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
                    MODELMBEAN_LOGGER.logp(Level.FINEST,
                            DescriptorSupport.class.getName(),
                            "getFields()", "Element is null");
                }
            } else {
                Object currValue = currElement.getValue();
                if (currValue == null) {
                    responseFields[i] = currElement.getKey() + "=";
                } else {
                    if (currValue instanceof java.lang.String) {
                        responseFields[i] =
                            currElement.getKey() + "=" + currValue.toString();
                    } else {
                        responseFields[i] =
                            currElement.getKey() + "=(" +
                            currValue.toString() + ")";
                    }
                }
            }
        }
        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
            MODELMBEAN_LOGGER.logp(Level.FINEST,
                    DescriptorSupport.class.getName(),
                    "getFields()", "Exit");
        }
        return responseFields;
}

 public synchronized int hashCode() 
{
        final int size = descriptorMap.size();
        // descriptorMap is sorted with a comparator that ignores cases.
        //
        return Util.hashCode(
                descriptorMap.keySet().toArray(new String[size]),
                descriptorMap.values().toArray(new Object[size]));
}

Returns the hash code value for this descriptor. The hash code is computed as the sum of the hash codes for each field in the descriptor. The hash code of a field with name {@code n} and value {@code v} is {@code n.toLowerCase().hashCode() ^ h}. Here {@code h} is the hash code of {@code v}, computed as follows:

• If {@code v} is null then {@code h} is 0.
• If {@code v} is a primitive array then {@code h} is computed using the appropriate overloading of {@code java.util.Arrays.hashCode}.
• If {@code v} is an object array then {@code h} is computed using Arrays.deepHashCode .
• Otherwise {@code h} is {@code v.hashCode()}.

 public synchronized boolean isValid() throws RuntimeOperationsException 
{
        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
            MODELMBEAN_LOGGER.logp(Level.FINEST,
                    DescriptorSupport.class.getName(),
                    "isValid()", "Entry");
        }
        // verify that the descriptor is valid, by iterating over each field...
        Set< Map.Entry< String, Object > > returnedSet = descriptorMap.entrySet();
        if (returnedSet == null) {   // null descriptor, not valid
            if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
                MODELMBEAN_LOGGER.logp(Level.FINEST,
                        DescriptorSupport.class.getName(),
                        "isValid()", "Returns false (null set)");
            }
            return false;
        }
        // must have a name and descriptor type field
        String thisName = (String)(this.getFieldValue("name"));
        String thisDescType = (String)(getFieldValue("descriptorType"));
        if ((thisName == null) || (thisDescType == null) ||
            (thisName.equals("")) || (thisDescType.equals(""))) {
            return false;
        }
        // According to the descriptor type we validate the fields contained
        for (Map.Entry< String, Object > currElement : returnedSet) {
            if (currElement != null) {
                if (currElement.getValue() != null) {
                    // validate the field valued...
                    if (validateField((currElement.getKey()).toString(),
                                      (currElement.getValue()).toString())) {
                        continue;
                    } else {
                        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
                            MODELMBEAN_LOGGER.logp(Level.FINEST,
                                    DescriptorSupport.class.getName(),
                                    "isValid()",
                                    "Field " + currElement.getKey() + "=" +
                                    currElement.getValue() + " is not valid");
                        }
                        return false;
                    }
                }
            }
        }
        // fell through, all fields OK
        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
            MODELMBEAN_LOGGER.logp(Level.FINEST,
                    DescriptorSupport.class.getName(),
                    "isValid()", "Returns true");
        }
        return true;
}

Returns true if all of the fields have legal values given their names.

This implementation does not support interoperating with a directory or lookup service. Thus, conforming to the specification, no checking is done on the "export" field.

Otherwise this implementation returns false if:

• name and descriptorType fieldNames are not defined, or null, or empty, or not String
• class, role, getMethod, setMethod fieldNames, if defined, are null or not String
• persistPeriod, currencyTimeLimit, lastUpdatedTimeStamp, lastReturnedTimeStamp if defined, are null, or not a Numeric String or not a Numeric Value >= -1
• log fieldName, if defined, is null, or not a Boolean or not a String with value "t", "f", "true", "false". These String values must not be case sensitive.
• visibility fieldName, if defined, is null, or not a Numeric String or a not Numeric Value >= 1 and <= 4
• severity fieldName, if defined, is null, or not a Numeric String or not a Numeric Value >= 0 and <= 6
  
• persistPolicy fieldName, if defined, is null, or not one of the following strings:
  "OnUpdate", "OnTimer", "NoMoreOftenThan", "OnUnregister", "Always", "Never". These String values must not be case sensitive.
  

 public synchronized  void removeField(String fieldName) 
{
        if ((fieldName == null) || (fieldName.equals(""))) {
            return;
        }
        descriptorMap.remove(fieldName);
}

 public synchronized  void setField(String fieldName,
    Object fieldValue) throws RuntimeOperationsException 
{
        // field name cannot be null or empty
        if ((fieldName == null) || (fieldName.equals(""))) {
            if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
                MODELMBEAN_LOGGER.logp(Level.FINEST,
                        DescriptorSupport.class.getName(),
                        "setField(fieldName,fieldValue)",
                        "Illegal arguments: null or empty field name");
            }
            final String msg = "Field name to be set is null or empty";
            final RuntimeException iae = new IllegalArgumentException(msg);
            throw new RuntimeOperationsException(iae, msg);
        }
        if (!validateField(fieldName, fieldValue)) {
            if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
                MODELMBEAN_LOGGER.logp(Level.FINEST,
                        DescriptorSupport.class.getName(),
                        "setField(fieldName,fieldValue)",
                        "Illegal arguments");
            }
            final String msg =
                "Field value invalid: " + fieldName + "=" + fieldValue;
            final RuntimeException iae = new IllegalArgumentException(msg);
            throw new RuntimeOperationsException(iae, msg);
        }
        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
            MODELMBEAN_LOGGER.logp(Level.FINEST,
                    DescriptorSupport.class.getName(),
                    "setField(fieldName,fieldValue)", "Entry: setting '"
                    + fieldName + "' to '" + fieldValue + "'");
        }
        // Since we do not remove any existing entry with this name,
        // the field will preserve whatever case it had, ignoring
        // any difference there might be in fieldName.
        descriptorMap.put(fieldName, fieldValue);
}

 public synchronized  void setFields(String[] fieldNames,
    Object[] fieldValues) throws RuntimeOperationsException 
{
        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
            MODELMBEAN_LOGGER.logp(Level.FINEST,
                    DescriptorSupport.class.getName(),
                    "setFields(fieldNames,fieldValues)", "Entry");
        }
        if ((fieldNames == null) || (fieldValues == null) ||
            (fieldNames.length != fieldValues.length)) {
            if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
                MODELMBEAN_LOGGER.logp(Level.FINEST,
                        DescriptorSupport.class.getName(),
                        "setFields(fieldNames,fieldValues)",
                        "Illegal arguments");
            }
            final String msg = "fieldNames and fieldValues are null or invalid";
            final RuntimeException iae = new IllegalArgumentException(msg);
            throw new RuntimeOperationsException(iae, msg);
        }
        for (int i=0; i <  fieldNames.length; i++) {
            if (( fieldNames[i] == null) || (fieldNames[i].equals(""))) {
                if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
                    MODELMBEAN_LOGGER.logp(Level.FINEST,
                            DescriptorSupport.class.getName(),
                            "setFields(fieldNames,fieldValues)",
                            "Null field name encountered at element " + i);
                }
                final String msg = "fieldNames is null or invalid";
                final RuntimeException iae = new IllegalArgumentException(msg);
                throw new RuntimeOperationsException(iae, msg);
            }
            setField(fieldNames[i], fieldValues[i]);
        }
        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
            MODELMBEAN_LOGGER.logp(Level.FINEST,
                    DescriptorSupport.class.getName(),
                    "setFields(fieldNames,fieldValues)", "Exit");
        }
}

 public synchronized String toString() 
{
        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
            MODELMBEAN_LOGGER.logp(Level.FINEST,
                    DescriptorSupport.class.getName(),
                    "toString()", "Entry");
        }
        String respStr = "";
        String[] fields = getFields();
        if ((fields == null) || (fields.length == 0)) {
            if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
                MODELMBEAN_LOGGER.logp(Level.FINEST,
                        DescriptorSupport.class.getName(),
                        "toString()", "Empty Descriptor");
            }
            return respStr;
        }
        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
            MODELMBEAN_LOGGER.logp(Level.FINEST,
                    DescriptorSupport.class.getName(),
                    "toString()", "Printing " + fields.length + " fields");
        }
        for (int i=0; i <  fields.length; i++) {
            if (i == (fields.length - 1)) {
                respStr = respStr.concat(fields[i]);
            } else {
                respStr = respStr.concat(fields[i] + ", ");
            }
        }
        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
            MODELMBEAN_LOGGER.logp(Level.FINEST,
                    DescriptorSupport.class.getName(),
                    "toString()", "Exit returning " + respStr);
        }
        return respStr;
}

Returns a human readable string representing the descriptor. The string will be in the format of "fieldName=fieldValue,fieldName2=fieldValue2,..."
If there are no fields in the descriptor, then an empty String is returned.
If a fieldValue is an object then the toString() method is called on it and its returned value is used as the value for the field enclosed in parenthesis.

 public synchronized String toXMLString() 
{
        final StringBuilder buf = new StringBuilder("< Descriptor >");
        Set< Map.Entry< String, Object > > returnedSet = descriptorMap.entrySet();
        for (Map.Entry< String, Object > currElement : returnedSet) {
            final String name = currElement.getKey();
            Object value = currElement.getValue();
            String valueString = null;
            /* Set valueString to non-null if and only if this is a string that
               cannot be confused with the encoding of an object.  If it
               could be so confused (surrounded by parentheses) then we
               call makeFieldValue as for any non-String object and end
               up with an encoding like "(java.lang.String/(thing))".  */
            if (value instanceof String) {
                final String svalue = (String) value;
                if (!svalue.startsWith("(") || !svalue.endsWith(")"))
                    valueString = quote(svalue);
            }
            if (valueString == null)
                valueString = makeFieldValue(value);
            buf.append("< field name=\"").append(name).append("\" value=\"")
                .append(valueString).append("\" >< /field >");
        }
        buf.append("< /Descriptor >");
        return buf.toString();
}

Returns an XML String representing the descriptor.

The format is not defined, but an implementation must ensure that the string returned by this method can be used to build an equivalent descriptor when instantiated using the constructor DescriptorSupport(String inStr) .

Fields which are not String objects will have toString() called on them to create the value. The value will be enclosed in parentheses. It is not guaranteed that you can reconstruct these objects unless they have been specifically set up to support toString() in a meaningful format and have a matching constructor that accepts a String in the same format.

If the descriptor is empty the following String is returned: <Descriptor></Descriptor>