Metacat

/**

 *      Name: QuerySpecification.java

 *   Purpose: A Class that represents a structured query, and can be 

 *            constructed from an XML serialization

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

 *            National Center for Ecological Analysis and Synthesis

 *   Authors: Matt Jones

 *

 *   Version: '$Id: QuerySpecification.java 159 2000-06-15 01:55:28Z jones $'

 */

package edu.ucsb.nceas.metacat;

import java.io.*;

import java.util.Stack;

import java.util.Vector;

import java.util.Enumeration;

import org.xml.sax.AttributeList;

import org.xml.sax.InputSource;

import org.xml.sax.HandlerBase;

import org.xml.sax.Parser;

import org.xml.sax.SAXException;

import org.xml.sax.SAXParseException;

import org.xml.sax.helpers.ParserFactory;

//import oracle.xml.parser.v2.SAXParser;

/** 

 * A Class that represents a structuredd query,and can be constructed from an

 * XML serialization

 */

public class QuerySpecification extends HandlerBase {

  /** Default parser name. */

  private static final String

      DEFAULT_PARSER = "org.apache.xerces.parsers.SAXParser";

      //DEFAULT_PARSER = "oracle.xml.parser.v2.SAXParser";

  // Query data structures

  private String meta_file_id;

  private String querytitle;

  private QueryGroup query = null;

  private Stack elementStack;

  private Stack queryStack;

  private String currentValue;

  private String currentPathexpr;

  /**

   * construct an instance of the QuerySpecification class 

   *

   * @param queryspec the XML representation of the query as a Reader

   */

  public QuerySpecification( Reader queryspec ) throws IOException {

    super();

    // Initialize the stack

    elementStack = new Stack();

    queryStack   = new Stack();

    // Initialize the parser and read the queryspec

    Parser parser = initializeParser();

    try {

      parser.parse(new InputSource(queryspec));

    } catch (SAXException e) {

      System.out.println("error parsing data");

      System.out.println(e.getMessage());

    }

  }

  /**

   * construct an instance of the QuerySpecification class 

   *

   * @param queryspec the XML representation of the query as a String

   */

  public QuerySpecification( String queryspec ) throws IOException {

    this(new StringReader(queryspec));

  }

  /** Main routine for testing */

  static public void main(String[] args) {

     if (args.length < 1) {

       System.err.println("Wrong number of arguments!!!");

       System.err.println("USAGE: java QuerySpecification <xmlfile>");

       return;

     } else {

       String xmlfile  = args[0];

       try {

         FileReader xml = new FileReader(new File(xmlfile));

         QuerySpecification qspec = new QuerySpecification(xml);

         System.out.println(qspec);

       } catch (IOException e) {

         System.err.println(e.getMessage());

       }

     }

  }

  private Parser initializeParser() {

    Parser parser = null;

    //

    // Set up the SAX document handlers for parsing

    //

    try {

      // Get an instance of the parser

      parser = ParserFactory.makeParser(DEFAULT_PARSER);

      // Set the DocumentHandler to this instance

      parser.setDocumentHandler(this);

      // Set the other Handler to the defHandler

      parser.setErrorHandler(this);

    } catch (Exception e) {

       System.err.println(e.toString());

    }

    return parser;

  }

  public void startElement (String name, AttributeList atts) 

         throws SAXException {

    BasicNode currentNode = new BasicNode(name);

    // add attributes to BasicNode here

    if (atts != null) {

      int len = atts.getLength();

      for (int i = 0; i < len; i++) {

        currentNode.setAttribute(atts.getName(i), atts.getValue(i));

      }

    }

    elementStack.push(currentNode); 

    if (currentNode.getTagName().equals("querygroup")) {

      QueryGroup currentGroup = new QueryGroup(

                                currentNode.getAttribute("booleantype"));

      if (query == null) {

        query = currentGroup;

      } else {

        QueryGroup parentGroup = (QueryGroup)queryStack.peek();

        parentGroup.addChild(currentGroup);

      }

      queryStack.push(currentGroup);

    }

  }

  public void endElement (String name) throws SAXException {

    BasicNode leaving = (BasicNode)elementStack.pop(); 

    if (leaving.getTagName().equals("queryterm")) {

      boolean isCaseSensitive = (new Boolean(

              leaving.getAttribute("casesensitive"))).booleanValue();

      QueryTerm currentTerm = null;

      if (currentPathexpr == null) {

        currentTerm = new QueryTerm(isCaseSensitive,

                      leaving.getAttribute("searchmode"),currentValue);

      } else {

        currentTerm = new QueryTerm(isCaseSensitive,

                      leaving.getAttribute("searchmode"),currentValue,

                      currentPathexpr);

      }

      QueryGroup currentGroup = (QueryGroup)queryStack.peek();

      currentGroup.addChild(currentTerm);

      currentValue = null;

      currentPathexpr = null;

    } else if (leaving.getTagName().equals("querygroup")) {

      QueryGroup leavingGroup = (QueryGroup)queryStack.pop();

    }

  }

  public void characters(char ch[], int start, int length) {

    String inputString = new String(ch, start, length);

    BasicNode currentNode = (BasicNode)elementStack.peek(); 

    String currentTag = currentNode.getTagName();

    if (currentTag.equals("meta_file_id")) {

      meta_file_id = inputString;

    } else if (currentTag.equals("querytitle")) {

      querytitle = inputString;

    } else if (currentTag.equals("value")) {

      currentValue = inputString;

    } else if (currentTag.equals("pathexpr")) {

      currentPathexpr = inputString;

    }

  }

  public String toString() {

    return "meta_file_id=" + meta_file_id + "\n" + 

           "querytitle=" + querytitle + "\n" + query;

  }

  /** a utility class that represents a group of terms in a query */

  private class QueryGroup {

    private String booleantype = null; // indicates how query terms are combined

    private Vector children = null;    // the list of query terms and groups

    public QueryGroup(String booleantype) {

      this.booleantype = booleantype;

      children = new Vector();

    }

    public void addChild(QueryGroup qgroup) {

      children.add((Object)qgroup); 

    }

    public void addChild(QueryTerm qterm) {

      children.add((Object)qterm); 

    }

    public Enumeration getChildren() {

      return children.elements();

    }

    public String toString() {

      StringBuffer self = new StringBuffer();

      self.append("  (Query group booleantype=" + booleantype + "\n");

      Enumeration en= getChildren();

      while (en.hasMoreElements()) {

        Object qobject = en.nextElement();

        self.append(qobject);

      }

      self.append("  )\n");

      return self.toString();

    }

  }

  /** a utility class that represents a single term in a query */

  private class QueryTerm {

    private boolean casesensitive = false;

    private String searchmode = null;

    private String value = null;

    private String pathexpr = null;

    public QueryTerm(boolean casesensitive, String searchmode, 

                     String value) {

      this.casesensitive = casesensitive;

      this.searchmode = searchmode;

      this.value = value;

    }

    public QueryTerm(boolean casesensitive, String searchmode, 

                     String value, String pathexpr) {

      this(casesensitive, searchmode, value);

      this.pathexpr = pathexpr;

    }

    public boolean isCaseSensitive() {

      return casesensitive;

    }

    public String getSearchMode() {

      return searchmode;

    }

    public String getValue() {

      return value;

    }

    public String getPathExpression() {

      return pathexpr;

    }

    public String toString() {

      StringBuffer self = new StringBuffer();

      self.append("    Query Term iscasesensitive=" + casesensitive + "\n");

      self.append("               searchmode=" + searchmode + "\n");

      self.append("               value=" + value + "\n");

      if (pathexpr != null) {

        self.append("               pathexpr=" + pathexpr + "\n");

      }

      return self.toString();

    }

  }

}