/* * 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(); } }
