Metacat

/**

 *  '$RCSfile$'

 *    Purpose: A Class that represents an XML Text node and its contents,

 *             and can build itself from a database connection

 *  Copyright: 2000 Regents of the University of California and the

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Matt Jones

 *    Release: @release@

 *

 *   '$Author$'

 *     '$Date$'

 * '$Revision$'

 *

 * 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.

 *

 * 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.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

package edu.ucsb.nceas.metacat;

import java.util.Collections;

import java.sql.SQLException;

import java.sql.ResultSet;

/**

 * A Class that represents an Filtered XML Subtree, it means a subtree which

 * contains another subtree has different access behavor to it.

 * for example, we have subtree A, it is not readable to user John. But in

 * subtree A, it contains a subtree B which is readable to user John

 */

public class FilteredSubTree

{

  private String docId = null;

  private String subTreeId = null;

  private String startElementName = null;

  private long   startNodeId = -1;

  private long   endNodeId =   -1;

    /**

    public FilteredSubTree(String myDocId, String mySubTreeId,

                  long myStartNodeId, long myEndNodeId)

                  throws McdbException

    {

      this.docId = myDocId;

      MetaCatUtil.debugMessage("Docid of FilteredSubtree: " + docId, 30);

      this.subTreeId = mySubTreeId;

      MetaCatUtil.debugMessage("id of FilteredSubtree: " + subTreeId, 30);

      this.startNodeId = myStartNodeId;

      MetaCatUtil.debugMessage("start node id of FilteredSubtree: " +

                                startNodeId, 30);

      this.endNodeId = myEndNodeId;

      MetaCatUtil.debugMessage("end node id of FilteredSubtree: " + endNodeId, 30);

     }

    /** Set the a docId */

    public void setDocId(String myId)

    {

      MetaCatUtil.debugMessage("set doc id: "+myId, 35);

      this.docId = myId;

    }

    /** Get the docId */

    public String getDocId()

    {

      return this.docId;

    }

    /** Set the a subtreeId */

    public void setSubTreeId(String myId)

    {

      MetaCatUtil.debugMessage("set sub tree id: "+myId, 35);

      this.subTreeId = myId;

    }

    /** Get the subTreeId */

    public String getSubTreeId()

    {

      return this.subTreeId;

    }

    /**

     * Set a startElementName

     */

    public void setStartElementName(String elementName)

    {

      MetaCatUtil.debugMessage("set start elementname: "+elementName, 35);

      this.startElementName = elementName;

    }

    /**

     * Get startElementName

     */

    public String getStartElementName()

    {

      return this.startElementName;

    }

    /** Set a start node id */

    public void setStartNodeId(long nodeId)

    {

      MetaCatUtil.debugMessage("set start node id: "+nodeId, 35);

      this.startNodeId = nodeId;

    }

    /** Get start node id */

    public long getStartNodeId()

    {

      return this.startNodeId;

    }

    /** Set a end node id */

    public void setEndNodeId(long nodeId)

    {

      MetaCatUtil.debugMessage("set end node id: "+nodeId, 35);

      this.endNodeId = nodeId;

    }

    /** Get end node id */

    public long getEndNodeId()

    {

      return this.endNodeId;

    }

       // because the subtree is mergeEquivlent, so there is no nested subtree

       Enumeration en = tree.elements();

       while (en.hasMoreElements())

       {

         SubTree sTree = (SubTree) en.nextElement();

         sortedFilteredSubTree.add(sTree);

       }

       Collections.sort(sortedFilteredSubTree, new SubTree());

    public Vector getFilteredSubTree()

    {

      return sortedFilteredSubTree;

    }

    public Stack getUnfilteredSubTreeNodeList() throws McdbException

    {

       DBConnection dbconn = null;

       int serialNumber = -1;

       Stack nodeRecordList = new Stack();

       long nodeid = 0;

       long parentnodeid = 0;

       long nodeindex = 0;

       String nodetype = null;

       String nodename = null;

       String nodeprefix = null;

       String nodedata = null;

       String sql = "SELECT nodeid, parentnodeid, nodeindex, " +

                    "nodetype, nodename, nodeprefix, nodedata " +

       for ( int i =0; i< sortedFilteredSubTree.size(); i++)

       {

         sql = sql + "nodeid < ? ) OR (nodeid > ? AND ";

       }

       sql = sql + "nodeid <= ? )) ORDER BY nodeid DESC";

       MetaCatUtil.debugMessage("sql command for selecting filtere subtree is: "

                                 +sql, 25);

       {

         dbconn=DBConnectionPool.

                    getDBConnection("SubTree.getSubTreeNodeList");

         serialNumber=dbconn.getCheckOutSerialNumber();

         pstmt = dbconn.prepareStatement(sql);

         // Bind the values to the query

         pstmt.setString(1, docId);

         pstmt.setLong(2, startNodeId);

         boolean inLoop = false;

         for (i=0; i< sortedFilteredSubTree.size(); i++)

         {

           SubTree tree = (SubTree)sortedFilteredSubTree.elementAt(i);

           long startId = tree.getStartNodeId();

           long endId   = tree.getEndNodeId();

           pstmt.setLong((2*i+3), startId);

           pstmt.setLong((2*i+4), endId);

           inLoop = true;

         }

         if (inLoop)

         {

           pstmt.setLong((2*i+5), endNodeId);

         }

         else

         {

           pstmt.setLong(3, endNodeId);

         }

         pstmt.execute();

         ResultSet rs = pstmt.getResultSet();

         boolean tableHasRows = rs.next();

         while (tableHasRows)

         {

           nodeid = rs.getLong(1);

           parentnodeid = rs.getLong(2);

           nodeindex = rs.getLong(3);

           nodetype = rs.getString(4);

           nodename = rs.getString(5);

           nodeprefix = rs.getString(6);

           nodedata = rs.getString(7);

           nodedata = MetaCatUtil.normalize(nodedata);

           // add the data to the node record list hashtable

           NodeRecord currentRecord = new NodeRecord(nodeid,parentnodeid,nodeindex,

                                      nodetype, nodename, nodeprefix, nodedata);

           nodeRecordList.push(currentRecord);

           // Advance to the next node

           tableHasRows = rs.next();

         }//while

         pstmt.close();

      } //try

      catch (SQLException e)

      {

      }//catch

      finally

      {

        try

        {

          pstmt.close();

        }

        catch (SQLException ee)

        {

        }

        finally

        {

          DBConnectionPool.returnDBConnection(dbconn, serialNumber);

        }

      }//finally

      return nodeRecordList;

    }//getSubtreeNodeList

    public static void main (String agus)

    {

    }

}