xref: /illumos-gate/usr/src/lib/libslp/javalib/com/sun/slp/AttributeDescriptor.java (revision 55fea89d)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 1999 by Sun Microsystems, Inc.
 * All rights reserved.
 *
 */

//  AttributeDescriptor.java: Describes an SLP attribute.
//  Author:           James Kempf
//  Created On:       Thu Jun 19 10:38:01 1997
//  Last Modified By: James Kempf
//  Last Modified On: Tue Jun  2 13:29:08 1998
//  Update Count:     29
//

package com.sun.slp;

import java.util.*;


/**
 * The instances of the AttributeDescriptor class
 * return information on a particular service location attribute. This
 * information is primarily for GUI tools. Programmatic attribute
 * verification should be done through the ServiceLocationAttributeVerifier.
 *
 * @author James Kempf
 *
 */

class AttributeDescriptor
    extends Object
    implements ServiceLocationAttributeDescriptor {

    // Indicates byte array type.

    private static final String JAVA_OPAQUE_TYPE = "[B";

    private String id = "";
    private String valueType = "";
    private String description = "";
    private Vector allowedValues = new Vector();
    private Vector defaultValues = new Vector();
    private boolean isMultivalued = false;
    private boolean isOptional = false;
    private boolean requiresExplicitMatch = false;
    private boolean isLiteral = false;
    private boolean isKeyword = false;

    /**
     * Return the attribute's id.
     *
     * @return A String with the attribute's id.
     */

    final public String getId() {
	return id;
    }

    /**
     * Return the fully qualified Java type of the attribute. SLP types
     * are translated into Java types as follows:
     *
     *	STRING		java.lang.String
     *	INTEGER		java.lang.Integer
     *	BOOLEAN		java.lang.Boolean
     *	OPAQUE		[B (i.e. array of byte, byte[]);
     *	KEYWORD		null string, ""
     *
     * @return A String containing the Java type name for the attribute values.
     */

    final public String getValueType() {
	return valueType;
    }

    /**
     * Return attribute's help text.
     *
     * @return A String containing the attribute's help text.
     */

    final public String getDescription() {
	return description;
    }

    /**
     * Return an Enumeration of allowed values for the attribute type.
     * For keyword attributes returns null. For no allowed values
     * (i.e. unrestricted) returns an empty Enumeration. Small memory
     * implementations may want to parse values on demand rather
     * than at the time the descriptor is created.
     *
     * @return An Enumeration of allowed values for the attribute or
     *         null if the attribute is keyword.
     */

    final public Enumeration getAllowedValues() {

	if (getIsKeyword()) {
	    return null;
	} else {
	    return allowedValues.elements();
	}
    }


    /**
     * Return an Enumeration of default values for the attribute type.
     * For keyword attributes returns null. For no allowed values
     * (i.e. unrestricted) returns an empty Enumeration. Small memory
     * implementations may want to parse values on demand rather
     * than at the time the descriptor is created.
     *
     * @return An Enumeration of default values for the attribute or
     *	      null if the attribute is keyword.
     */

    final public Enumeration getDefaultValues() {

	if (getIsKeyword()) {
	    return null;
	} else {
	    return defaultValues.elements();
	}
    }

    /**
     * Returns true if the "M" flag is set.
     *
     * @return True if the "M" flag is set.
     */

    final public boolean getIsMultivalued() {
	return isMultivalued;
    }

    /**
     * Returns true if the "O" flag is set.
     *
     * @return True if the "O" flag is set.
     */

    final public boolean getIsOptional() {
	return isOptional;
    }

    /**
     * Returns true if the "X" flag is set.
     *
     * @return True if the "X" flag is set.
     */

    final public boolean getRequiresExplicitMatch() {
	return requiresExplicitMatch;
    }

    /**
     * Returns true if the "L" flag is set.
     *
     * @return True if the "L" flag is set.
     */

    final public boolean getIsLiteral() {
	return isLiteral;
    }

    /**
     * Returns true if the attribute is a keyword attribute.
     *
     * @return True if the attribute is a keyword attribute
     */

    final public boolean getIsKeyword() {
	return isKeyword;
    }

    //
    // Package private interface for setting properties.
    //

    /**
     * Set the attribute's id.
     *
     * @param nid New id string
     */

    void setId(String nid) {
	id = nid;
    }

    /**
     * Set the fully qualified Java type of the attribute. We don't check
     * the argument here, assuming that the caller has taken care of it.
     *
     * @param nvt New value type.
     */

    void setValueType(String nvt) {
	valueType = nvt;
    }

    /**
     * Set attribute's help text.
     *
     * @param ndes A String containing the attribute's help text.
     */

    void setDescription(String ndes) {
	description = ndes;
    }

    /**
     * Set the allowed values for an attribute.
     *
     * @param nnv A vector of allowed values for the attribute.
     */

    void setAllowedValues(Vector nnv) {
	allowedValues = nnv;
    }


    /**
     * Set the default values for an attribute.
     *
     * @param nnv A vector of default values for the attribute.
     */

    void setDefaultValues(Vector nnv) {
	defaultValues = nnv;
    }

    /**
     * Set the isMultivalued flag.
     *
     * @param flag New multivalued flag.
     */

    void setIsMultivalued(boolean flag) {
	isMultivalued = flag;
    }

    /**
     * Set the isOptional flag.
     *
     * @param flag New optional flag.
     */

    void setIsOptional(boolean flag) {
	isOptional = flag;
    }

    /**
     * Set the requiresExplicitMatch flag.
     *
     * @param flag New explicit match flag.
     */

    void setRequiresExplicitMatch(boolean flag) {
	requiresExplicitMatch = flag;
    }

    /**
     * Set the isLiteral flag.
     *
     * @param flag New literal flag.
     */

    void setIsLiteral(boolean flag) {
	isLiteral = flag;
    }

    /**
     * Set the keyword attribute flag.
     *
     * @param flag New keyword attribute flag.
     */

    void setIsKeyword(boolean flag) {
	isKeyword = flag;
    }

    /**
     * Format a string with the id and all the fields.
     *
     */

    public String toString() {

	String ret = "";

	ret += "\nid:" + id + "\n";
	ret += "valueType:" + valueType + "\n";
	ret += "description:" + description + "\n";
	ret +=
	    "defaultValues:" +
	    (defaultValues == null ? "<null>":
	    (valueType.equals(JAVA_OPAQUE_TYPE) ?
	    formatByteArrays(defaultValues) : defaultValues.toString())) +
	    "\n";
	ret +=
	    "allowedValues:" +
	    (allowedValues == null ? "<null>":
	    (valueType.equals(JAVA_OPAQUE_TYPE) ?
	    formatByteArrays(allowedValues) : allowedValues.toString())) +
	    "\n";
	ret += "isMultivalued:" + (isMultivalued ? "true":"false") + "\n";
	ret += "isOptional:" + (isOptional ? "true":"false") + "\n";
	ret += "requiresExplicitMatch:" +
	    (requiresExplicitMatch ? "true":"false") + "\n";
	ret += "isLiteral:" + (isLiteral ? "true":"false") + "\n";
	ret += "isKeyword:" + (isKeyword ? "true":"false") + "\n\n";

	return ret;
    }

    // Formats an array of bytes for opaque, rather than just the address.

    private String formatByteArrays(Vector arrays) {
	int i, n = arrays.size();
	StringBuffer ret = new StringBuffer();

	ret.append("[");

	for (i = 0; i < n; i++) {
	    byte array[] = (byte[])arrays.elementAt(i);

	    ret.append("{ ");

	    int j, m = array.length;

	    for (j = 0; j < m; j++) {
		ret.append("0x");
		ret.append(Integer.toHexString((int)array[j]&0xFF));
		ret.append(j == m - 1 ? " } " : ",");
	    }

	    ret.append(i == n - 1 ? "":" , ");
	}

	ret.append("]");

	return ret.toString();
    }

}