source: trunk/greenstone3-extensions/gs3build/src/org/greenstone/gsdl3/gs3build/classifier/ClassifierManager.java@ 12188

package org.greenstone.gsdl3.gs3build.classifier;

import java.util.List;
import java.util.Iterator;
import org.w3c.dom.Element;
import org.w3c.dom.Document;

import org.greenstone.gsdl3.gs3build.doctypes.DocumentID;
import org.greenstone.gsdl3.gs3build.doctypes.DocumentInterface;
import org.greenstone.gsdl3.gs3build.doctypes.DocumentList;
import org.greenstone.gsdl3.gs3build.database.GS3SQLConnection;
import org.greenstone.gsdl3.util.GSXML;


public class ClassifierManager
{
  DocumentList           documents;
  ClassifierInterface [] list;
  int                    size;
  int                    used;
  GS3SQLConnection       database;

  /**
   *  Instantiate a classifier manager that will classify the
   *  documents in a given <code>DocumentList</code> object.
   *  The list of documents should not change during the
   *  <code>classifyDocuments</code> function, and the documents
   *  themselves may be altered at that time.
   *
   *  @param <code>DocumentList</code> a provider of documents for
   *         classification.
   */
  public ClassifierManager(DocumentList documentList, GS3SQLConnection database)
  { this.list = new ClassifierInterface[10];
    this.size = 10;
    this.used = 0;
    this.documents = documentList;
    this.database  = database;
  }

  /**
   *  Add a classifier to the end of the list of classifiers...
   *
   *  @param <code>ClassifierInterface</code> the classifier.
   */
  public void addClassifier(ClassifierInterface classifier)
  { this.ensureSize(this.used + 1);
    this.list[this.used] = classifier;
    this.used ++;

    classifier.setDatabase(this.database);
  }

  /**
   *  Classify an individual document - the document itself may be written
   *  to in consequence, in which case the document <strong>must</strong>
   *  be rewritten to disk.  This function does <strong>not</strong> do the
   *  writing itself.
   *
   *  @param <code>DocumentID</code> the document's identifier.
   *  @param <code>DocumentInterface</code> the document itself.
   */
  public void classifyDocument(DocumentID docId, DocumentInterface document)
  { for (int i = 0; i < this.used; i ++)
    {   this.list[i].classifyDocument(docId, document);
    }
  }

  /**
   *  Classify all the documents that the document list is able to provide...
   */
  public void classifyDocuments()
  { for (int i = 0; i < this.used; i ++)
    { for (int p = 0; p < this.list[i].getClassifierPasses(); p ++)
      { this.list[i].startClassifierPass(p);

    Iterator iterator = this.documents.iterator();

    while (iterator.hasNext()) {
      DocumentInterface document = (DocumentInterface) iterator.next();

      if (document.isIndexed()) {
        if (!this.list[i].classifyDocument(document.getID(), document)) {
          System.out.println("Ending document");
        }
        
        if (document.isChanged()) {
          //          System.out.println("Writing document " + document.getID());
          this.documents.storeChangedDocument(document);
        }
      }
    }
    this.list[i].endClassifierPass(p);
      }
      this.list[i].completeClassification();
    }
  }

  public void ensureSize(int size)
  { while (size >= this.size)
    { ClassifierInterface newList [] = new ClassifierInterface[this.size*2];
      this.size *= 2;
      System.arraycopy(this.list, 0, newList, 0, this.size);
      this.list = newList;
    }
  }

  public static ClassifierInterface loadClassifier(String classifierName)
  { System.out.println("Loading classifier " + classifierName);
    try {
      ClassifierInterface classifier = 
    (ClassifierInterface) Class.forName("org.greenstone.gsdl3.gs3build.classifier."+classifierName+"Classifier").newInstance();
      return classifier;
    }
    catch (ClassNotFoundException ex) {
      System.err.println("Attempt to load classifier " + classifierName + " which does not exist");
    }
    catch (InstantiationException instEx) {
      System.err.println("Unable to create classifier " + classifierName);
    }
    catch (IllegalAccessException accessEx) {
      System.err.println("Unable to instantiate classifier " + classifierName + " due to permissions problems " + accessEx.toString());
    }
    return null;
  }
    
  public static ClassifierInterface loadClassifier(String classifierName, List params)
  { ClassifierInterface classifier = loadClassifier(classifierName);
    if (classifier != null) {
      classifier.configure(params);
    }
    return classifier;
  }

  public boolean addServiceDescriptions(Element service_class_list) {
    if (this.used==0) {
      // no classiifers
      return true;
    }
    Document owner_doc = service_class_list.getOwnerDocument();
    Element browse_service = owner_doc.createElement(GSXML.SERVICE_CLASS_ELEM);
    browse_service.setAttribute(GSXML.NAME_ATT, "GS3Browse");
    service_class_list.appendChild(browse_service);
    
    Element classifier_list = owner_doc.createElement(GSXML.CLASSIFIER_ELEM+GSXML.LIST_MODIFIER);
    browse_service.appendChild(classifier_list);
    boolean success = true;
    for (int i = 0; i < this.used; i ++) {
    if (!this.list[i].addClassifierDescription(classifier_list)) {
        success = false;
    }
    }
    return success;
  }
}