Java PointerTargetTreeNodeList类代码示例

import net.didion.jwnl.data.list.PointerTargetTreeNodeList; //导入依赖的package包/类
/** A symmetric relationship is one whose type is symmetric (i.e. is it's own inverse). */
private RelationshipList findSymmetricRelationships(
    final Synset sourceSynset, final Synset targetSynset, PointerType type, int depth) throws JWNLException {

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

	PointerTargetTreeNodeList.Operation opr = new PointerTargetTreeNodeList.Operation() {
		public Object execute(PointerTargetTreeNode testNode) {
                if (targetSynset.equals(testNode.getSynset())) {
                   
				return testNode;
			}
			return null;
		}
	};
	List l = tree.getAllMatches(opr);

	RelationshipList list = new RelationshipList();
	for (int i = 0; i < l.size(); i++) {
		PointerTargetNodeList nodes = findSymmetricRelationship((PointerTargetTreeNode)l.get(i), type);
		list.add(new SymmetricRelationship(type, nodes, sourceSynset, targetSynset));
	}
	return list;
}
 

import net.didion.jwnl.data.list.PointerTargetTreeNodeList; //导入依赖的package包/类
/**
 * Turn an existing tree list into an inheritance tree list.
 * @param list the tree list to convert
 * @param searchTypes the pointer types to include in the pointer lists
 * @param labelType the <code>PointerType</code> with which to label each pointer
 * @param pointerDepth the depth to which to search for each pointer list
 * @param ancestorDepth the depth to which to go to in <code>tree</code>
 * @param allowRedundancies if true, duplicate items are allowed in the list
 */
public PointerTargetTreeNodeList makeInheritedTreeList(PointerTargetTreeNodeList list,
                                                       PointerType[] searchTypes, PointerType labelType,
                                                       int pointerDepth, int ancestorDepth,
                                                       boolean allowRedundancies) throws JWNLException {
	ancestorDepth--;
	PointerTargetTreeNodeList inherited = new PointerTargetTreeNodeList();
	for (Iterator itr = list.iterator(); itr.hasNext();) {
		PointerTargetTreeNode node = (PointerTargetTreeNode) itr.next();
		if (allowRedundancies || !inherited.contains(node)) {
			if (ancestorDepth == 0) {
				inherited.add(node.getPointerTarget(),
				              null,
				              makePointerTargetTreeList(node.getSynset(), searchTypes, labelType, pointerDepth, allowRedundancies),
				              PointerType.HYPERNYM);
			} else {
				inherited.add(node.getPointerTarget(),
				              makeInheritedTreeList(node.getChildTreeList(), searchTypes, labelType,
				                                    pointerDepth, ancestorDepth, allowRedundancies),
				              makePointerTargetTreeList(node.getSynset(), searchTypes, labelType, pointerDepth, allowRedundancies),
				              PointerType.HYPERNYM);
			}
		}
	}
	return inherited;
}
 

import net.didion.jwnl.data.list.PointerTargetTreeNodeList; //导入依赖的package包/类
/**
 * Harvest all the synsets from this {@link PointerTargetTreeNodeList}, iteratively and recursively. Each treeNode holds a synset, and a pointer to a child list 
 * of treeNodes.
 * 
 * @param pointerTargetTreeList must not be null!
 * @return
 * @throws WordNetException 
 */
protected Set<Synset> getSetOfSynsets(PointerTargetTreeNodeList pointerTargetTreeList) throws WordNetException {
	Set<Synset> ret = new HashSet<Synset>();
	for (Object treeNodeAsObject : pointerTargetTreeList)
	{
		if (!(treeNodeAsObject instanceof PointerTargetTreeNode))
			throw new WordNetException("Internal error. this was supposed to be a PointerTargetTreeNodeList: " + pointerTargetTreeList);
		PointerTargetTreeNode treeNode = (PointerTargetTreeNode) treeNodeAsObject;
		ret.add(new JwnlSynset(jwnlDictionary, treeNode.getSynset()));
		if (treeNode.hasValidChildTreeList())
			ret.addAll(getSetOfSynsets(treeNode.getChildTreeList()));
	}
	return ret;
}
 

import net.didion.jwnl.data.list.PointerTargetTreeNodeList; //导入依赖的package包/类
/** Find all antonyms of <code>synset</code>, and all synonyms of those antonyms to depth <code>depth</code>. */
public PointerTargetTree getExtendedAntonyms(Synset synset, int depth) throws JWNLException {
	PointerTargetTreeNodeList list = new PointerTargetTreeNodeList();
	if (synset.getPOS() == POS.ADJECTIVE) {
		PointerTargetNodeList antonyms = getAntonyms(synset);
		list = makePointerTargetTreeList(antonyms, PointerType.SIMILAR_TO, PointerType.ANTONYM, depth, false);
	}
	return new PointerTargetTree(new PointerTargetTreeNode(synset, list, null));
}
 

import net.didion.jwnl.data.list.PointerTargetTreeNodeList; //导入依赖的package包/类
/** Get the antonyms of all words that mean the same as <code>synset</code> to depth <code>depth</code>.*/
public PointerTargetTree getIndirectAntonyms(Synset synset, int depth) throws JWNLException {
	PointerTargetTreeNodeList list = new PointerTargetTreeNodeList();
	if (synset.getPOS() == POS.ADJECTIVE) {
		PointerTargetNodeList synonyms = getSynonyms(synset);
		list = makePointerTargetTreeList(synonyms, PointerType.ANTONYM, PointerType.ANTONYM, depth, false);
	}
	return new PointerTargetTree(new PointerTargetTreeNode(synset, list, null));
}
 

import net.didion.jwnl.data.list.PointerTargetTreeNodeList; //导入依赖的package包/类
/**
 * Make a nested list of pointer targets to depth <var>depth</var>, starting at <code>synset</code>. Each
 * level of the list is related to the previous level by a pointer of type <var>searchType</var>.
 * @param labelType the type used to label each pointer target in the tree
 * @param allowRedundancies if true, duplicate items will be included in the tree
 */
public PointerTargetTreeNodeList makePointerTargetTreeList(Synset set, PointerType searchType,
                                                           PointerType labelType, int depth,
                                                           boolean allowRedundancies) throws JWNLException {
	PointerType[] searchTypes = new PointerType[1];
	searchTypes[0] = searchType;
	return makePointerTargetTreeList(set, searchTypes, labelType, depth, allowRedundancies);
}