import edu.stanford.nlp.util.Interner; //导入依赖的package包/类
/**
 * Static factory method for relations requiring an argument, including
 * HAS_ITH_CHILD, ITH_CHILD_OF, UNBROKEN_CATEGORY_DOMINATES,
 * UNBROKEN_CATEGORY_DOMINATED_BY.
 *
 * @param s The String representation of the relation
 * @param arg The argument to the relation, as a string; could be a node
 *          description or an integer
 * @return The singleton static relation of the specified type with the
 *         specified argument. Uses Interner to insure singleton-ity
 * @throws ParseException If bad relation s
 */
static Relation getRelation(String s, String arg) throws ParseException {
  if (arg == null) {
    return getRelation(s);
  }
  Relation r;
  if (s.equals("<")) {
    r = new HasIthChild(Integer.parseInt(arg));
  } else if (s.equals(">")) {
    r = new IthChildOf(Integer.parseInt(arg));
  } else if (s.equals("<+")) {
    r = new UnbrokenCategoryDominates(arg);
  } else if (s.equals(">+")) {
    r = new UnbrokenCategoryIsDominatedBy(arg);
  } else if (s.equals(".+")) {
    r = new UnbrokenCategoryPrecedes(arg);
  } else if (s.equals(",+")) {
    r = new UnbrokenCategoryFollows(arg);
  } else {
    throw new ParseException("Unrecognized compound relation " + s + ' '
        + arg);
  }
  return Interner.globalIntern(r);
}
 

import edu.stanford.nlp.util.Interner; //导入依赖的package包/类
/**
 * For supplying a new instance for the global methods to use.
 *
 * @return the previous global interner.
 */
public static SynchronizedInterner<Object> setGlobal(Interner<Object> delegate) {
  synchronized(globalMutex) {
    SynchronizedInterner<Object> oldInterner = SynchronizedInterner.interner;
    SynchronizedInterner.interner = Generics.newSynchronizedInterner(delegate);
    return oldInterner;
  }
}
 

import edu.stanford.nlp.util.Interner; //导入依赖的package包/类
private void readObject(ObjectInputStream ois)
  throws IOException, ClassNotFoundException
{
  ois.defaultReadObject();
  // reinitialize the transient objects
  itwInterner = new Interner<IntTaggedWord>();
}
 

import edu.stanford.nlp.util.Interner; //导入依赖的package包/类
/**
 * Static factory method for all relations with no arguments. Includes:
 * DOMINATES, DOMINATED_BY, PARENT_OF, CHILD_OF, PRECEDES,
 * IMMEDIATELY_PRECEDES, HAS_LEFTMOST_DESCENDANT, HAS_RIGHTMOST_DESCENDANT,
 * LEFTMOST_DESCENDANT_OF, RIGHTMOST_DESCENDANT_OF, SISTER_OF, LEFT_SISTER_OF,
 * RIGHT_SISTER_OF, IMMEDIATE_LEFT_SISTER_OF, IMMEDIATE_RIGHT_SISTER_OF,
 * HEADS, HEADED_BY, IMMEDIATELY_HEADS, IMMEDIATELY_HEADED_BY, ONLY_CHILD_OF,
 * HAS_ONLY_CHILD, EQUALS
 *
 * @param s The String representation of the relation
 * @return The singleton static relation of the specified type
 * @throws ParseException If bad relation s
 */
static Relation getRelation(String s,
                            Function<String, String> basicCatFunction,
                            HeadFinder headFinder)
  throws ParseException
{
  if (SIMPLE_RELATIONS_MAP.containsKey(s))
    return SIMPLE_RELATIONS_MAP.get(s);

  // these are shorthands for relations with arguments
  if (s.equals("<,")) {
    return getRelation("<", "1", basicCatFunction, headFinder);
  } else if (parentOfLastChild.matcher(s).matches()) {
    return getRelation("<", "-1", basicCatFunction, headFinder);
  } else if (s.equals(">,")) {
    return getRelation(">", "1", basicCatFunction, headFinder);
  } else if (lastChildOfParent.matcher(s).matches()) {
    return getRelation(">", "-1", basicCatFunction, headFinder);
  }

  // finally try relations with headFinders
  Relation r;
  if (s.equals(">>#")) {
    r = new Heads(headFinder);
  } else if (s.equals("<<#")) {
    r = new HeadedBy(headFinder);
  } else if (s.equals(">#")) {
    r = new ImmediatelyHeads(headFinder);
  } else if (s.equals("<#")) {
    r = new ImmediatelyHeadedBy(headFinder);
  } else {
    throw new ParseException("Unrecognized simple relation " + s);
  }

  return Interner.globalIntern(r);
}
 

import edu.stanford.nlp.util.Interner; //导入依赖的package包/类
HeadedBy(HeadFinder hf) {
  super("<<#");
  this.heads = Interner.globalIntern(new Heads(hf));
}
 

import edu.stanford.nlp.util.Interner; //导入依赖的package包/类
ImmediatelyHeadedBy(HeadFinder hf) {
  super("<#");
  this.immediatelyHeads = Interner
      .globalIntern(new ImmediatelyHeads(hf));
}
 

import edu.stanford.nlp.util.Interner; //导入依赖的package包/类
HasIthChild(int i) {
  super('<' + String.valueOf(i));
  ithChildOf = Interner.globalIntern(new IthChildOf(i));
}
 

import edu.stanford.nlp.util.Interner; //导入依赖的package包/类
UnbrokenCategoryIsDominatedBy(String arg) {
  super(">+(" + arg + ')');
  unbrokenCategoryDominates = Interner
      .globalIntern((new UnbrokenCategoryDominates(arg)));
}
 

import edu.stanford.nlp.util.Interner; //导入依赖的package包/类
public SynchronizedInterner(Interner<T> delegate) {
  if (delegate == null) throw new NullPointerException();
  this.delegate = delegate;
  this.mutex = this;
}
 

import edu.stanford.nlp.util.Interner; //导入依赖的package包/类
UnbrokenCategoryIsDominatedBy(String arg,
                              Function<String, String> basicCatFunction) {
  super(">+(" + arg + ')');
  unbrokenCategoryDominates = Interner
    .globalIntern((new UnbrokenCategoryDominates(arg, basicCatFunction)));
}