import net.sf.extjwnl.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 ExtJwnlDictionary. Use JwiDictionary instead");
	
	PointerType pointerType = ExtJwnlUtils.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 LinkedHashSet<Synset>();
	else {
		if (realSynset==null)
			throw new WordNetException("Internal bug: realSynset is null!");
		return getSetOfSynsets(PointerUtils.makePointerTargetTreeList(realSynset, pointerType,chainingLength));
	}
}
 

import net.sf.extjwnl.data.PointerUtils; //导入依赖的package包/类
public List<ISense> getParents(int depth) throws LinguisticOracleException {
    List<ISense> out = new ArrayList<>();
    try {
        PointerTargetTree hypernyms = PointerUtils.getHypernymTree(synset, depth);
        for (Iterator itr = hypernyms.toList().iterator(); itr.hasNext(); ) {
            if (itr.hasNext()) {
                for (Object o : ((PointerTargetNodeList) itr.next())) {
                    Synset t = ((PointerTargetNode) o).getSynset();
                    if (!synset.equals(t)) {
                        out.add(new WordNetSense(t));
                    }
                }
            }
        }
    } catch (JWNLException e) {
        throw new LinguisticOracleException(e.getClass().getSimpleName() + ": " + e.getMessage(), e);
    }
    return out;
}
 

import net.sf.extjwnl.data.PointerUtils; //导入依赖的package包/类
public List<ISense> getChildren(int depth) throws LinguisticOracleException {
    List<ISense> out = new ArrayList<>();
    try {
        PointerTargetTree hypernyms = PointerUtils.getHyponymTree(synset, depth);
        for (Iterator itr = hypernyms.toList().iterator(); itr.hasNext(); ) {
            if (itr.hasNext()) {
                for (Object o : ((PointerTargetNodeList) itr.next())) {
                    Synset t = ((PointerTargetNode) o).getSynset();
                    if (!synset.equals(t)) {
                        out.add(new WordNetSense(t));
                    }
                }
            }
        }
    } catch (JWNLException e) {
        throw new LinguisticOracleException(e.getClass().getSimpleName() + ": " + e.getMessage(), e);
    }
    return out;
}
 

import net.sf.extjwnl.data.PointerUtils; //导入依赖的package包/类
/**
 * Finds the asymmetric relationship(s) between two words. A relationship is
 * asymmetric if its type is asymmetric (i.e. it's not its own inverse).
 *
 * @param sourceSynset source synset
 * @param targetSynset target synset
 * @param type         pointer type
 * @param depth        depth
 * @return all relationships of type <var>type</var> between <var>sourceSynset</var> and <var>targetSynset</var>
 * @throws CloneNotSupportedException CloneNotSupportedException
 */
private static RelationshipList findAsymmetricRelationships(
        Synset sourceSynset, Synset targetSynset, PointerType type, int depth) throws CloneNotSupportedException, JWNLException {

    // We run the reversal function on the trees to get linear (non-branching)
    // paths from the source word to its deepest ancestor (i.e. if there are
    // multiple relations from a single word anywhere in the path, the reversal
    // function will break them down into multiple, linear paths).
    List<PointerTargetNodeList> sourceRelations = new PointerTargetTree(
            sourceSynset, PointerUtils.makePointerTargetTreeList(sourceSynset, type, depth)).reverse();
    List<PointerTargetNodeList> targetRelations = new PointerTargetTree(
            targetSynset, PointerUtils.makePointerTargetTreeList(targetSynset, type, depth)).reverse();

    RelationshipList relationships = new RelationshipList();
    // Do an exhaustive search for relationships
    for (PointerTargetNodeList sourceRelation : sourceRelations) {
        for (PointerTargetNodeList targetRelation : targetRelations) {
            Relationship relationship = findAsymmetricRelationship(
                    sourceRelation, targetRelation, type, sourceSynset, targetSynset);
            if (relationship != null) {
                relationships.add(relationship);
            }
        }
    }
    return relationships;
}
 

import net.sf.extjwnl.data.PointerUtils; //导入依赖的package包/类
/**
 * A symmetric relationship is one whose type is symmetric (i.e. is it's own inverse).
 *
 * @param type         pointer type
 * @param sourceSynset source synset
 * @param targetSynset target synset
 * @param depth        depth
 * @return list of symmetric relationships between source and target
 */
private static RelationshipList findSymmetricRelationships(
        final Synset sourceSynset, final Synset targetSynset, PointerType type, int depth) throws JWNLException {

    PointerTargetTree tree = new PointerTargetTree(
            sourceSynset, PointerUtils.makePointerTargetTreeList(sourceSynset, type, null, depth, false));

    PointerTargetTreeNodeList.Operation opr = new PointerTargetTreeNodeList.Operation() {
        public PointerTargetTreeNode execute(PointerTargetTreeNode testNode) {
            if (targetSynset.equals(testNode.getSynset())) {

                return testNode;
            }
            return null;
        }
    };
    List l = tree.getAllMatches(opr);

    RelationshipList list = new RelationshipList();
    for (Object aL : l) {
        PointerTargetNodeList nodes = findSymmetricRelationship((PointerTargetTreeNode) aL, type);
        list.add(new SymmetricRelationship(type, nodes, sourceSynset, targetSynset));
    }
    return list;
}
 

import net.sf.extjwnl.data.PointerUtils; //导入依赖的package包/类
public List<ISense> getParents(int depth) {
    List<ISense> out = new ArrayList<ISense>();
    PointerTargetTree hypernyms = PointerUtils.getHypernymTree(synset, depth);
    for (Iterator itr = hypernyms.toList().iterator(); itr.hasNext(); ) {
        if (itr.hasNext()) {
            for (Object o : ((PointerTargetNodeList) itr.next())) {
                Synset t = ((PointerTargetNode) o).getSynset();
                if (!synset.equals(t)) {
                    out.add(new WordNetSense(t));
                }
            }
        }
    }
    return out;
}
 

import net.sf.extjwnl.data.PointerUtils; //导入依赖的package包/类
public List<ISense> getChildren(int depth) {
    List<ISense> out = new ArrayList<ISense>();
    PointerTargetTree hypernyms = PointerUtils.getHyponymTree(synset, depth);
    for (Iterator itr = hypernyms.toList().iterator(); itr.hasNext(); ) {
        if (itr.hasNext()) {
            for (Object o : ((PointerTargetNodeList) itr.next())) {
                Synset t = ((PointerTargetNode) o).getSynset();
                if (!synset.equals(t)) {
                    out.add(new WordNetSense(t));
                }
            }
        }
    }
    return out;
}
 

import net.sf.extjwnl.data.PointerUtils; //导入依赖的package包/类
public Set<Synset> getAlsoSees() throws WordNetException
{
	return getSetOfSynsets(PointerUtils.getAlsoSees(this.realSynset));
}
 

import net.sf.extjwnl.data.PointerUtils; //导入依赖的package包/类
public Set<Synset> getAntonyms() throws WordNetException
{
	return getSetOfSynsets(PointerUtils.getAntonyms(this.realSynset));
}
 

import net.sf.extjwnl.data.PointerUtils; //导入依赖的package包/类
public Set<Synset> getAttributes() throws WordNetException
{
	return getSetOfSynsets(PointerUtils.getAttributes(this.realSynset));
}
 

import net.sf.extjwnl.data.PointerUtils; //导入依赖的package包/类
public Set<Synset> getCauses() throws WordNetException
{
	return getSetOfSynsets(PointerUtils.getCauses(this.realSynset));
}
 

import net.sf.extjwnl.data.PointerUtils; //导入依赖的package包/类
public Set<Synset> getCoordinateTerms() throws WordNetException
{
	return getSetOfSynsets(PointerUtils.getCoordinateTerms(this.realSynset));
}
 

import net.sf.extjwnl.data.PointerUtils; //导入依赖的package包/类
public Set<Synset> getEntailments() throws WordNetException
{
	return getSetOfSynsets(PointerUtils.getEntailments(this.realSynset));
}
 

import net.sf.extjwnl.data.PointerUtils; //导入依赖的package包/类
public Set<Synset> getHolonyms() throws WordNetException
{
	return getSetOfSynsets(PointerUtils.getHolonyms(this.realSynset));
}
 

import net.sf.extjwnl.data.PointerUtils; //导入依赖的package包/类
public Set<Synset> getHypernyms() throws WordNetException
{
	return getSetOfSynsets(PointerUtils.getDirectHypernyms(this.realSynset));
}
 

import net.sf.extjwnl.data.PointerUtils; //导入依赖的package包/类
public Set<Synset> getHyponyms() throws WordNetException
{
	return getSetOfSynsets(PointerUtils.getDirectHyponyms(this.realSynset));
}
 

import net.sf.extjwnl.data.PointerUtils; //导入依赖的package包/类
public Set<Synset> getMemberHolonyms() throws WordNetException
{
	return getSetOfSynsets(PointerUtils.getMemberHolonyms(this.realSynset));
}
 

import net.sf.extjwnl.data.PointerUtils; //导入依赖的package包/类
public Set<Synset> getMemberMeronyms() throws WordNetException
{
	return getSetOfSynsets(PointerUtils.getMemberMeronyms(this.realSynset));
}
 

import net.sf.extjwnl.data.PointerUtils; //导入依赖的package包/类
public Set<Synset> getMeronyms() throws WordNetException
{
	return getSetOfSynsets(PointerUtils.getMeronyms(this.realSynset));
}
 

import net.sf.extjwnl.data.PointerUtils; //导入依赖的package包/类
public Set<Synset> getPartHolonyms() throws WordNetException
{
	return getSetOfSynsets(PointerUtils.getPartHolonyms(this.realSynset));
}