Category.java :  » Natural-Language-Processing » GATE » shef » nlp » supple » category » Java Open Source

package shef.nlp.supple.category;

import gate.FeatureMap;
import gate.creole.ExecutionException;
import gate.util.Err;
import gate.util.SimpleFeatureMapImpl;

import java.util.Hashtable;
import java.util.Iterator;
import java.util.TreeSet;

import shef.nlp.supple.utils.EmptyFeatureMap;
import shef.nlp.supple.utils.IllegalCategoryName;

public class Category
{
  static TreeSet ALL_CAT = new TreeSet();
  static TreeSet NE_CAT = new TreeSet();
  static TreeSet POS_CAT = new TreeSet();
  static Hashtable DEF_CAT = new Hashtable();

  /* DEFAULT FEATURE MAPS FOR POS AND SYNTACTIC CATEGORIES */
  static FeatureMap DEF_POS = new SimpleFeatureMapImpl();
  static FeatureMap N_POS = new SimpleFeatureMapImpl();
  static FeatureMap A_POS = new SimpleFeatureMapImpl();
  static FeatureMap V_POS = new SimpleFeatureMapImpl();
  static FeatureMap TOP_POS = new SimpleFeatureMapImpl();
  static FeatureMap BOTTOM_POS = new SimpleFeatureMapImpl();

  /* CONSTANT FEATURE NAMES VALID FOR BUCHART PARSING */
  public static String S_FORM = "s_form";
  public static String M_ROOT = "m_root";
  public static String M_AFFIX = "m_affix";
  public static String TEXT = "text";
  public static String EDGE = "edge";
  public static String SEM = "sem";
  public static String HEAD = "head";
  public static String SOURCE = "source";
  public static String PERSON = "person";
  public static String NUMBER = "number";
  public static String GENDER = "gender";
  public static String TENSE = "tense";
  public static String ASPECT = "aspect";
  public static String VOICE = "voice";
  public static String VFORM = "vform";
  public static String DEGREE = "degree";
  public static String NE_TAG = "ne_tag";
  public static String NE_TYPE = "ne_type";

  /* ANY VALUE */
  static String ANY = "_";
  static String EMPTY = "";
  static String BODY = "body";

  String name;
  public String getCategory() { return name; }
  public void  setCategory(String Name) { name = Name; }

  FeatureMap features = new SimpleFeatureMapImpl();
  public FeatureMap getFeatures() { return features; }
  public void setFeatures(FeatureMap Features) { features = Features; }

  static boolean is_ne(String type) { return NE_CAT.contains(type); }

  public boolean equals(Object o)
  {
    if (!(o instanceof Category)) return false;

    Category c = (Category)o;

    return name.equals(c.name) && features.equals(c.features);
  }

  static
  {
    /* FEATURES FOR DEFAULT POS CATEGORIES */
    DEF_POS.put(S_FORM,ANY);
    DEF_POS.put(M_ROOT,EMPTY);
    DEF_POS.put(M_AFFIX,EMPTY);
    DEF_POS.put(TEXT,"body");
    /* FEATURES FOR NOUN POS CATEGORIES */

    N_POS.put(S_FORM,ANY);
    N_POS.put(M_ROOT,EMPTY);
    N_POS.put(M_AFFIX,EMPTY);
    N_POS.put(TEXT,"body");
    N_POS.put(PERSON,ANY);
    N_POS.put(NUMBER,ANY);

    /* FEATURES FOR ADJ AND ADV CATEGORIES */
    A_POS.put(S_FORM,ANY);
    A_POS.put(M_ROOT,EMPTY);
    A_POS.put(M_AFFIX,EMPTY);
    A_POS.put(TEXT,"body");
    A_POS.put(DEGREE,ANY);

    /* FEATURES FOR VERB CATEGORIES */
    V_POS.put(S_FORM,ANY);
    V_POS.put(M_ROOT,EMPTY);
    V_POS.put(M_AFFIX,EMPTY);
    V_POS.put(TEXT,"body");
    V_POS.put(PERSON,ANY);
    V_POS.put(NUMBER,ANY);
    V_POS.put(TENSE,ANY);
    V_POS.put(VFORM,ANY);

    /* TOP */
    TOP_POS.put(S_FORM,"top");
    TOP_POS.put(M_ROOT,"top");
    TOP_POS.put(M_AFFIX,EMPTY);
    TOP_POS.put(TEXT,"body");

    /* BOTTOM */
    BOTTOM_POS.put(S_FORM,"bottom");
    BOTTOM_POS.put(M_ROOT,"bottom");
    BOTTOM_POS.put(M_AFFIX,EMPTY);
    BOTTOM_POS.put(TEXT,"body");

    /* SET OF POS CATS FOR BUCHART */
    POS_CAT.add("n");
    POS_CAT.add("pn");
    POS_CAT.add("v");
    POS_CAT.add("jj");
    POS_CAT.add("rb");
    POS_CAT.add("fw");
    POS_CAT.add("cd");
    POS_CAT.add("cc");
    POS_CAT.add("dt");
    POS_CAT.add("ex");
    POS_CAT.add("in");
    POS_CAT.add("ls");
    POS_CAT.add("md");
    POS_CAT.add("pdt");
    POS_CAT.add("pos");
    POS_CAT.add("pp");
    POS_CAT.add("pps");
    POS_CAT.add("rp");
    POS_CAT.add("to");
    POS_CAT.add("uh");
    POS_CAT.add("wdt");
    POS_CAT.add("wp");
    POS_CAT.add("wrb");
    POS_CAT.add("sym");
    POS_CAT.add("period");
    POS_CAT.add("comma");
    POS_CAT.add("top");
    POS_CAT.add("bottom");

    // NON POS CATS
    NE_CAT.add("list_np");

    /* ALL VALID CATEGORIES */
    ALL_CAT.addAll(NE_CAT);
    ALL_CAT.addAll(POS_CAT);

    Iterator ite_pos = POS_CAT.iterator();
    while(ite_pos.hasNext())
    {
      DEF_CAT.put(ite_pos.next(),DEF_POS);
    }

    /* DEFAULT SET OF CATEGORIES AND THEIR FEATURES */
    DEF_CAT.put("n",N_POS);
    DEF_CAT.put("v",V_POS);
    DEF_CAT.put("jj",A_POS);
    DEF_CAT.put("pn",N_POS);
    DEF_CAT.put("rb",A_POS);
    DEF_CAT.put("top",TOP_POS);
    DEF_CAT.put("bottom",BOTTOM_POS);
    DEF_CAT.put("list_np",DEF_POS);
  }

  public Category() {}

  public Category(String Name, FeatureMap Features)
  {
    name = Name;
    features = new SimpleFeatureMapImpl();
    features.putAll(Features);
  }

  public Category(String Name) throws IllegalCategoryName
  {
    if(!ALL_CAT.contains(Name))
    {
      throw new IllegalCategoryName(Name+" is invalid");
    }
    name = Name;
  }

  public static Category getDefaultCategory(String Name)
  {
    return new Category(Name,(FeatureMap) DEF_CAT.get(Name));
  }

  public static String quoteValue(String value)
  {
    String output = "";
    output = "\'";
    int len = value.length();
    for(int i=0; i<len; i++)
    {
      if(value.charAt(i)=='\'')
      {
        output += "''";
      }
      else if(value.charAt(i)=='\n')
      {
        output += " ";
      }
      else
        output +=  value.charAt(i);
    }

    output += '\'';
    return output;
  }

  public String toSUPPLEFormat() throws EmptyFeatureMap, ExecutionException
  {
    String cat;
    FeatureMap features;
    String output= "";

    cat = this.getCategory();
    features = this.getFeatures();

    /* FOR POS CATEGORIES */

    if (POS_CAT.contains(cat) )
    {
      output += cat;
      output += "(";

      output += S_FORM+":"+quoteValue((String) features.get(S_FORM))+",";
      output += M_ROOT+":"+quoteValue((String) features.get(M_ROOT))+",";
      output += M_AFFIX+":"+quoteValue((String) features.get(M_AFFIX))+",";
      output += TEXT+":"+quoteValue((String) features.get(TEXT));

      if (cat == "n" || cat == "pn")
      {
        output += ",";
        output += PERSON+":"+features.get(PERSON)+",";
        output += NUMBER+":"+features.get(NUMBER);
      }
      else if (cat == "v")
      {
        output += ",";
        output += PERSON+":"+features.get(PERSON)+",";
        output += NUMBER+":"+features.get(NUMBER);
        output += ",";
        output += TENSE+":"+features.get(TENSE)+",";
        output += VFORM+":"+features.get(VFORM);
      }
      else if (cat == "jj" | cat == "rb" )
      {
        output += ",";
        output += DEGREE+":"+features.get(DEGREE);
      }
      else
      {
        /* nothing else */
      }
    }
    else if (NE_CAT.contains(cat))
    {
      if (cat=="list_np")
      {
        output += cat;
        output += "(";

        output += S_FORM+":"+quoteValue((String) features.get(S_FORM))+",";
        output += M_ROOT+":"+quoteValue((String) features.get(M_ROOT))+",";
        output += M_AFFIX+":"+quoteValue((String) features.get(M_AFFIX))+",";
        output += TEXT+":"+quoteValue((String) features.get(TEXT))+",";
        output += NE_TAG+":"+quoteValue((String) features.get("ne_tag"))+",";

        if (features.get("ne_type") != null)
        {
          output += NE_TYPE+":"+quoteValue((String) features.get("ne_type"))+",";
        }

        output += GENDER+":"+quoteValue((String) features.get("gender"));
      }
      else
      {
        Err.println("There is no category "+cat);
      }
    }
    output += ")";

    return output;
  }

  public static FeatureMap getDefaultFeatureMap(String Name)
  {
    return (FeatureMap) DEF_CAT.get(Name);
  }

  public void emptyCategory(String Name) throws IllegalCategoryName
  {
    if (Name=="n")
    {
      this.setCategory("n");
      this.setFeatures(N_POS);
      return;
    }
    if (Name=="v")
    {
      this.setCategory("v");
      this.setFeatures(V_POS);
      return;
    }

    throw new IllegalCategoryName(Name+" is invalid");
  }

  public void setFeatureValue(FeatureValue fv)
  {
    this.features.put(fv.feature,fv.value);
  }

  public void show()
  {
    System.out.println("CAT: "+name);
    System.out.println("FEATURES: "+features);
  }

  public void showFeatureMap()
  {
    System.out.println("Features "+features);
  }
}