source: trunk/gsdl3/src/java/org/greenstone/gsdl3/gs3build/classifier/GS2HierarchyClassifier.java@ 6288

package org.greenstone.gsdl3.gs3build.classifier;

import java.io.*;

import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;

import org.xml.sax.XMLReader;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.Attributes;
import org.xml.sax.helpers.XMLReaderFactory;
import org.xml.sax.helpers.DefaultHandler;

import org.greenstone.gsdl3.gs3build.doctypes.DocumentID;
import org.greenstone.gsdl3.gs3build.doctypes.DocumentInterface;
import org.greenstone.gsdl3.gs3build.doctypes.DocumentLoader;
import org.greenstone.gsdl3.gs3build.util.XMLTools;
import org.greenstone.gsdl3.gs3build.util.GS2TextFileHandler;
import org.greenstone.gsdl3.gs3build.util.GS3SQLConnection;

public class GS2HierarchyClassifier implements ClassifierInterface
{ 
  class GS2HierarchyClassifierObserver implements ClassifierObserverInterface
  { List              classifications;
    DocumentInterface document;

    public GS2HierarchyClassifierObserver(DocumentInterface document)
    { this.document = document;
    }

    public void recordClassification(String label)
    { this.document.addDocumentMetadata("gsdl3", "classified", label);
      System.out.println("Assigned document " + this.document.getID().toString() + " to " + label);
    }

    public List getClassifications()
    { return this.classifications;
    }
  }

  class GS2HierarchyNode extends AbstractHierarchyNode
  { /**
     *  Simple node
     */
    public GS2HierarchyNode()
    { super();
    }
    
    public GS2HierarchyNode(String prefix, String name, String id, String descriptor)
    { super(prefix, name, id, descriptor);
    }
    
    /**
     *  Take a document, and find the classifications that it matches against in
     *  the current hierarchy.  
     *
     *  @param <code>DocumentID</code> the id of the document being classified
     *  @param <code>List</code> the values against which the classifier should
     *         test for the document being a match - i.e. the pertinent document
     *         property values.
     *  @param <code>ClassifierObserverInterface</code>
     *         object modifies the document with information about the
     *         classifications that it fell within.
     */
    public void getClassifications(DocumentID documentID, List values, 
                   ClassifierObserverInterface observer)
    { // Go through the list of values, and if this node matches, record
      // the fact in the classifier observer...
      Iterator valueList = values.iterator();

      while (valueList.hasNext())
      { if (this.isMatch(valueList.next().toString()))
    { observer.recordClassification(this.name);
      this.addDocument(documentID);
    }
      }
     
      // recurse into the child nodes for them to do the same...
      Iterator childList = this.childNodes.iterator();

      while (childList.hasNext())
      { ((GS2HierarchyNode) childList.next()).getClassifications(documentID, values, observer);
      }
    }
  }

  /**
   *  An inner class to handle Classifier files
   */
  class GS2HierarchyHandler extends GS2TextFileHandler
  { GS2HierarchyNode rootNode = null;

    GS2HierarchyHandler(String hierarchyName, String content)
    { super(content);
 
      this.rootNode = new GS2HierarchyNode();
      String prefix = "CL"+hierarchyName;

      while (this.hasMoreLines()) {
    String description;
    String name, id;

    this.getLine();
    
    name = this.getEntry(true);
    if (name == null || name.length() == 0) {
      continue;
    }

    id = this.getEntry(true);
    if (id == null || id.length() == 0) {
      continue;
    }

    description = this.getEntry(true);
    if (description == null || description.length() == 0) {
      continue;
    }
    
    // Initialise the tree
    GS2HierarchyNode node = new GS2HierarchyNode(prefix, name, id, description);

    this.rootNode.add(node);
      }
    }

    public GS2HierarchyNode getHierarchy()
    { return this.rootNode;
    }
  }

  private          GS2HierarchyNode hierarchy;
  List             fields;
  String           sortBy;
  GS3SQLConnection database;

  public GS2HierarchyClassifier()
  { // a 'do nothing' constructor which takes more information from configure...
    this.fields = new ArrayList();
    this.database = null;
  }

  public GS2HierarchyClassifier(File file)
  { 
    String documentText = 
      DocumentLoader.getAsString(file);
    
    if (documentText == null) {
      System.err.println("GS2HierarchyClassifier: Unable to load any content for " + file);
      return;
    }

    GS2HierarchyHandler handler = new GS2HierarchyHandler("CL", documentText);

    this.hierarchy = handler.getHierarchy();
    this.fields = new ArrayList();
    System.out.println("loaded hierarchy for "+ file.toString());
    this.database = null;
  }

  public void setDatabase(GS3SQLConnection database)
  { this.database = database;
  }

  public void configure(List parameters)
  {
    File file = null;
    
    Iterator iterator = parameters.iterator();
    while (iterator.hasNext()) {
      String param = iterator.next().toString();

      if (param.equals("-metadata")) {
    if (iterator.hasNext()) {
      String field = iterator.next().toString();
      if (field != null && field.length() > 0) {
        this.fields.add(field);
      }
    }
      }
      else if (param.equals("-hfile")) {
    // this parameter had better have been expanded previously to a full path,
    // as we're not going to do that here!!!
    if (iterator.hasNext()) {
      file = new File(iterator.next().toString());
    }
      }
      else if (param.equals("-sort")) {
    if (iterator.hasNext()) {
      String sort = iterator.next().toString();
      if (sort != null && sort.length() > 0) {
        this.sortBy = sort;
      }
    }
      }
    }

    if (file == null) {
      return;
    }

    String documentText = 
      DocumentLoader.getAsString(file);
    
    if (documentText == null) {
      System.err.println("GS2HierarchyClassifier: Unable to load any content for " + file);
      return;
    }

    GS2HierarchyHandler handler = new GS2HierarchyHandler(this.fields.get(0).toString(), documentText);

    this.hierarchy = handler.getHierarchy();    
  }

  /**
   *  Classify a particular document - the document id will be used to record its
   *  membership of any classifier nodes, and the document interface will also be
   *  used to assign back knowledge of any classifiers to which the document is
   *  assigned.
   *
   *  @param <code>DocumentID</code> the document identifier
   *  @param <code>DocumentInterface</code> the document interface
   */
  public boolean classifyDocument(DocumentID documentID, DocumentInterface document)
  { if (this.hierarchy == null) {
      return true;
    }
    
    // the observer records the assignment of documents to classifications
    GS2HierarchyClassifierObserver classifyObserver = new GS2HierarchyClassifierObserver(document);
        
    // get the metadata item from the document
    Iterator thisField = this.fields.iterator();

    // for every field listed as being a scannable field...
    while (thisField.hasNext())
    { String fieldName = thisField.next().toString();
            
      // ...get the values for that field...
      List values = document.getDocumentMetadataItem(fieldName);

      if (values == null)
      { continue;
      }

      System.out.println("Matching " + values.get(0).toString());

      if (documentID == null) {
    System.out.println("Bad documentID");
    continue;
      }

      // ...and send them to the classifier
      this.hierarchy.getClassifications(documentID, values, classifyObserver);
    }
    return true;
  }

  public int getClassifierPasses()
  { return 1;
  }

  public void startClassifierPass(int pass)
  {
  }
  
  public void endClassifierPass(int pass)
  {
  }
  
  public void completeClassification()
  { // TODO: store the classifications to file...

    // The hierarchy member may be null if the classifier did not initialise correctly...
    if (this.hierarchy != null) {
      this.hierarchy.writeSQL(this.database);
    }
  }
}