org.osgi.compendium/src/main/java/info/dmtree/MetaNode.java

/*
 * $Header: /cvshome/build/info.dmtree/src/info/dmtree/MetaNode.java,v 1.4 2006/07/04 12:26:16 tszeredi Exp $
 *
 * Copyright (c) OSGi Alliance (2004, 2006). All Rights Reserved.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package info.dmtree;

/**
 * The MetaNode contains meta data as standardized by OMA DM but extends it 
 * (without breaking the compatibility) to provide for better DMT data quality 
 * in an environment where many software components manipulate this data.
 * <p>
 * The interface has several types of functions to describe the nodes in the
 * DMT. Some methods can be used to retrieve standard OMA DM metadata such as
 * access type, cardinality, default, etc., others are for data extensions such
 * as valid names and values. In some cases the standard behaviour has been
 * extended, for example it is possible to provide several valid MIME types, or
 * to differentiate between normal and automatic dynamic nodes.
 * <p>
 * Most methods in this interface receive no input, just return information
 * about some aspect of the node. However, there are two methods that behave
 * differently, {@link #isValidName} and {@link #isValidValue}. These
 * validation methods are given a potential node name or value (respectively),
 * and can decide whether it is valid for the given node. Passing the validation
 * methods is a necessary condition for a name or value to be used, but it is
 * not necessarily sufficient: the plugin may carry out more thorough (more
 * expensive) checks when the node is actually created or set.
 * <p>
 * If a <code>MetaNode</code> is available for a node, the DmtAdmin must use
 * the information provided by it to filter out invalid requests on that node.
 * However, not all methods on this interface are actually used for this
 * purpose, as many of them (e.g. {@link #getFormat} or {@link #getValidNames})
 * can be substituted with the validating methods. For example,
 * {@link #isValidValue} can be expected to check the format, minimum, maximum,
 * etc. of a given value, making it unnecessary for the DmtAdmin to call
 * {@link #getFormat()}, {@link #getMin()}, {@link #getMax()} etc. separately.
 * It is indicated in the description of each method if the DmtAdmin does not
 * enforce the constraints defined by it - such methods are only for external
 * use, for example in user interfaces.
 * <p>
 * Most of the methods of this class return <code>null</code> if a certain
 * piece of meta information is not defined for the node or providing this
 * information is not supported. Methods of this class do not throw exceptions.
 */
public interface MetaNode {

    /**
     * Constant for the ADD access type. If {@link #can(int)} returns
     * <code>true</code> for this operation, this node can potentially be
     * added to its parent. Nodes with {@link #PERMANENT} or {@link #AUTOMATIC}
     * scope typically do not have this access type.
     */
    int CMD_ADD = 0;

    /**
     * Constant for the DELETE access type. If {@link #can(int)} returns
     * <code>true</code> for this operation, the node can potentially be
     * deleted.
     */
    int CMD_DELETE = 1;

    /**
     * Constant for the EXECUTE access type. If {@link #can(int)} returns
     * <code>true</code> for this operation, the node can potentially be
     * executed.
     */
    int CMD_EXECUTE = 2;

    /**
     * Constant for the REPLACE access type. If {@link #can(int)} returns
     * <code>true</code> for this operation, the value and other properties of
     * the node can potentially be modified.
     */
    int CMD_REPLACE = 3;

    /**
     * Constant for the GET access type. If {@link #can(int)} returns
     * <code>true</code> for this operation, the value, the list of child nodes
     * (in case of interior nodes) and the properties of the node can
     * potentially be retrieved.
     */
    int CMD_GET = 4;

    /**
     * Constant for representing a permanent node in the tree. This must be
     * returned by {@link #getScope} if the node cannot be added, deleted or
     * modified in any way through tree operations. Permanent nodes cannot have
     * non-permanent nodes as parents.
     */
    int PERMANENT = 0;

    /**
     * Constant for representing a dynamic node in the tree. This must be
     * returned by {@link #getScope} for all nodes that are not permanent and
     * are not created automatically by the management object.
     */
    int DYNAMIC = 1;

    /**
     * Constant for representing an automatic node in the tree. This must be
     * returned by {@link #getScope()} for all nodes that are created
     * automatically by the management object. Automatic nodes represent a
     * special case of dynamic nodes, so this scope should be mapped to
     * {@link #DYNAMIC} when used in an OMA DM context.
     * <p>
     * An automatic node is usually created instantly when its parent is
     * created, but it is also valid if it only appears later, triggered by some
     * other condition. The exact behaviour must be defined by the Management
     * Object.
     */
    int AUTOMATIC = 2;

    /**
     * Check whether the given operation is valid for this node. If no meta-data
     * is provided for a node, all operations are valid.
     * 
     * @param operation One of the <code>MetaNode.CMD_...</code> constants.
     * @return <code>false</code> if the operation is not valid for this node
     *         or the operation code is not one of the allowed constants
     */
    boolean can(int operation);

    /**
     * Check whether the node is a leaf node or an internal one.
     * 
     * @return <code>true</code> if the node is a leaf node
     */
    boolean isLeaf();

    /**
     * Return the scope of the node. Valid values are
     * {@link #PERMANENT MetaNode.PERMANENT}, {@link #DYNAMIC MetaNode.DYNAMIC}
     * and {@link #AUTOMATIC MetaNode.AUTOMATIC}. Note that a permanent node is
     * not the same as a node where the DELETE operation is not allowed.
     * Permanent nodes never can be deleted, whereas a non-deletable node can
     * disappear in a recursive DELETE operation issued on one of its parents.
     * If no meta-data is provided for a node, it can be assumed to be a dynamic
     * node.
     * 
     * @return {@link #PERMANENT} for permanent nodes, {@link #AUTOMATIC} for
     *         nodes that are automatically created, and {@link #DYNAMIC}
     *         otherwise
     */
    int getScope();

    /**
     * Get the explanation string associated with this node. Can be
     * <code>null</code> if no description is provided for this node.
     * 
     * @return node description string or <code>null</code> for no description
     */
    String getDescription();

    /**
     * Get the number of maximum occurrences of this type of nodes on the same
     * level in the DMT. Returns <code>Integer.MAX_VALUE</code> if there is no
     * upper limit. Note that if the occurrence is greater than 1 then this node
     * can not have siblings with different metadata. In other words, if
     * different types of nodes coexist on the same level, their occurrence can
     * not be greater than 1. If no meta-data is provided for a node, there is
     * no upper limit on the number of occurrences.
     * 
     * @return The maximum allowed occurrence of this node type
     */
    int getMaxOccurrence();

    /**
     * Check whether zero occurrence of this node is valid. If no meta-data is
     * returned for a node, zero occurrences are allowed.
     * 
     * @return <code>true</code> if zero occurrence of this node is valid
     */
    boolean isZeroOccurrenceAllowed();

    /**
     * Get the default value of this node if any.
     * 
     * @return The default value or <code>null</code> if not defined
     */
    DmtData getDefault();

    /**
     * Get the list of MIME types this node can hold. The first element of the
     * returned list must be the default MIME type.
     * <p>
     * All MIME types are considered valid if no meta-data is provided for a
     * node or if <code>null</code> is returned by this method. In this case
     * the default MIME type cannot be retrieved from the meta-data, but the
     * node may still have a default. This hidden default (if it exists) can be
     * utilized by passing <code>null</code> as the type parameter of
     * {@link DmtSession#setNodeType(String, String)} or
     * {@link DmtSession#createLeafNode(String, DmtData, String)}.
     * 
     * @return the list of allowed MIME types for this node, starting with the
     *         default MIME type, or <code>null</code> if all types are
     *         allowed
     */
    String[] getMimeTypes();

    /**
     * Get the maximum allowed value associated with a node of numeric format.
     * If no meta-data is provided for a node, there is no upper limit to its
     * value. This method is only meaningful if the node has integer or float
     * format. The returned limit has <code>double</code> type, as this can be
     * used to denote both integer and float limits with full precision. The
     * actual maximum should be the largest integer or float number that does
     * not exceed the returned value.
     * <p>
     * The information returned by this method is not checked by DmtAdmin, it
     * is only for external use, for example in user interfaces. DmtAdmin only
     * calls {@link #isValidValue} for checking the value, its behaviour should
     * be consistent with this method.
     * 
     * @return the allowed maximum, or <code>Double.MAX_VALUE</code> if there
     *         is no upper limit defined or the node's format is not integer or
     *         float
     */
    double getMax();

    /**
     * Get the minimum allowed value associated with a node of numeric format.
     * If no meta-data is provided for a node, there is no lower limit to its
     * value. This method is only meaningful if the node has integer or float
     * format. The returned limit has <code>double</code> type, as this can be
     * used to denote both integer and float limits with full precision. The
     * actual minimum should be the smallest integer or float number that is
     * larger than the returned value.
     * <p>
     * The information returned by this method is not checked by DmtAdmin, it
     * is only for external use, for example in user interfaces. DmtAdmin only
     * calls {@link #isValidValue} for checking the value, its behaviour should
     * be consistent with this method.
     * 
     * @return the allowed minimum, or <code>Double.MIN_VALUE</code> if there
     *         is no lower limit defined or the node's format is not integer or
     *         float
     */
    double getMin();

    /**
     * Return an array of DmtData objects if valid values are defined for the
     * node, or <code>null</code> otherwise. If no meta-data is provided for a
     * node, all values are considered valid.
     * <p>
     * The information returned by this method is not checked by DmtAdmin, it
     * is only for external use, for example in user interfaces. DmtAdmin only
     * calls {@link #isValidValue} for checking the value, its behaviour should
     * be consistent with this method.
     * 
     * @return the valid values for this node, or <code>null</code> if not
     *         defined
     */
    DmtData[] getValidValues();

    /**
     * Get the node's format, expressed in terms of type constants defined in
     * {@link DmtData}. If there are multiple formats allowed for the node then
     * the format constants are OR-ed. Interior nodes must have
     * {@link DmtData#FORMAT_NODE} format, and this code must not be returned
     * for leaf nodes. If no meta-data is provided for a node, all applicable
     * formats are considered valid (with the above constraints regarding
     * interior and leaf nodes).
     * <p>
     * Note that the 'format' term is a legacy from OMA DM, it is more customary
     * to think of this as 'type'.
     * <p>
     * The formats returned by this method are not checked by DmtAdmin, they
     * are only for external use, for example in user interfaces. DmtAdmin only
     * calls {@link #isValidValue} for checking the value, its behaviour should
     * be consistent with this method.
     * 
     * @return the allowed format(s) of the node
     */
    int getFormat();
    
    /**
     * Get the format names for any raw formats supported by the node.  This
     * method is only meaningful if the list of supported formats returned by
     * {@link #getFormat()} contains {@link DmtData#FORMAT_RAW_STRING} or
     * {@link DmtData#FORMAT_RAW_BINARY}: it specifies precisely which raw
     * format(s) are actually supported.  If the node cannot contain data in one
     * of the raw types, this method must return <code>null</code>.
     * <p>
     * The format names returned by this method are not checked by DmtAdmin,
     * they are only for external use, for example in user interfaces. DmtAdmin
     * only calls {@link #isValidValue} for checking the value, its behaviour
     * should be consistent with this method.
     * 
     * @return the allowed format name(s) of raw data stored by the node, or
     *         <code>null</code> if raw formats are not supported
     */
    String[] getRawFormatNames();

    /**
     * Checks whether the given value is valid for this node. This method can be
     * used to ensure that the value has the correct format and range, that it
     * is well formed, etc. This method should be consistent with the
     * constraints defined by the {@link #getFormat}, {@link #getValidValues},
     * {@link #getMin} and {@link #getMax} methods (if applicable), as the Dmt
     * Admin only calls this method for value validation.
     * <p>
     * This method may return <code>true</code> even if not all aspects of the
     * value have been checked, expensive operations (for example those that
     * require external resources) need not be performed here. The actual value
     * setting method may still indicate that the value is invalid.
     * 
     * @param value the value to check for validity
     * @return <code>false</code> if the specified value is found to be
     *         invalid for the node described by this meta-node,
     *         <code>true</code> otherwise
     */
    boolean isValidValue(DmtData value);

    /**
     * Return an array of Strings if valid names are defined for the node, or
     * <code>null</code> if no valid name list is defined or if this piece of
     * meta info is not supported. If no meta-data is provided for a node, all
     * names are considered valid.
     * <p>
     * The information returned by this method is not checked by DmtAdmin, it
     * is only for external use, for example in user interfaces. DmtAdmin only
     * calls {@link #isValidName} for checking the name, its behaviour should be
     * consistent with this method.
     * 
     * @return the valid values for this node name, or <code>null</code> if
     *         not defined
     */
    String[] getValidNames();

    /**
     * Checks whether the given name is a valid name for this node. This method
     * can be used for example to ensure that the node name is always one of a
     * predefined set of valid names, or that it matches a specific pattern.
     * This method should be consistent with the values returned by
     * {@link #getValidNames} (if any), the DmtAdmin only calls this method for
     * name validation.
     * <p>
     * This method may return <code>true</code> even if not all aspects of the
     * name have been checked, expensive operations (for example those that
     * require external resources) need not be performed here. The actual node
     * creation may still indicate that the node name is invalid.
     * 
     * @param name the node name to check for validity
     * @return <code>false</code> if the specified name is found to be invalid
     *         for the node described by this meta-node, <code>true</code>
     *         otherwise
     */
    boolean isValidName(String name);

    /**
     * Returns the list of extension property keys, if the provider of this
     * <code>MetaNode</code> provides proprietary extensions to node meta
     * data. The method returns <code>null</code> if the node doesn't provide
     * such extensions.
     * 
     * @return the array of supported extension property keys
     */
    String[] getExtensionPropertyKeys();

    /**
     * Returns the value for the specified extension property key. This method
     * only works if the provider of this <code>MetaNode</code> provides
     * proprietary extensions to node meta data.
     * 
     * @param key the key for the extension property
     * @return the value of the requested property, cannot be <code>null</code>
     * @throws IllegalArgumentException if the specified key is not supported by
     *         this <code>MetaNode</code>
     */
    Object getExtensionProperty(String key);
}