import net.didion.jwnl.data.Synset; //导入依赖的package包/类
/**
   * @param token A token from the domain e.g. "v-kidnap"
   * @return A list of synonyms (with "v-" attached)
   */
  private List<String> synonymsOf(String token) {
    POS pos = POS.VERB;
    if( token.startsWith("n") ) pos = POS.NOUN;
    String header = token.substring(0, 2);
    
    // Get the synsets.
    Synset[] synsets = _wordnet.synsetsOf(token.substring(2), pos);
    
    // Get all words in all synsets.
    List<String> synonyms = new ArrayList<String>();
    if( synsets != null ) {
      for( Synset synset : synsets ) {
        List<String> syms = _wordnet.wordsInSynset(synset);
//        System.out.println("  token " + token + " synset " + synset + ": " + syms);
        for( String sym : syms ) {
          String strtoken = header + sym;
          if( !synonyms.contains(strtoken) )
            synonyms.add(strtoken);
        }
      }
    }
    return synonyms;
  }
 

import net.didion.jwnl.data.Synset; //导入依赖的package包/类
/**
 * Returns true if the two tokens are under the same immediate synset (siblings).
 * @param token1 A token.
 * @param token2 A token.
 * @param postag The POS tag of both tokens.
 * @return True if the tokens are siblings, false otherwise.
 */
public boolean areSiblings(String token1, String token2, POS postag) {
  Synset[] synsets1 = synsetsOf(token1, postag);
  Synset[] synsets2 = synsetsOf(token2, postag);
  if( synsets1 != null && synsets2 != null ) {
    for( int i = 0; i < synsets1.length; i++ ) {
      Synset syn = synsets1[i];
      for( int j = 0; j < synsets2.length; j++ ) {
        if( syn == synsets2[j] )
          return true;
      }
    }
  }
  if( (token1.equals("hurt") && token2.equals("injure")) || (token1.equals("injure") && token2.equals("hurt"))  )
    System.out.println("areSiblings returning false!");
  return false;
}
 

import net.didion.jwnl.data.Synset; //导入依赖的package包/类
public boolean isNounPersonOrGroup(String token, boolean mainSynsetOnly, boolean justPerson) {
  if( _isPersonOrGroup == null ) _isPersonOrGroup = new HashMap<String, Boolean>();
  if( _isPersonOrGroup.containsKey(token) ) return _isPersonOrGroup.get(token);

  Synset[] synsets = synsetsOf(token, POS.NOUN);
  if( synsets == null ) {
  }
  else {
    for( Synset synset : synsets ) {
      List<Synset> chain = hypernymChainKeepChild(synset);
      if( chain != null ) {
        for( Synset parent : chain ) {
          if( isPersonSynset(parent) || (!justPerson && isSocialGroupSynset(parent)) ) {
            _isPersonOrGroup.put(token, true);
            return true;
          }
        }
      }
      // Stop now if we are only checking the main synset.
      if( mainSynsetOnly ) return false;
    }
  }
  _isPersonOrGroup.put(token, false);
  return false;
}
 

import net.didion.jwnl.data.Synset; //导入依赖的package包/类
public boolean isTime(String token) {
    if( _isTime == null ) _isTime = new HashMap<String, Boolean>();
    if( _isTime.containsKey(token) ) return _isTime.get(token);

    Synset[] synsets = synsetsOf(token, POS.NOUN);
//    System.out.println("isTime top " + token);
    if( synsets == null ) {
//      System.out.println("isTime null synsets: " + token);
    }
    else {
      for( Synset synset : synsets ) {
        List<Synset> chain = hypernymChainKeepChild(synset);
        if( chain != null ) {
          for( Synset parent : chain ) {
            if( isTimeSynset(parent) ) {
              _isTime.put(token, true);
              return true;
            }
          }
        }
      }
    }
    _isTime.put(token, false);
    return false;
  }
 

import net.didion.jwnl.data.Synset; //导入依赖的package包/类
public boolean isLocation(String token) {
  if( _isLocation == null ) _isLocation = new HashMap<String, Boolean>();
  if( _isLocation.containsKey(token) ) return _isLocation.get(token);

  Synset[] synsets = synsetsOf(token, POS.NOUN);
  //    System.out.println("isNounEntity top " + token);
  if( synsets == null ) {
    //      System.out.println("isNounEntity null synsets: " + token);
  }
  else {
    for( Synset synset : synsets ) {
      List<Synset> chain = hypernymChainKeepChild(synset);
      if( chain != null ) {
        for( Synset parent : chain ) {
          if( isLocationSynset(parent) ) {
            _isLocation.put(token, true);
            return true;
          }
        }
      }
    }
  }
  _isLocation.put(token, false);
  return false;
}
 

import net.didion.jwnl.data.Synset; //导入依赖的package包/类
/**
 * Assumes the given token is a noun.
 * @return true if the token has a synset with an ancestor that is Integer
 */
public boolean isInteger(String token) {
  Synset[] synsets = synsetsOf(token, POS.NOUN);
  //    System.out.println("isNounEntity top " + token);
  if( synsets == null ) {
    //      System.out.println("isNounEntity null synsets: " + token);
  }
  else {
    for( Synset synset : synsets ) {
      List<Synset> chain = hypernymChainKeepChild(synset);
      if( chain != null ) {
        for( Synset parent : chain ) {
          //	    System.out.println(parent);
          Word[] words = parent.getWords();
          if( (words.length > 0 && words[0].getLemma().equals("integer")) )
            return true;
        }
      }
    }
  }
  return false;
}
 

import net.didion.jwnl.data.Synset; //导入依赖的package包/类
/**
 * Assumes the given token is a noun.
 * @return true if the token has a synset with an ancestor that is a physical object
 *         synset.
 */
public boolean isPhysicalObject(String token) {
  if( _isPhysicalObject == null ) _isPhysicalObject = new HashMap<String, Boolean>();
  if( _isPhysicalObject.containsKey(token) ) return _isPhysicalObject.get(token);

  Synset[] synsets = synsetsOf(token, POS.NOUN);
  if( synsets == null ) {
  }
  else {
    for( Synset synset : synsets ) {
      List<Synset> chain = hypernymChainKeepChild(synset);
      if( chain != null ) {
        for( Synset parent : chain ) {
          if( isPhysicalObjectSynset(parent) ) {
            _isPhysicalObject.put(token, true);
            return true;
          }
        }
      }
    }
  }
  _isPhysicalObject.put(token, false);
  return false;
}
 

import net.didion.jwnl.data.Synset; //导入依赖的package包/类
/**
   * Assumes the given token is a noun.
   * WordNet does not put material (explosive, rocks, dust, fiber, etc.) under "physical objects".
   * @return true if the token has a synset with an ancestor that is a "material" synset.
   *       
   */
  public boolean isMaterial(String token) {
    if( _isMaterial == null ) _isMaterial = new HashMap<String, Boolean>();
    if( _isMaterial.containsKey(token) ) return _isMaterial.get(token);

    Synset[] synsets = synsetsOf(token, POS.NOUN);
//    System.out.println("isMatter top " + token);
    if( synsets == null ) {
    }
    else {
      for( Synset synset : synsets ) {
        List<Synset> chain = hypernymChainKeepChild(synset);
        if( chain != null ) {
          for( Synset parent : chain ) {
            Word[] words = parent.getWords();
            if( words.length >= 1 && words[0].getLemma().equals("material") ) {
              _isMaterial.put(token, true);
              return true;
            }
          }
        }
      }
    }
    _isMaterial.put(token, false);
    return false;
  }
 

import net.didion.jwnl.data.Synset; //导入依赖的package包/类
/**
 * Assumes the given token is a noun.
 * @return true if the token only has "instance hypernym" links from its synsets.
 *              If it has a normal "hypernym", or is unknown, then return false.
 */
public boolean isNamedEntity(String token) {
  // save time with a table lookup
  if( _isNamedEntity == null ) _isNamedEntity = new HashMap<String, Boolean>();
  if( _isNamedEntity.containsKey(token) ) return _isNamedEntity.get(token);

  Synset[] synsets = synsetsOf(token, POS.NOUN);
  //    System.out.println("isNounEvent top " + token);
  if( synsets == null ) {
    //      System.out.println("isNounEvent null synsets: " + token);
  }
  else {
    for( Synset synset : synsets ) {
      if( !hasHypernymInstance(synset) ) {
        _isNamedEntity.put(token, false);
        return false;
      }
    }
    _isNamedEntity.put(token, true);
    return true;
  }
  _isNamedEntity.put(token, false);
  return false;
}
 

import net.didion.jwnl.data.Synset; //导入依赖的package包/类
/**
 * Create token/lemma/synset features for an event.
 * @param eventIndex Either 1 or 2, the first or second event in your link. This differentiates the feature names.
 */
private Counter<String> getSingleEventTokenFeatures(int eventIndex, TextEvent event1, List<Tree> trees) {
  Counter<String> feats = new ClassicCounter<String>();
  
  String token = event1.string();
  String postag = TreeOperator.indexToPOSTag(trees.get(event1.sid()), event1.index());
  String lemma = _wordnet.lemmatizeTaggedWord(token, postag);

  // Token and Lemma
  feats.incrementCount("token" + eventIndex + "-" + token);
  feats.incrementCount("lemma" + eventIndex + "-" + lemma);
  
  // WordNet synset
  Synset[] synsets = null;
  if( postag.startsWith("VB") )
    synsets = _wordnet.synsetsOf(token, POS.VERB);
  else if( postag.startsWith("NN") )
    synsets = _wordnet.synsetsOf(token, POS.NOUN);
  if( synsets != null && synsets.length > 0 )
    feats.incrementCount("synset" + eventIndex + "-" + synsets[0].getOffset());
  
  return feats;
}
 

import net.didion.jwnl.data.Synset; //导入依赖的package包/类
/**
   * Get the chain of parents from the given synset to the top of the
   * wordnet hierarchy.  Checks for loops (they exist!).
   * @param synset Child synset of which we want the parent chain.
   * @param history The list of synsets we've already traversed.
   * @return The hypernym chain.
   */
  public List<Synset> hypernymChain(Synset synset, List<Synset> history) {
    List<Synset> chain = new ArrayList<Synset>();

    Pointer[] links = synset.getPointers();
    if( links != null ) {
      for( Pointer link : links ) {
        // HYPERNYM is the type of link in WordNet.  However, they also have an "instance hypernym"
        // which does not have a PointerType type in their API, yet appears in their database.
        // This is a hack that checks the key "@i" is an instance, "@" is standard hypernym.
//        if( link.getType() == PointerType.HYPERNYM ) {
        if( link.getType() != null && link.getType().getKey().charAt(0) == hypernymChar ) {
          try {
            Synset target = link.getTargetSynset();
            if( !history.contains(target) ) {
              history.add(target);
              chain.add(target);
              List<Synset> upperChain = hypernymChain(target, history);
              if( upperChain != null ) chain.addAll(upperChain);
              // ** There's only one parent per synset, right?
              return chain;
            }
            else System.out.println("Wordnet found loop at " + synset + "\nhistory=" + history);
          } catch( Exception ex ) { ex.printStackTrace(); }
        }
      }
    }
    return null;
  }
 

import net.didion.jwnl.data.Synset; //导入依赖的package包/类
private static AnswerType findWnMapMatch(Synset synset,int level) throws Exception {
    AnswerType type = null;
    String synsetId = buildSynsetString(synset);
    String typeStr = wnAtypeMap.get(synsetId);
    if (typeStr != null) {
        type = AnswerType.constructFromString(typeStr);
        type.setConfidence( 1.0 - ((double)level / 100.0));
        return type;
    }
    PointerTargetNodeList ptNodeList = null;
    ptNodeList = pUtils.getDirectHypernyms(synset);
    for (int i = 0; i < ptNodeList.size(); i++) {
        Synset parent = (Synset)((PointerTargetNode)ptNodeList.get(i)).getPointerTarget();
        type = findWnMapMatch(parent,level+1);
        if (type != null) return type;
    }
    return type;
}
 

import net.didion.jwnl.data.Synset; //导入依赖的package包/类
private Synset getSynset(POS pos, long offset, String line) throws JWNLException {
	POSKey key = new POSKey(pos, offset);
	Synset synset = getCachedSynset(key);
       if (synset == null) {
           try {
               if (line == null) {
                   line = getFileManager().readLineAt(pos, DictionaryFileType.DATA, offset);
               }
               synset = _factory.createSynset(pos, line);
               synset.getWords();
               
               if (synset != null) {
                   cacheSynset(key, synset);
               }
           } catch (IOException e) {
               throw new JWNLException("DICTIONARY_EXCEPTION_005", new Long(offset), e);
           }
       }
	return synset;
}
 

import net.didion.jwnl.data.Synset; //导入依赖的package包/类
/**
 * @param s
 * @param lookFor 
 * @return
 * @throws JWNLException 
 */
private static boolean canBe(Synset s, List<String> lookFor,LinkedList<Synset> checked) throws JWNLException {
	if(!checked.contains(s)) {
		checked.add(s); //to avoid circles
		for(String lf:lookFor) {
			if(s.containsWord(lf)) {
				return true;
			}
		}
		for(Pointer p:s.getPointers(PointerType.HYPERNYM)) {
			if(canBe(p.getTargetSynset(),lookFor,checked)){
				return true;
			}
		}		
	}
	return false;
}
 

import net.didion.jwnl.data.Synset; //导入依赖的package包/类
/**
 * @return All synsets for the given word and POS category.
 */
public Synset[] synsetsOf(String token, POS postag) {
  try {
    IndexWord iword = Dictionary.getInstance().lookupIndexWord(postag, token);
    if( iword != null ) {
      Synset[] synsets = iword.getSenses();
      return synsets;
    }
  } catch( Exception ex ) { ex.printStackTrace(); }
  return null;
}
 

import net.didion.jwnl.data.Synset; //导入依赖的package包/类
/**
 * @return All lemmas that are under the given synset.
 */
public List<String> wordsInSynset(Synset synset) {
  List<String> strings = new ArrayList<String>();
  Word[] words = synset.getWords();
  for( Word word : words )
    strings.add(word.getLemma()); 
  return strings;
}
 

import net.didion.jwnl.data.Synset; //导入依赖的package包/类
/**
 * @return True if the synset has a "hypernym instance" link.
 */
public boolean hasHypernymInstance(Synset synset) {
  Pointer[] links = synset.getPointers();
  if( links != null ) {
    for( Pointer link : links )
      if( link.getType().getKey().equals(hypernymInstance) )
        return true;
  }
  return false;
}
 

import net.didion.jwnl.data.Synset; //导入依赖的package包/类
/**
 * Get the chain of parents from the given synset to the top of the
 * wordnet hierarchy.  Return the chain, but rooted with the given
 * synset.
 */
public List<Synset> hypernymChainKeepChild(Synset synset) {
  List<Synset> chain = new ArrayList<Synset>();
  chain.add(synset);
  
  List<Synset> parents = hypernymChain(synset);
  if( parents != null )
    chain.addAll(parents);
  
  return chain;
}
 

import net.didion.jwnl.data.Synset; //导入依赖的package包/类
/**
 * Get all synsets that are reachable by hypernym relations from this token.
 */
public Set<Synset> getAllSynsetAncestors(String token, POS tag) {
  Synset[] synsets = synsetsOf(token, tag);
  if( synsets != null ) {
    Set<Synset> allsynsets = new HashSet<Synset>();
    for( Synset synset : synsets ) {
      List<Synset> chain = hypernymChainKeepChild(synset);
      allsynsets.addAll(chain);
    }
    return allsynsets;
  }
  else return null;
}
 

import net.didion.jwnl.data.Synset; //导入依赖的package包/类
/**
 * Assumes the given token is a noun.
 * @return true if there is some synset with this token that has a 
 *              nominalization relation attached to it.
 */
public boolean isNominalization(String token) {
  Synset[] synsets = synsetsOf(token, POS.NOUN);
  if( synsets == null ) {
    //      System.out.println("isNominalization null synsets: " + token);
  }
  else {
    for( Synset synset : synsets ) {
      Pointer[] links = synset.getPointers();
      if( links != null ) {
        for( Pointer link : links ) {
          // Found a link from this noun as a Nominalization to another.
          if( link.getType() == PointerType.NOMINALIZATION ) {
            // Check that the nominalized word is a verb (e.g. not an adjective).
            try {
              Synset target = link.getTargetSynset();
              if( target.getPOS() == POS.VERB ) {
                //		  System.out.println("WordNet isNom() link found: " + link);
                //		  System.out.println(" --> " + link.getTargetSynset());
                return true;
              }
            } catch( Exception ex ) { ex.printStackTrace(); }
          }
        }
      }
    }
  }
  return false;
}