import net.didion.jwnl.data.Word; //导入依赖的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.Word; //导入依赖的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.Word; //导入依赖的package包/类
public Set<SensedWord> getNeighborSensedWords(WordNetRelation relation) throws WordNetException {

		Set<SensedWord> sensedWords = new HashSet<SensedWord>();
		if (relation.isLexical())
		{
			PointerType pointerType = JwnlUtils.wordNetRelationToPointerType(relation);
			if (pointerType != null)
			{
				Pointer[] pointers = wordObj.getPointers(pointerType);
				for (Pointer pointer : pointers)
					try {	sensedWords.add( new JwnlSensedWord(((Word) pointer.getTarget()), dictionary));	}
					catch (JWNLException e) { throw new WordNetException("See nested",e);	}
			}
		}
		return sensedWords;
	}
 

import net.didion.jwnl.data.Word; //导入依赖的package包/类
private List<String> getWords(Synset ss) {
    List<String> ssWords = new ArrayList<String>();
    for (Word w : ss.getWords()) {
        ssWords.add(w.getLemma().replaceAll("_", " "));
    }
    return ssWords;
}
 

import net.didion.jwnl.data.Word; //导入依赖的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.Word; //导入依赖的package包/类
/**
 * Gets all of the verbs that are in the synset of which the given noun token
 * has a nominalization pointer to.
 * @param token A noun e.g. explosion
 * @return A list of strings that are verbs e.g. explode, detonate
 */
public List<String> getVerbsOfNominalization(String token) {
  Synset[] synsets = synsetsOf(token, POS.NOUN);
  if( synsets != null ) {
    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 ) {
                Synset verbSynset = link.getTargetSynset();
                Word[] verbs = verbSynset.getWords();
                List<String> theverbs = new ArrayList<String>();
                for( Word verb : verbs )
                  theverbs.add(verb.getLemma());
                return theverbs;
              }
            } catch( Exception ex ) { ex.printStackTrace(); }
          }
        }
      }
    }
  }
  return null;
}
 

import net.didion.jwnl.data.Word; //导入依赖的package包/类
private boolean isSocialGroupSynset(Synset synset) {
  if( synset != null ) {
    Word[] words = synset.getWords();
    if( words.length > 0 && words[0].getLemma().equals("social_group") )
      return true;
  }
  return false;
}
 

import net.didion.jwnl.data.Word; //导入依赖的package包/类
private boolean isLocationSynset(Synset synset) {
  if( synset != null ) {
    Word[] words = synset.getWords();
    if( words.length > 0 && 
        (words[0].getLemma().equals("location") || words[0].getLemma().equals("road")) )
      return true;
  }
  return false;
}
 

import net.didion.jwnl.data.Word; //导入依赖的package包/类
private boolean isPersonSynset(Synset synset) {
  if( synset != null ) {
    Word[] words = synset.getWords();
    if( words.length > 0 && words[0].getLemma().equals("person") )
      return true;
  }
  return false;
}
 

import net.didion.jwnl.data.Word; //导入依赖的package包/类
private boolean isPhysicalObjectSynset(Synset synset) {
  if( synset != null ) {
    Word[] words = synset.getWords();
    if( words.length >= 2 && 
        (words[1].getLemma().equals("physical_object") || words[0].getLemma().equals("physical_object")) )
      return true;
  }
  return false;
}
 

import net.didion.jwnl.data.Word; //导入依赖的package包/类
public boolean isTimeSynset(Synset synset) {
  if( synset != null ) {
    Word[] words = synset.getWords();
    if( words.length >= 1 &&
        (words[0].getLemma().equals("time_period") || words[0].getLemma().equals("time") || words[0].getLemma().equals("time_unit")) )
      return true;
  }
  return false;
}
 

import net.didion.jwnl.data.Word; //导入依赖的package包/类
/**
 * A more precise lookup of physical structures (more precise than all physical objects)
 */
public boolean isStructure(String token) {
  if( _isStructure == null ) _isStructure = new HashMap<String, Boolean>();
  if( _isStructure.containsKey(token) ) return _isStructure.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 ) {
          //            System.out.println("\t" + parent);
          Word[] words = parent.getWords();
          if( words.length > 0 && words[0].getLemma().equals("structure") ) {
            _isStructure.put(token, true);
            return true;
          }
        }
      }
    }
  }
  _isStructure.put(token, false);
  return false;
}
 

import net.didion.jwnl.data.Word; //导入依赖的package包/类
/**
 * Assumes the given token is a noun.
 * @return true if the token has a synset with an ancestor that is the Event
 *         synset.
 */
public boolean isMeasure(String token) {
  // save time with a table lookup
  if( _isMeasure == null ) _isMeasure = new HashMap<String, Boolean>();
  if( _isMeasure.containsKey(token) ) return _isMeasure.get(token);

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

import net.didion.jwnl.data.Word; //导入依赖的package包/类
/**
 * Assumes the given token is a noun.
 * @return true if the token has a synset with an ancestor that is the Event
 *         synset.
 */
public boolean isNounEvent(String token) {
  // save time with a table lookup
  if( _isNounEvent == null ) _isNounEvent = new HashMap<String, Boolean>();
  if( _isNounEvent.containsKey(token) ) return _isNounEvent.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 ) {
      List<Synset> chain = hypernymChainKeepChild(synset);
      if( chain != null ) {
        for( Synset parent : chain ) {
          Word[] words = parent.getWords();
          if( words.length == 1 && words[0].getLemma().equals("event") ) {
            _isNounEvent.put(token, true);
            return true;
          }
        }
      }
    }
  }
  _isNounEvent.put(token, false);
  return false;
}
 

import net.didion.jwnl.data.Word; //导入依赖的package包/类
/**
 * Ctor
 * @param synset
 * @param strWord
 * @throws WordNetException 
 */
public JwnlSensedWord(JwnlSynset synset, String strWord) throws WordNetException {
	this.synset = synset;
	this.word = strWord;
	
	String wordToLookup = strWord.replace(' ', '_');	// mimic jwnl, which replaces underscores with spaces when looking up
 	Word[] words = synset.realSynset.getWords();
 	Word wordObj = lookupWordInWords(words, wordToLookup);
 	if (wordObj == null)
 		throw new WordNetException("\""+ strWord + "\" is not a memeber of the given synset " + synset);
 	this.wordObj = wordObj;
 	dictionary = synset.jwnlDictionary;
 	this.pos = JwnlUtils.getWordNetPartOfSpeech( wordObj.getPOS());
}
 

import net.didion.jwnl.data.Word; //导入依赖的package包/类
/**
 * @param words
 * @param wordToLookup 
 * @return
 */
private Word lookupWordInWords(Word[] words, String wordToLookup) {
 	boolean found = false;
 	Word someWord = null;
	for (int i = 0; i < words.length && !found; i++)
 	{
		someWord = words[i];
		found = someWord.getLemma().equalsIgnoreCase(wordToLookup);
 	}

	return someWord;
}
 

import net.didion.jwnl.data.Word; //导入依赖的package包/类
public Set<String> getWords() throws WordNetException
{
	if (words == null)
	{
		words = new HashSet<String>();
		for (Word word : this.realSynset.getWords())
		{
			String lemma = word.getLemma();
			lemma = lemma.replaceAll("_", " ");	// clean
			words.add(lemma);
		}
	}
	return new HashSet<String>(words);	// return a copy
}
 

import net.didion.jwnl.data.Word; //导入依赖的package包/类
public long getUsageOf(String word) throws WordNetException
{
	long ret = 0;
	Word[] wordsOfSynset = this.realSynset.getWords();
	for (Word wordOfSynset : wordsOfSynset)
	{
		if (wordOfSynset.getLemma().equals(word))
		{
			ret = wordOfSynset.getUsageCount();
		}
	}
	return ret;

}
 

import net.didion.jwnl.data.Word; //导入依赖的package包/类
public List<WordAndUsage> getWordsAndUsages() throws WordNetException
{
	List<WordAndUsage> ret = null;
	Word[] words = this.realSynset.getWords();
	ret = new ArrayList<WordAndUsage>(words.length);
	for (Word word : words)
	{
		// TODO handle this better
		try
		{
			ret.add(new WordAndUsage(word.getLemma(), word.getUsageCount()));
		}
		catch(NoSuchElementException e){} // a JWNL bug
	}
	Collections.sort(ret,
			Collections.reverseOrder( // I'm preferring correctness to performance (in this case)
					new Comparator<WordAndUsage>()
					{
						public int compare(WordAndUsage o1, WordAndUsage o2)
						{
							if (o1.getUsage()<o2.getUsage())return -1;
							else if (o1.getUsage()==o2.getUsage()) return 0;
							else return 1;
						}

					} // end of anonymous class Comparator
			) // end of reverseOrder function (which returns the reverse of the defined comparator)
	);
	
	return ret;
}
 

import net.didion.jwnl.data.Word; //导入依赖的package包/类
@Override
public List<SensedWord> getAllSensedWords() throws WordNetException {
	Word[] objWords = realSynset.getWords();
	List<SensedWord> sensedWords = new ArrayList<SensedWord>(objWords.length);
	for ( Word word : objWords)
		new JwnlSensedWord(word, this.jwnlDictionary);
	return sensedWords;
}