Ignore:
Timestamp:
2006-07-19T14:51:13+12:00 (18 years ago)
Author:
kjdon
Message:

made ArgumentContainer a base class instead of an interface and moved all the shared code from Plugin and Classifier into it (ie most of these two classes). also removed custom stuff from classifier and plugin - no more custom ones allowed

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r11542 r12247  
    4343 */
    4444public class Classifier
    45     extends ArrayList
    46     implements ArgumentContainer, Comparable, DOMProxyListEntry, Serializable {
     45    extends ArgumentContainer {
     46   
    4747
    4848    static final public String CLASSIFIER_PREFIX = "CL";
    49 
    50     private boolean is_abstract = false;
    51 
    52     /** A reference to the classifier that this one inherits from. */
    53     private Classifier super_classifier = null;
    54     /** The element this classifier is based upon. */
    55     private Element element;
    56     /** A description of this classifier. */
    57     private String description = null;
    58     /** The name of the classifier as it would appear in the collect.cfg file. */
    59     private String name = null;
    60     /** This string is filled out the first time this classifier is created, and remains unchanged there-after. It is used to match up with Format commands that may not yet have been instantiated (and thus only have offline references along the lines of 'CL1' to figure out what Classifier they want.) */
    61     private String old_position_string = null;
    6249
    6350    /** Constructor used only in DOMProxyListModel initializations.
    … …  
    6552    public Classifier() {
    6653    }
    67 
     54   
    6855    public Classifier(Element element, Classifier base_classifier) {
    69     super();
    70     this.element = element;
    71     this.name = element.getAttribute(StaticStrings.TYPE_ATTRIBUTE);
    72     ///atherer.println("Establishing Classifier: " + name);
    73     // Parse in any argument options for this classifier, keeping a list of the ones found
    74     HashMap known_arguments = new HashMap();
    75     NodeList option_elements = element.getElementsByTagName(StaticStrings.OPTION_ELEMENT);
    76     int option_elements_length = option_elements.getLength();
    77     for(int i = 0; i < option_elements_length; i++) {
    78         Element option_element = (Element) option_elements.item(i);
    79         Argument argument = new Argument(option_element);
    80         ///atherer.println("Rebuilding existing argument: " + argument.getName());
    81         argument.setOwner(name);
    82         add(argument);
    83         known_arguments.put(argument.getName(), argument);
    84     }
    85     // If a base classifier was given
    86     if(base_classifier != null) {
    87         // Copy the details, and add a reference to whatever base_classifiers super classifier is.
    88         description = base_classifier.getDescription();
    89         // Now search through the 'dummy' arguments belonging to the base classifier. For each found, if it is already assigned, fill out further details such as type. If any are found that are not already assigned for this classifier, copy them and add them, but without a value.
    90         ArrayList all_arguments = base_classifier.getArguments(true, true);
    91         int argument_count = all_arguments.size();
    92         for(int j = 0; j < argument_count; j++) {
    93         Argument base_argument = (Argument) all_arguments.get(j);
    94         String base_argument_name = base_argument.getName();
    95         ///atherer.println("Library indicates this classifier should have an argument: " + base_argument_name);
    96         Argument existing_argument = (Argument) known_arguments.get(base_argument_name);
    97         // Found an existing argument. Complete its details
    98         if(existing_argument != null) {
    99             ///atherer.println("Found existing argument. Filling out details.");
    100             existing_argument.setCustomArgument(false);
    101             existing_argument.setDefaultValue(base_argument.getDefaultValue());
    102             existing_argument.setDescription(base_argument.getDescription());
    103             existing_argument.setOptions(base_argument.getOptions());
    104             existing_argument.setRequired(base_argument.isRequired());
    105             existing_argument.setType(base_argument.getType());
    106             existing_argument.setOwner(base_argument.getOwner());
    107             existing_argument.setHiddenGLI(base_argument.isHiddenGLI());
    108         }
    109         // No existing argument. Copy base_argument and add it, but do not set its assigned flag. That should be set the first time its changed by the user.
    110         else {
    111             ///atherer.println("No such argument. Adding new, unassigned, argument.");
    112             // The trick thing is that we have to create a new element in the DOM as well.
    113             Argument new_argument = base_argument.copy();
    114             //new_argument.setOwner(name);
    115             Element argument_element = CollectionDesignManager.collect_config.document.createElement(StaticStrings.OPTION_ELEMENT);
    116             argument_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, base_argument_name);
    117             argument_element.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.FALSE_STR);
    118             argument_element.setAttribute(StaticStrings.CUSTOM_ATTRIBUTE, StaticStrings.FALSE_STR);
    119             new_argument.setElement(argument_element);
    120             // All done. Add it.
    121             element.appendChild(argument_element);
    122             add(new_argument);
    123         }
    124         }
    125     }
    126     old_position_string = getPositionString();
    127     }
    128 
    129     /** Constructor.
    130      * @param name The name of this classifier as a <strong>String</strong>.
    131      * @param description A description of this classifier as a <strong>String</strong>.
    132      * @param super_classifier The super class of this classifier, as a <strong>Classifier</strong>.
    133      */
    134     public Classifier(String name, String description, Classifier super_classifier) {
    135     super();
    136     this.description = description;
    137     this.name = name;
    138     this.super_classifier = super_classifier;
    139     }
    140 
    141     /** Method to add an argument to this classifier. Only adds the argument if it isn't already present.
    142      * @param argument The <strong>Argument</strong> to add.
    143      */
    144     public void addArgument(Argument argument) {
    145     if(element == null && !contains(argument)) {
    146         add(argument);
    147         argument.setOwner(name);
    148     }
    149     }
    150 
    151     /** Method to compare two classifiers for ordering.
    152      * @param object The classifier we are comparing to, as an <strong>Object</strong>.
    153      * @return An <i>int</i> specifying the classifier order, using values as set out in String.
    154      * @see java.lang.String#compareTo
    155      */
    156     public int compareTo(Object object) {
    157     if(object == null) {
    158         return -1;
    159     }
    160     return toString().compareTo(object.toString());
     56    super(element, base_classifier);
    16157    }
    16258
    … …  
    16965    Classifier base_classifier = CollectionDesignManager.classifier_manager.getBaseClassifier(classifier_name);
    17066    Classifier classifier = new Classifier(element, base_classifier);
     67    if (base_classifier == null) {
     68        // this is kind of a place holder classifier for one which is invalid. It won't get written out to the config file when its next saved.
     69        classifier.setAssigned(false);
     70    }
    17171    base_classifier = null;
    17272    classifier_name = null;
    17373    return classifier;
    17474    }
    175 
    176     /** Method to determine if two classifiers are equal.
    177      * @param object The classifier to test against, as an <strong>Object</strong>.
    178      * @return <i>true</i> if the classifier names match, <i>false</i> otherwise.
    179      */
    180     public boolean equals(Object object) {
    181     return (compareTo(object) == 0);
    182     }
    183 
    184     /** Method to retrieve an argument by its name.
    185      * @param name The name of the argument as a <strong>String</strong>.
    186      * @return The <strong>Argument</strong> requested, or <i>null</i> if no such argument.
    187      */
    188     public Argument getArgument(String name) {
    189     // The name given may still include the '-'
    190     if(name.startsWith("-")) {
    191         name = name.substring(1);
    192     }
    193     ArrayList arguments = getArguments(true, true);
    194     for(int i = 0; i < arguments.size(); i++) {
    195         Argument argument = (Argument)arguments.get(i);
    196         if(argument.getName().equals(name)) {
    197         return argument;
    198         }
    199     }
    200     return null;
    201     }
    202 
    203      /** Retrieve all of the arguments available to this base classifier, including its super classifiers arguments. Some complexity is added by allowing the caller to choose whether they want normal arguments, custom arguments, or both.
    204       * @return an ArrayList of all of the arguments, starting with those for this classifier and ending with the arguments for basplug or similiar root classifier
    205       */
    206     public ArrayList getArguments(boolean include_normal, boolean include_custom) {
    207     ArrayList arguments = new ArrayList();
    208     if(include_normal && include_custom) {
    209         arguments.addAll(this);
    210     }
    211     else {
    212         int size = size();
    213         for(int i = 0; i < size; i++) {
    214         Argument argument = (Argument) get(i);
    215         if(argument.isCustomArgument()) {
    216             if(include_custom && !arguments.contains(argument)) {
    217             arguments.add(argument);
    218             }
    219         }
    220         else {
    221             if(include_normal && !arguments.contains(argument)) {
    222             arguments.add(argument);
    223             }
    224         }
    225         argument = null;
    226         }
    227     }
    228     if(super_classifier != null) {
    229         ArrayList remainder = super_classifier.getArguments(include_normal, include_custom);
    230         remainder.removeAll(arguments);
    231         arguments.addAll(remainder);
    232     }
    233     return arguments;
    234     }
    235 
    236     /** Method to retrieve a classifiers custom argument information. Custom arguments are defined to be those that have not got matching arguments in the base reference classifier from the library. Of course if there is no base classifier then all arguments are considered to be custom.
    237      * @return the custom arguments as a String
    238      */
    239     public String getCustom() {
    240     StringBuffer custom_text = new StringBuffer();
    241     // Retrieve all of the arguments, and append any that are custom into one long string
    242     ArrayList arguments = getArguments(false, true);
    243     int arguments_size = arguments.size();
    244     boolean first = true;
    245     for(int i = 0; i < arguments_size; i++) {
    246         Argument argument = (Argument) arguments.get(i);
    247         if(argument.isAssigned()) {
    248         if(!first) {
    249             custom_text.append(" ");
    250         }
    251         custom_text.append(argument.toString());
    252         first = false;
    253         }
    254     }
    255     return custom_text.toString();
    256     }
    257 
    258     public String getDescription() {
    259     return description;
    260     }
    261 
    262     public Element getElement() {
    263     return element;
    264     }
    265 
    266     /** Method to retrieve a classifiers name.
    267      * @return A <strong>String</strong> containing the classifiers name.
    268      */
    269     public String getName() {
    270     if(name == null && element != null) {
    271         name = element.getAttribute(StaticStrings.TYPE_ATTRIBUTE);
    272     }
    273     return name;
    274     }
    275 
    276     /* private String getOldPositionString() {
    277     return old_position_string;
    278     } */
    27975
    28076    /** Generate the string showing this classifiers position. */
    … …  
    29187    }
    29288
    293     public boolean isAbstract() {
    294     return is_abstract;
    295     }
    296 
    297     public boolean isAssigned() {
    298     return (element != null && !element.getAttribute(CollectionConfiguration.ASSIGNED_ATTRIBUTE).equals(CollectionConfiguration.FALSE_STR));
    299     }
    300 
    301     public void setAssigned(boolean assigned) {
    302     if(element != null) {
    303         element.setAttribute(CollectionConfiguration.ASSIGNED_ATTRIBUTE, (assigned ? CollectionConfiguration.TRUE_STR : CollectionConfiguration.FALSE_STR));
    304     }
    305     }
    306 
    307     /** Set the custom arguments. This turns out to be quite tricky. We must parse in the string, searching for arguments (for that we use a handy method in CollectionConfiguration). Next, for each argument, we check if we already know about it. If so we update its value, otherwise we create a new argument and assign it (must assign!).
    308      * @param custom_str the custom arguments all splodged together in one String
    309      */
    310     public void setCustom(String custom_str) {
    311     HashMap raw_arguments = CollectionConfiguration.parseArguments(new CommandTokenizer(custom_str));
    312     ArrayList custom_arguments = getArguments(false, true);
    313     int size = custom_arguments.size();
    314     for(int i = 0; i < size; i++) {
    315         Argument argument = (Argument) custom_arguments.get(i);
    316         String original_argument_name = StaticStrings.MINUS_CHARACTER + argument.getName();
    317         if(raw_arguments.containsKey(original_argument_name)) {
    318         // Set as assigned
    319         argument.setAssigned(true);
    320         String argument_value = (String)raw_arguments.remove(original_argument_name);
    321         if(argument_value != null) {
    322             argument.setValue(argument_value);
    323             argument_value = null;
    324         }
    325         }
    326         // We've removed it from our custom statement, so unassign
    327         else {
    328         argument.setAssigned(false);
    329         }
    330         argument = null;
    331     }
    332     // Any left over, add to the classifier
    333     Iterator argument_names = raw_arguments.keySet().iterator();
    334     while(argument_names.hasNext()) {
    335         String argument_name = (String) argument_names.next();
    336         String argument_value = (String) raw_arguments.get(argument_name);
    337         // The tricky thing is that we have to create a new element in the DOM as well.
    338         Element argument_element = CollectionDesignManager.collect_config.document.createElement(StaticStrings.OPTION_ELEMENT);
    339         argument_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, argument_name.substring(1));
    340         argument_element.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
    341         argument_element.setAttribute(StaticStrings.CUSTOM_ATTRIBUTE, StaticStrings.TRUE_STR);
    342         Argument argument = new Argument(argument_element);
    343         argument_name = null;
    344         if(argument_value != null) {
    345         argument.setValue(argument_value);
    346         argument_value = null;
    347         }
    348         // All done. Add it.
    349         element.appendChild(argument_element);
    350         add(argument);
    351         argument_element = null;
    352     }
    353     raw_arguments = null;
    354     }
    355 
    356     /** Method to set the value of desc.
    357      * @param description The new value of desc as a <strong>String</strong>.
    358      */
    359     public void setDescription(String description) {
    360     this.description = description;
    361     }
    362 
    363     public void setElement(Element element) {
    364     this.element = element;
    365     }
    366 
    367     public void setIsAbstract(boolean is_abstract) {
    368     this.is_abstract = is_abstract;
    369     }
    370 
    371     /** Method to set the value of name.
    372      * @param name The new value of name as a <strong>String</strong>.
    373      */
    374     public void setName(String name) {
    375     this.name = name;
    376     }
    377 
    378     /** Method to set the value of the super_classifier.
    379      * @param super_classifier The new value of super_classifier as a <strong>Classifier</strong>, or <i>null</i> if this class has no inheritance.
    380      */
    381     public void setSuper(Classifier super_classifier) {
    382     this.super_classifier = super_classifier;
    383     }
    384 
    385 
    386     /** Method to print out this classifier as it would appear to the user in the interface
    387      * @return A <strong>String</strong> containing a single classifier command.
    388      */
    389     public String toString()
    390     {
    391     if (element == null) {
    392         return name;
    393     }
    394 
    395     if (name == null) {
    396         name = element.getAttribute(StaticStrings.TYPE_ATTRIBUTE);
    397     }
    398 
    399     StringBuffer text = new StringBuffer(StaticStrings.CLASSIFY_STR);
    400     text.append(" ");
    401     text.append(name);
    402 
    403     ArrayList arguments = getArguments(true, true);
    404     for (int i = 0; i < arguments.size(); i++) {
    405         Argument argument = (Argument) arguments.get(i);
    406         if (argument.isAssigned()) {
    407         text.append(" ");
    408         text.append(argument.toString());
    409         }
    410     }
    411 
    412     return text.toString();
    413     }
    41489}
Note: See TracChangeset for help on using the changeset viewer.