source: other-projects/trunk/gs3-webservices-democlient/src/GS3DemoClient/org/greenstone/gs3client/data/ClassifierNodeData.java@ 15222

/**
 *#########################################################################
 * ClassifierNodeData.java - part of the demo-client for Greenstone 3, of 
 * the Greenstone digital library suite from the New Zealand Digital 
 * Library Project at the  * University of Waikato, New Zealand.
 * <BR><BR>
 * Copyright (C) 2008 New Zealand Digital Library Project
 * <BR><BR>
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * <BR><BR>
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *########################################################################
 */

package org.greenstone.gs3client.data;

import java.util.Vector;
import java.util.Map;
import java.util.HashMap;

import org.greenstone.gs3client.data.NodeData;
import org.w3c.dom.Element;

/** 
 * ClassifierNodeData represents the information that can be stored in a   
 * &lt;classifierNode&gt; element. A ClassifierNode may have children and
 * further descendents of type NodeData: either of type DocumentNodeData  
 * or type ClassifierNodeData.
 * @author ak19
*/
public class ClassifierNodeData extends NodeData {
    /** Children (of this NodeData) as given in a nodeStructure, which 
     * can be ClassifierNodeData or DocumentNodeData. */
    NodeData[] childnodes = null; 
    
    /** Constructor that given a classifierNode element creates
     * a ClassifierNodeData instance to parse and store its data. 
     * A classifierNodeData &lt;classifierNode&gt; contains just a nodeID
     * and can contain children. When a response for a classifierNode's
     * children is returned in a &lt;nodeStructure&gt;, this can be used to 
     * set the children. 
     * This classifierNodeData object is constructed from the data 
     * encapsulated in a &lt;classifierNode&gt; element 
     * @param classifierNodeTag is the &lt;classifierNode&gt; element in a 
     * Greenstone3 response XML message */
    public ClassifierNodeData(Element classifierNodeTag) {
        super(classifierNodeTag);
    }
    
    /** This method is mainly useful for setting the top-level/root 
     * classifierNode's name. Otherwise, can use method setMetadataList
     * to set the various metadata (name, values) associated with a
     * classifierNode.
     * Adds a new title to nodeMetadata as long as it is not the same 
     * as the previous title added. 
     * @param name is the previous title added */
    public void setTitle(String name) {
        if(nodeMetadata == null) 
            nodeMetadata = new HashMap();
        // the nodeMetadata hashmap exists
        Vector values;
        if(nodeMetadata.containsKey("Title")) {
            values = (Vector)nodeMetadata.get("Title");
            // check if the last value is the same as
            // what we're trying to insert
            String value = (String)values.get(values.size()-1);
            if(!value.equals(name)) // don't add duplicates
                values.add(name);
        } else {
            values = new Vector();
            values.add(name);
            this.nodeMetadata.put("Title", values);
        }
    }
    
    /** Given a map of nodeIdsToNodes, this method instantiates any
     * children this ClassifierNodeData object might have. This
     * method will set member childnodes (or leave it at none)
     * and update idsToNodes_map as necessary.
     * @param idsToNodes_map is a Hashmap of all the Node IDs to Node
     * objects being maintained (Classifier- or DocumentNode) */
    public void setChildren(Map idsToNodes_map) {
        Vector children = new Vector();
        setChildren(children, idsToNodes_map);
        
        if(children.size() == 0) // then childnodes[] remains at null
            return;
        // else
        childnodes = new NodeData[children.size()];
        children.toArray(childnodes); // now childnodes[] contains what's
                                    // in the Vector children
        
        // now update the idsToNodes_map with any new nodes
        for(int i = 0; i < childnodes.length; i++)
            if(!idsToNodes_map.containsKey(childnodes[i].nodeID))
                idsToNodes_map.put(childnodes[i].nodeID, childnodes[i]);
    }
    
    /** Gets the children of this node, but does not guarantee that *their*
     * children are set. Will return null either if this NodeData has no 
     * children or if this node's children are not set yet. 
     * @return an array of all the child Nodes of this ClassifierNode
     * (as per its hierarchical structure) or null if these are not yet set
     * or if it has no children */
    public NodeData[] getChildren() { return childnodes; }
    
    /**@return a string representation of the values stored in this 
     * ClassifierNodeData object: outputs the nodeID and calls show() on any 
     * children NodeData objects. It's mainly useful for debugging purposes. */
    public String show() {
        StringBuffer buf = new StringBuffer(super.show());
        buf.append(showMeta());
        if(this.childnodes != null) {
            for(int i = 0; i < this.childnodes.length; i++) 
                buf.append("\n " + this.childnodes[i].show());
        }
        return buf.toString();
    }   
}