RBNBBaseParameterHolder.java

/*
 * Created on Jun 17, 2004
 */
package org.nees.rbnb;

import java.io.IOException;

import java.util.Hashtable;
import java.util.Enumeration;

import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.MutableTreeNode;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import org.w3c.dom.Node;

public class RBNBBaseParameterHolder
{
    
    final static String XML_TAG_FOR_PARAMETER_NAME = "name";
    final static String XML_TAG_FOR_PARAMETER_TYPE = "type";
    final static String XML_TAG_FOR_PARAMETER_DEFAULT_VALUE = "defaultValue";
    final static String XML_TAG_FOR_PARAMETER_VALUE = "value";
    
    final static String BOOLEAN_TYPE = "Boolean";
    final static String INTEGER_TYPE = "Integer";
    final static String LONG_TYPE = "Long";
    final static String FLOAT_TYPE = "Float";
    final static String DOUBLE_TYPE = "Double";
    final static String STRING_TYPE = "String";
    
    private String[] types = new String[]
        {BOOLEAN_TYPE, INTEGER_TYPE, LONG_TYPE, 
            FLOAT_TYPE, DOUBLE_TYPE, STRING_TYPE};
    private Object[] prototypes = new Object[]
        {
            new Boolean(true),
            new Integer(0),
            new Long(0),
            new Float(0.0),
            new Double(0.0),
            new String("")
        };
    private String name;
    private String type;
    private Object defaultValue;
    private Object value;
    
    public RBNBBaseParameterHolder(Node node)
    {
        setFromDocNode(node);
    }
        
    public RBNBBaseParameterHolder(String n, String t, Object d)
        throws IllegalArgumentException
    {
        initialize(n,t,d);
    }
    
    public RBNBBaseParameterHolder(RBNBBaseParameterHolder model)
        throws IllegalArgumentException
    {
        initialize(model.getName(), model.getType(), model.getDefaultValue());
        if (model.getValue() != null) setValue(model.getValue());
    }
    
    private void initialize(String n, String t, Object d)
    {
        if ((n == null) || n.equals(""))
            throw new IllegalArgumentException("RBNBBase: parameter name must be defined");
        if ((t == null) || t.equals(""))
            throw new IllegalArgumentException("RBNBBase: parameter type must be defined");
        name = n;
        type = t;
        boolean found = false;
        int index = 0;
            
        for (int i = 0; (i < types.length) && !found; i++)
        {
            index = i;
            if (types[i].equals(t)) found = true;
        }
        if (!found)
            throw new IllegalArgumentException("RBNBBase: Illegal Parameter Type " + t);
        
        if (d != null)
            if (!d.getClass().equals(prototypes[index].getClass()))
                throw new IllegalArgumentException(
                    "RBNBBase: Parameter type and class of default "
                    + "do not match; type =" + t
                    + "class of default = " + d.getClass());
        defaultValue = d;
    }
    
    public void setValue(Object v)
        throws IllegalArgumentException
    {
        if (v != null)
        {
            if (defaultValue != null)
            {
                if (!defaultValue.getClass().equals(v.getClass()))
                    throw new IllegalArgumentException("RBNBBase: Classes of default value and "
                        + "value do not match; "
                        + "class of default =" + defaultValue.getClass()
                        + "class of value = " + v.getClass());
            }
            else
            {
                int index = 0;
                boolean found = false;
                for (int i = 0; (i < types.length) && !found; i++)
                {
                    index = i;
                    if (types[i].equals(type)) found = true;
                }
                if (!found)
                    throw new IllegalArgumentException("RBNBBase: Illegal Parameter Type " + type);
                if (!v.getClass().equals(prototypes[index].getClass()))
                    throw new IllegalArgumentException(
                        "RBNBBase: Parameter type and class of value "
                        + "do not match; type =" + type
                        + "class of default = " + v.getClass());
            }
        }
        value = v;
    }

    public void setValueFromString(String s) {
        Object test = makeTypeObject(type, s);
        if (test == null) return;
        setValue(test);
    }
        
    public Object getValue()
    {
        return value;
    }

    public Object getDefaultValue()
    {
        return defaultValue;
    }
    
    public void setDefaultFromTemplate(RBNBBaseParameterHolder t)
    {
        Object defaultValue = t.getDefaultValue();
        if (defaultValue != null)
            this.defaultValue = defaultValue;
    }
    
    private void setName(String name)
    {
        this.name = name;
    }
    
    public String getName()
    {
        return name;
    }
    
    public String toString()
    {
        return getName();
    }
    
    private void setType(String type)
    {
        this.type = type;
    }
    
    public String getType()
    {
        return type;
    }
    
    public void setFromDocNode(Node node)
    {
        String name = null;
        String type = null;
        String defaultValueString = null;
        String valueString = null;
        
        NodeList children = node.getChildNodes();
        final int length = children.getLength();
        for(int i = 0; i < length; i++)
        {
            Node child = children.item(i);
            if (child.getNodeType() == Node.ELEMENT_NODE)
            {
                Element element = (Element)child;
                String tag = element.getTagName();
                if (tag.equals(XML_TAG_FOR_PARAMETER_NAME))
                {
                    // get string from templage name
                    // <templateName>name</templateName>
                    name = child.getChildNodes().item(0).getNodeValue();
                }
                else
                if (tag.equals(XML_TAG_FOR_PARAMETER_TYPE))
                {
                    // get string from templage name
                    // <type>type</type>
                    type = child.getChildNodes().item(0).getNodeValue();
                }
                else
                if (tag.equals(XML_TAG_FOR_PARAMETER_DEFAULT_VALUE))
                {
                    if (child.hasChildNodes())
                    // get string from templage name
                    // <defaultValue>value</defaultValue>
                    defaultValueString = child.getChildNodes().item(0).getNodeValue();
                }
                else
                if (tag.equals(XML_TAG_FOR_PARAMETER_VALUE))
                {
                    if (child.hasChildNodes())
                    // get string from templage name
                    // <value>value</value>
                    valueString = child.getChildNodes().item(0).getNodeValue();
                }
            }
        }
        
//      System.out.println("Parameter from doc...");
//      if (name == null) System.out.println("Parameter from doc: null name");
//      else System.out.println("Parameter from doc: name = " + name);
//      if (type == null) System.out.println("Parameter from doc: null type");
//      else System.out.println("Parameter from doc: type = " + type);
//      if (defaultValueString == null) System.out.println("Parameter from doc: null default");
//      else System.out.println("Parameter from doc: default = " + defaultValueString);
//      if (valueString == null) System.out.println("Parameter from doc: null value");
//      else System.out.println("Parameter from doc: value = " + valueString);
        
        if (defaultValueString != null)
            initialize(name,type,makeTypeObject(type,defaultValueString));
        else
            initialize(name,type,null);
        if (valueString != null)
            setValue(makeTypeObject(type,valueString));
    }
        
    private Object makeTypeObject(String type, String value)
    {
        Object ret = null;
//      final static String BOOLEAN_TYPE = "Boolean";
//      final static String INTEGER_TYPE = "Integer";
//      final static String LONG_TYPE = "Long";
//      final static String FLOAT_TYPE = "Float";
//      final static String DOUBLE_TYPE = "Double";
//      final static String STRING_TYPE = "String";
        
        try{
            if (type.equals(BOOLEAN_TYPE))
                ret = new Boolean(value);
            else if (type.equals(INTEGER_TYPE))
                ret = new Integer(value);
            else if (type.equals(LONG_TYPE))
                ret = new Long(value);
            else if (type.equals(FLOAT_TYPE))
                ret = new Float(value);
            else if (type.equals(DOUBLE_TYPE))
                ret = new Double(value);
            else if (type.equals(STRING_TYPE))
                ret = value;
        }
        catch (Exception ignore) {}     
        return ret;
    }
    
    public Node createXmlNode(Document doc)
    {
        Node node,root = doc.createElement(NeesControlMetadata.XML_TAG_FOR_PARAMETER);
        
        node = doc.createElement(XML_TAG_FOR_PARAMETER_NAME);
        node.appendChild(doc.createTextNode(name));
        root.appendChild(node);

        if ((type != null) && (!type.equals("")))
        {
            node = doc.createElement(XML_TAG_FOR_PARAMETER_TYPE);
            node.appendChild(doc.createTextNode(type));
            root.appendChild(node);
        }
        
        if (getDefaultValue() != null)
        {   
            node = doc.createElement(XML_TAG_FOR_PARAMETER_DEFAULT_VALUE);
            node.appendChild(doc.createTextNode(getDefaultValue().toString()));
            root.appendChild(node);
        }
        
        if (getValue() != null)
        {
            node = doc.createElement(XML_TAG_FOR_PARAMETER_VALUE);
            node.appendChild(doc.createTextNode(getValue().toString()));
            root.appendChild(node);
        }
            
        return root;
    }

    public MutableTreeNode makeSwingTreeNode() {
        
        DefaultMutableTreeNode node, root = new DefaultMutableTreeNode(this);
        if ((type != null) && (!type.equals("")))
        {
            node = new DefaultMutableTreeNode("Type: " + type);
            root.add(node);
        }

        if (defaultValue != null)
        {   
            node = new DefaultMutableTreeNode("Default: " + defaultValue.toString());
            root.add(node);
        }

        if (value != null)
        {   
            node = new DefaultMutableTreeNode("Value: " + value.toString());
            root.add(node);
        }
        
        return root;
    }

    public static MutableTreeNode makeParamersSwingTreeNode(Hashtable parameters) {
        DefaultMutableTreeNode root = new DefaultMutableTreeNode("Parameters");
        Enumeration e = parameters.elements();
        while (e.hasMoreElements())
        {
            RBNBBaseParameterHolder p = (RBNBBaseParameterHolder)e.nextElement();
            root.add(p.makeSwingTreeNode());
        }
        return (MutableTreeNode)root;
    }

}

---