Changeset 12644


Ignore:
Timestamp:
2006-09-01T12:13:59+12:00 (18 years ago)
Author:
mdewsnip
Message:

Moved the new classifiers stuff out into a new static class (greenstone.Classifiers) in preparation for extending it to do collection-specific classifiers.

Location:
trunk/gli/src/org/greenstone/gatherer
Files:
1 added
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/gli/src/org/greenstone/gatherer/Gatherer.java

    r12642 r12644  
    3838import org.greenstone.gatherer.Configuration;
    3939import org.greenstone.gatherer.GAuthenticator;
    40 import org.greenstone.gatherer.cdm.ClassifierManager;
    4140import org.greenstone.gatherer.collection.CollectionManager;
    4241import org.greenstone.gatherer.feedback.ActionRecorderDialog;
    … …  
    4443import org.greenstone.gatherer.file.FileAssociationManager;
    4544import org.greenstone.gatherer.file.RecycleBin;
     45import org.greenstone.gatherer.greenstone.Classifiers;
    4646import org.greenstone.gatherer.greenstone.Plugins;
    4747import org.greenstone.gatherer.gui.GUIManager;
    … …  
    436436
    437437    // Get a list of the core Greenstone classifiers and plugins
    438     ClassifierManager.loadClassifiersList();
     438    Classifiers.loadClassifiersList();
    439439    Plugins.loadPluginsList();
    440440    }

  • trunk/gli/src/org/greenstone/gatherer/cdm/Classifier.java

    r12635 r12644  
    2929import java.io.*;
    3030import java.util.*;
     31import org.greenstone.gatherer.greenstone.Classifiers;
    3132import org.greenstone.gatherer.util.StaticStrings;
    3233import org.greenstone.gatherer.util.Utility;
    … …  
    6162    String classifier_name = element.getAttribute(StaticStrings.TYPE_ATTRIBUTE);
    6263    // Determine the base classifier from the classifier name
    63     Classifier base_classifier = ClassifierManager.getClassifier(classifier_name, true);
     64    Classifier base_classifier = Classifiers.getClassifier(classifier_name, true);
    6465    Classifier classifier = new Classifier(element, base_classifier);
    6566    if (base_classifier == null) {

  • trunk/gli/src/org/greenstone/gatherer/cdm/ClassifierManager.java

    r12641 r12644  
    4141import org.greenstone.gatherer.Gatherer;
    4242import org.greenstone.gatherer.LocalGreenstone;
     43import org.greenstone.gatherer.greenstone.Classifiers;
    4344import org.greenstone.gatherer.gui.DesignPaneHeader;
    4445import org.greenstone.gatherer.gui.GComboBox;
    … …  
    5960    extends DOMProxyListModel
    6061{
    61     // A list of all the classifiers in the core Greenstone "perllib/classify" folder (arguments may not be loaded)
    62     static private ArrayList core_greenstone_classifiers_list = null;
    63 
    6462    /** The controls for editing the contents of this manager. */
    6563    private Control controls = null;
    … …  
    7674    DebugStream.println("ClassifierManager: " + getSize() + " classifiers parsed.");
    7775
    78     // core_greenstone_classifiers_list = loadClassifiersList();
    79 
    8076    // Force the assigned classifiers to be loaded and cached now
    8177    for (int i = 0; i < getSize(); i++) {
    … …  
    8379    }
    8480    }
    85 
    86 
    87     // --------------------------------------------------------------------------------------------------------
    8881
    8982
    … …  
    9487
    9588    // Add all the non-abstract core Greenstone classifiers
    96     for (int i = 0; i < core_greenstone_classifiers_list.size(); i++) {
    97         Classifier classifier = (Classifier) core_greenstone_classifiers_list.get(i);
     89    ArrayList classifiers_list = Classifiers.getClassifiersList();
     90    for (int i = 0; i < classifiers_list.size(); i++) {
     91        Classifier classifier = (Classifier) classifiers_list.get(i);
    9892        if (!classifier.isAbstract()) {
    9993        available.add(classifier);
    … …  
    106100    return available.toArray();
    107101    }
    108 
    109 
    110     static public Classifier getClassifier(String classifier_name, boolean arguments_required)
    111     {
    112     for (int i = 0; i < core_greenstone_classifiers_list.size(); i++) {
    113         Classifier classifier = (Classifier) core_greenstone_classifiers_list.get(i);
    114         if (classifier.getName().equals(classifier_name)) {
    115         if (arguments_required) {
    116             if (classifier.getArguments().size() == 0) {
    117             loadClassifierInfo(classifier);
    118             }
    119             else {
    120             DebugStream.println("Already loaded arguments for " + classifier_name + "!");
    121             }
    122         }
    123         return classifier;
    124         }
    125     }
    126 
    127     return null;
    128     }
    129 
    130 
    131     static private void loadClassifierInfo(Classifier classifier)
    132     {
    133     DebugStream.println("Loading arguments for " + classifier.getName() + "...");
    134 
    135     // Run classifierfo.pl to get the list of classifiers
    136     try {
    137         StringBuffer xml = null;
    138         if (Gatherer.isGsdlRemote) {
    139         String classinfo_output = RemoteGreenstoneServer.getScriptOptions("classinfo.pl", "&classifier=" + classifier);
    140         xml = new StringBuffer(classinfo_output);
    141         }
    142         else {
    143         ArrayList args = new ArrayList();
    144         if (Utility.isWindows()) {
    145             args.add(Configuration.perl_path);
    146             args.add("-S");
    147         }
    148         args.add(LocalGreenstone.getBinScriptDirectoryPath() + "classinfo.pl");
    149         args.add("-xml");
    150         args.add("-language");
    151         args.add(Configuration.getLanguage());
    152         args.add(classifier.getName());
    153 
    154         // Run the classinfo.pl process
    155         Runtime runtime = Runtime.getRuntime();
    156         Process process = runtime.exec((String[]) args.toArray(new String[] { }));
    157         InputStream input_stream = process.getErrorStream();
    158         xml = XMLTools.readXMLStream(input_stream);
    159         }
    160 
    161         if (xml.length() > 0) {
    162         parseClassifierInfoXML(classifier, xml.toString());
    163         }
    164         else {
    165         JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("CDM.ClassifierManager.Classifier_XML_Parse_Failed", classifier.getName()), Dictionary.get("General.Error"), JOptionPane.ERROR_MESSAGE);
    166         }
    167     }
    168     catch (Exception exception) {
    169         DebugStream.printStackTrace(exception);
    170     }
    171     }
    172 
    173 
    174     static public void loadClassifiersList()
    175     {
    176     DebugStream.println("In loadClassifiersList()...");
    177 
    178     // Run classifierfo.pl to get the list of classifiers
    179     try {
    180         StringBuffer xml = null;
    181         if (Gatherer.isGsdlRemote) {
    182         String classinfo_output = RemoteGreenstoneServer.getScriptOptions("classinfo.pl", "&listall");
    183         xml = new StringBuffer(classinfo_output);
    184         }
    185         else {
    186         ArrayList args = new ArrayList();
    187         if (Utility.isWindows()) {
    188             args.add(Configuration.perl_path);
    189             args.add("-S");
    190         }
    191         args.add(LocalGreenstone.getBinScriptDirectoryPath() + "classinfo.pl");
    192         args.add("-listall");
    193         args.add("-xml");
    194 
    195         // Run the classinfo.pl process
    196         Runtime runtime = Runtime.getRuntime();
    197         Process process = runtime.exec((String[]) args.toArray(new String[] { }));
    198         InputStream input_stream = process.getErrorStream();
    199         xml = XMLTools.readXMLStream(input_stream);
    200         }
    201 
    202         if (xml.length() > 0) {
    203         core_greenstone_classifiers_list = parseClassifiersListXML(xml.toString());
    204         }
    205         else {
    206         JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("CDM.ClassifierManager.Classifier_List_XML_Parse_Failed"), Dictionary.get("General.Error"), JOptionPane.ERROR_MESSAGE);
    207         }
    208     }
    209     catch (Exception exception) {
    210         DebugStream.printStackTrace(exception);
    211     }
    212     }
    213 
    214 
    215     static private void parseClassifierInfoXML(Classifier classifier, String xml)
    216     {
    217     Document document = XMLTools.parseXML(new StringReader(xml));
    218     parseClassifierInfoXMLNode(classifier, document.getDocumentElement());
    219     }
    220 
    221 
    222     static private void parseClassifierInfoXMLNode(Classifier classifier, Node root_node)
    223     {
    224     for (Node node = root_node.getFirstChild(); node != null; node = node.getNextSibling()) {
    225         String node_name = node.getNodeName();
    226 
    227         if (node_name.equalsIgnoreCase("Name")) {
    228         classifier.setName(XMLTools.getValue(node));
    229         }
    230         else if (node_name.equals("Desc")) {
    231         classifier.setDescription(XMLTools.getValue(node));
    232         }
    233         else if (node_name.equals("Abstract")) {
    234         classifier.setIsAbstract(XMLTools.getValue(node).equalsIgnoreCase(StaticStrings.YES_STR));
    235         }
    236         // Parse the classifier arguments
    237         else if (node_name.equalsIgnoreCase("Arguments")) {
    238         for (Node argument_node = node.getFirstChild(); argument_node != null; argument_node = argument_node.getNextSibling()) {
    239             // An option
    240             if (argument_node.getNodeName().equalsIgnoreCase("Option")) {
    241             Argument argument = new Argument();
    242             argument.parseXML((Element) argument_node);
    243             classifier.addArgument(argument);
    244             }
    245         }
    246         }
    247         // A super classifier class
    248         else if (node_name.equalsIgnoreCase("ClassInfo")) {
    249         Classifier super_classifier = new Classifier();
    250         parseClassifierInfoXMLNode(super_classifier, node);
    251         classifier.setSuper(super_classifier);
    252         }
    253     }
    254     }
    255 
    256 
    257     static private ArrayList parseClassifiersListXML(String xml)
    258     {
    259     ArrayList classifiers_list = new ArrayList();
    260 
    261     Document document = XMLTools.parseXML(new StringReader(xml));
    262     Node root = document.getDocumentElement();
    263     for (Node node = root.getFirstChild(); node != null; node = node.getNextSibling()) {
    264         String node_name = node.getNodeName();
    265 
    266         if (node_name.equals("ClassInfo")) {
    267         Classifier classifier = new Classifier();
    268         parseClassifierInfoXMLNode(classifier, node);
    269         classifiers_list.add(classifier);
    270         }
    271     }
    272 
    273     return classifiers_list;
    274     }
    275 
    276 
    277     // --------------------------------------------------------------------------------------------------------
    278102
    279103
    … …  
    591415        {
    592416        // Retrieve the classifier
    593         Classifier classifier = getClassifier(classifier_name, true);
     417        Classifier classifier = Classifiers.getClassifier(classifier_name, true);
    594418        if (classifier == null) {
    595419            System.err.println("Error: getClassifier() returned null.");
Note: See TracChangeset for help on using the changeset viewer.