import net.didion.jwnl.data.PointerUtils; //导入依赖的package包/类
public Set<Synset> getRelatedSynsets(WordNetRelation relation, int chainingLength) throws WordNetException {
	if (chainingLength < 1)
		throw new WordNetException("chaining length must be positive. I got " + chainingLength);
	if (WordNetRelation.STRICT_2ND_DEGREE_COUSIN.equals(relation))
		throw new WordNetMethodNotSupportedException("Extracting cousin relations is currently not supported by JwnlDictionary. Use JwiDictionary instead");
	PointerType pointerType = JwnlUtils.wordNetRelationToPointerType(relation);
	
	if (pointerType == null)		
		// some relations (inc. SYNONYM) have no neighbors, cos they have no matching JWNL relation
		// other relations just don't exist in ext JWNL
		return new HashSet<Synset>();
	else
	{
		if (!relation.isTransitive())
			chainingLength = 1;			// most relations make no sense when chained
		try {	return getSetOfSynsets(PointerUtils.getInstance().makePointerTargetTreeList(realSynset, pointerType, chainingLength));	}
		catch (JWNLException e) { throw new WordNetException("see nested" , e);	}
	}
}
 

import net.didion.jwnl.data.PointerUtils; //导入依赖的package包/类
public Set<Synset> getCoordinateTerms() throws WordNetException
{
	try {
		return getSetOfSynsets(PointerUtils.getInstance().getCoordinateTerms(this.realSynset));
	} catch (JWNLException e) {
		throw new WordNetException("See nested", e);
	}
}
 

import net.didion.jwnl.data.PointerUtils; //导入依赖的package包/类
public Set<Synset> getHolonyms() throws WordNetException
{
	try {
		return getSetOfSynsets(PointerUtils.getInstance().getHolonyms(this.realSynset));
	} catch (JWNLException e) {
		throw new WordNetException("See nested", e);
	}
}
 

import net.didion.jwnl.data.PointerUtils; //导入依赖的package包/类
public Set<Synset> getMeronyms() throws WordNetException
{
	try {
		return getSetOfSynsets(PointerUtils.getInstance().getMeronyms(this.realSynset));
	} catch (JWNLException e) {
		throw new WordNetException("See nested", e);
	}
}
 

import net.didion.jwnl.data.PointerUtils; //导入依赖的package包/类
/**
 * Initializes static resources.  The input properties that must be defined are:
 * <ul>
 *   <li>jwnl.configuration : </p>&nbsp; the location of the configuration file for JWNL
 *   <li>edu.cmu.lti.javelin.qa.english.WordNetAnswerTypeMapping.mapFile :
 *   <p>&nbsp; the location of the file specifying a mapping from WordNet synsets
 *   to answer subtypes.  The one-to-many mapping must be specified  
 *   one element per line, with the domain and range values separated by a comma. 
 *   Blank lines and lines beginning with "#" are ignored.  WordNet synsets must be
 *   represented by concatenating the list of lemmas in the synset, separating them 
 *   with a dash ("-"), followed by another "-" and the database file offset of the synset.
 *   (Note: this offset value will vary with the version of WordNet used.)</p>
 *   &nbsp; Thus, an example of an element of the mapping is:</p>
 *     <code>body_of_water-water-8651117,ocean</code>
 * </ul>
 * @throws Exception if one of the required properties is not defined.
 */
public static void initialize() throws Exception {
    if (isInitialized()) return;
    
    if (!JWNL.isInitialized()) {
        String file_properties = System.getProperty("jwnl.configuration");
        if (file_properties == null)
            throw new Exception("Required property 'jwnl.configuration' is undefined");
        JWNL.initialize(new FileInputStream(file_properties));
    }
    pUtils = PointerUtils.getInstance();
    
    Properties properties = Properties.loadFromClassName(WordNetAnswerTypeMapping.class.getName());
    
    String wnAtypeMapFile = properties.getProperty("mapFile");
    if (wnAtypeMapFile == null)
        throw new RuntimeException("Required parameter mapFile is undefined");

    BufferedReader in = new BufferedReader(new FileReader(wnAtypeMapFile));
    String line;
    wnAtypeMap = new HashMap<String, String>();
    wnAtypeMapKeys = new ArrayList<String>();
    while ((line = in.readLine()) != null) {
        if (line.matches("#.*") || line.matches("\\s*")) continue;
        String[] strs = line.split(",");
        wnAtypeMap.put(strs[0],strs[1]);
        wnAtypeMapKeys.add(strs[0]);
    }
    in.close();
    setInitialized(true);
}
 

import net.didion.jwnl.data.PointerUtils; //导入依赖的package包/类
private static Synset[] getHypernymSynsets(Synset synset) {
	PointerTargetNodeList hypernyms = null;
	try {
		hypernyms = PointerUtils.getInstance().getDirectHypernyms(synset);
	} catch (JWNLException e) {}
	if (hypernyms == null) return null;
	
	return getSynsets(hypernyms);
}
 

import net.didion.jwnl.data.PointerUtils; //导入依赖的package包/类
private static Synset[] getHyponymSynsets(Synset synset) {
	PointerTargetNodeList hyponyms = null;
	try {
		hyponyms = PointerUtils.getInstance().getDirectHyponyms(synset);
	} catch (JWNLException e) {}
	if (hyponyms == null) return null;
	
	return getSynsets(hyponyms);
}
 

import net.didion.jwnl.data.PointerUtils; //导入依赖的package包/类
private static Synset[] getEntailingSynsets(Synset synset) {
	PointerTargetNodeList entailing = null;
	try {
		entailing = PointerUtils.getInstance().getEntailments(synset);
	} catch (JWNLException e) {}
	if (entailing == null) return null;
	
	return getSynsets(entailing);
}
 

import net.didion.jwnl.data.PointerUtils; //导入依赖的package包/类
private static Synset[] getCausingSynsets(Synset synset) {
	PointerTargetNodeList causing = null;
	try {
		causing = PointerUtils.getInstance().getCauses(synset);
	} catch (JWNLException e) {}
	if (causing == null) return null;
	
	return getSynsets(causing);
}
 

import net.didion.jwnl.data.PointerUtils; //导入依赖的package包/类
private static Synset[] getMemberOfSynsets(Synset synset) {
	PointerTargetNodeList membersOf = null;
	try {
		membersOf = PointerUtils.getInstance().getMemberHolonyms(synset);
	} catch (JWNLException e) {}
	if (membersOf == null) return null;
	
	return getSynsets(membersOf);
}
 

import net.didion.jwnl.data.PointerUtils; //导入依赖的package包/类
private static Synset[] getSubstanceOfSynsets(Synset synset) {
	PointerTargetNodeList substancesOf = null;
	try {
		substancesOf = PointerUtils.getInstance().getSubstanceHolonyms(synset);
	} catch (JWNLException e) {}
	if (substancesOf == null) return null;
	
	return getSynsets(substancesOf);
}
 

import net.didion.jwnl.data.PointerUtils; //导入依赖的package包/类
private static Synset[] getPartOfSynsets(Synset synset) {
	PointerTargetNodeList partsOf = null;
	try {
		partsOf = PointerUtils.getInstance().getPartHolonyms(synset);
	} catch (JWNLException e) {}
	if (partsOf == null) return null;
	
	return getSynsets(partsOf);
}
 

import net.didion.jwnl.data.PointerUtils; //导入依赖的package包/类
private static Synset[] getHasMemberSynsets(Synset synset) {
	PointerTargetNodeList haveMember = null;
	try {
		haveMember = PointerUtils.getInstance().getMemberMeronyms(synset);
	} catch (JWNLException e) {}
	if (haveMember == null) return null;
	
	return getSynsets(haveMember);
}
 

import net.didion.jwnl.data.PointerUtils; //导入依赖的package包/类
private static Synset[] getHasSubstanceSynsets(Synset synset) {
	PointerTargetNodeList haveSubstance = null;
	try {
		haveSubstance = PointerUtils.getInstance().getSubstanceMeronyms(synset);
	} catch (JWNLException e) {}
	if (haveSubstance == null) return null;
	
	return getSynsets(haveSubstance);
}
 

import net.didion.jwnl.data.PointerUtils; //导入依赖的package包/类
private static Synset[] getHasPartSynsets(Synset synset) {
	PointerTargetNodeList havePart = null;
	try {
		havePart = PointerUtils.getInstance().getPartMeronyms(synset);
	} catch (JWNLException e) {}
	if (havePart == null) return null;
	
	return getSynsets(havePart);
}
 

import net.didion.jwnl.data.PointerUtils; //导入依赖的package包/类
public double findMatchForAdj(IndexWord index1, IndexWord index2) {
    // the max number of common concepts between the two tokens
    double value = 0;

    if (index1 != null && index2 != null) {
        // The two tokens existe in WordNet, we find the "depth"
        try {
            // Synsets for each token
            Synset[] Syno1 = index1.getSenses();
            Synset[] Syno2 = index2.getSenses();
            for (int i = 0; i < index1.getSenseCount(); i++) {

                Synset synset1 = Syno1[i];
                for (int k = 0; k < index2.getSenseCount(); k++) {

                    Synset synset2 = Syno2[k];

                    PointerTargetNodeList adjSynonymList = 
                        PointerUtils.getInstance().getSynonyms(synset1);

                    Iterator listIt = adjSynonymList.iterator();
                    // browse lists
                    while (listIt.hasNext()) {
                        PointerTargetNode ptn = (PointerTargetNode) listIt.next();
                        if (ptn.getSynset() == synset2) {
                            value = 1;
                        }
                    }
                }
            }
            // System.err.println("value = " + value);
            return value;
        }
        catch (JWNLException je) {
            je.printStackTrace();
            System.exit(-1);
        }
    }
    return 0;
}
 

import net.didion.jwnl.data.PointerUtils; //导入依赖的package包/类
private void demonstrateListOperation(IndexWord word) throws JWNLException {
	// Get all of the hypernyms (parents) of the first sense of <var>word</var>
	PointerTargetNodeList hypernyms = PointerUtils.getInstance().getDirectHypernyms(word.getSense(1));
	System.out.println("Direct hypernyms of \"" + word.getLemma() + "\":");
	hypernyms.print();
}
 

import net.didion.jwnl.data.PointerUtils; //导入依赖的package包/类
private void demonstrateTreeOperation(IndexWord word) throws JWNLException {
	// Get all the hyponyms (children) of the first sense of <var>word</var>
	PointerTargetTree hyponyms = PointerUtils.getInstance().getHyponymTree(word.getSense(1));
	System.out.println("Hyponyms of \"" + word.getLemma() + "\":");
	hyponyms.print();
}