kb.hierarchy

Class TypeHierarchy

Object

kb.hierarchy.POSet

kb.hierarchy.TypeHierarchy

public class TypeHierarchy
extends POSet

Treats a hierarchy just like a partially ordered set, except that there is one "bottom" node. Can be used for either a relation or concept type hierarchy. By default in Charger, every concept and relation type is added to its respective hierarchy, with TYPE_DEFAULT_TOP_LABEL as their supertype and DEFAULT_BOTTOM_LABEL as their subtype. Only using the genspeclink can real supertypes and subtypes be denoted.

Author:

Harry Delugach

See Also:

TypeHierarchyNode

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	TypeHierarchy.KindOfHierarchy

Field Summary

Fields

Modifier and Type	Field and Description
static String	DEFAULT_BOTTOM_LABEL
protected TypeHierarchyNode	infinum
protected TypeHierarchy.KindOfHierarchy	kind
(package private) TypeMatchingRuleSet	matchRules
protected String	name
static String	RELATION_DEFAULT_NAME
static String	RELATION_DEFAULT_TOP_LABEL
protected TypeHierarchyNode	relationRoot
protected TypeHierarchyNode	root
static String	TYPE_DEFAULT_NAME
static String	TYPE_DEFAULT_TOP_LABEL
protected TypeHierarchyNode	typeRoot

Fields inherited from class kb.hierarchy.POSet

allnodes

Constructor Summary

Constructors

Constructor and Description
TypeHierarchy() Creates a new hierarchy with the same root values as the other constructors, but uses TYPE_DEFAULT_NAME and makes it a type hierarchy by default.
TypeHierarchy(String newname, TypeHierarchy.KindOfHierarchy kind) Creates a new hierarchy, but it is not empty.

Method Summary

Modifier and Type	Method and Description
boolean	addSubtypeToType(GNode subtypeObject, GNode supertypeObject) Adds the label of the supertype to the hierarchy if it isn't there.
boolean	addSubtypeToType(String subtypeLabel, String supertypeLabel) Basic construction unit for hierarchy.
void	addToTopAndBottom(TypeHierarchyNode node) Makes sure that the already added-node is linked to the top and bottom.
TypeHierarchyNode	addTypeLabel(String name) Adds a label in a node to the hierarchy.
TypeHierarchyNode	getBottom() Get the node at the bottom of the hierarchy.
ArrayList<String>	getKeys() Get all the type name keys in this hierarchy.
ArrayList<String>	getLabelsAsValues() Get all the type labels in this hierarchy.
String	getName() Get the name of this hierarchy, the one given when it was created or by setName.
TypeHierarchyNode	getNodeByValue(String value) Finds a node whose key (previously transformed from its value) matches the value once it is also transformed.
TypeHierarchyNode	getTop() Return the node at the top of this hierarchy.
boolean	isIgnoreCase() Convenience method to tell whether there's an ignore case rule
boolean	isIgnoreSpaces() Convenience method to tell whether there's an ignore spaces rule
boolean	isIgnoreSpecial() Convenience method to tell whether there's an ignore special characters rule
String	isRedundantSuperSubtype(String supertypeString, String subtypeString) Detects whether adding a specialization between the two terms will create a redundant or cyclic hierarchy.
String	makeKey(String value) Apply the rules, successively transforming the value into the key.
boolean	matchByRules(TypeMatchingRuleSet rules, TypeHierarchyNode node, String value) Determine whether a node's value matches a given value after applying the rules.
boolean	matchByRules(TypeMatchingRuleSet rules, TypeHierarchyNode node1, TypeHierarchyNode node2) Determine whether two nodes match values after applying the rules.
boolean	removeSuperTypeFromType(GraphObject supertypeObject, GraphObject subtypeObject) Removes the super/sub type relationship between the nodes.
boolean	removeSuperTypeFromType(String supertypeString, String subtypeString) Removes the super/sub type relationship between the nodes.
boolean	removeSuperTypeFromType(TypeHierarchyNode sup, TypeHierarchyNode sub)
boolean	removeTypeLabel(String value) Removes a label from the hierarchy, without any super or sub types.
void	setIgnoreCase(boolean ignoreCase) Convenience method to set an ignore/consider case rule.
void	setIgnoreSpaces(boolean ignoreSpaces) Convenience method to set an ignore/consider spaces rule.
void	setIgnoreSpecial(boolean ignoreSpecial) Convenience method to set an ignore/consider special characters rule.
void	setName(String name) Set the human-readable name of this hierarchy.
String	showHierarchy()
String	showHierarchy(String start) Displays all hierarchy nodes in very clunky text

Methods inherited from class kb.hierarchy.POSet

addNode, clear, deleteNode, getCardinality, getNodeByKey

Methods inherited from class Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

TYPE_DEFAULT_TOP_LABEL

public static String TYPE_DEFAULT_TOP_LABEL

RELATION_DEFAULT_TOP_LABEL

public static String RELATION_DEFAULT_TOP_LABEL

DEFAULT_BOTTOM_LABEL

public static String DEFAULT_BOTTOM_LABEL

TYPE_DEFAULT_NAME

public static String TYPE_DEFAULT_NAME

RELATION_DEFAULT_NAME

public static String RELATION_DEFAULT_NAME

typeRoot

protected TypeHierarchyNode typeRoot

relationRoot

protected TypeHierarchyNode relationRoot

root

protected TypeHierarchyNode root

infinum

protected TypeHierarchyNode infinum

name

protected String name

kind

protected TypeHierarchy.KindOfHierarchy kind

matchRules

TypeMatchingRuleSet matchRules

Constructor Detail

TypeHierarchy

public TypeHierarchy(String newname,
                     TypeHierarchy.KindOfHierarchy kind)

Creates a new hierarchy, but it is not empty. It has a root value of TYPE_DEFAULT_TOP_LABEL and a bottom value of DEFAULT_BOTTOM_LABEL.

Parameters:

newname - An optional name for this hierarchy

TypeHierarchy

public TypeHierarchy()

Creates a new hierarchy with the same root values as the other constructors, but uses TYPE_DEFAULT_NAME and makes it a type hierarchy by default.

Method Detail

getTop

public TypeHierarchyNode getTop()

Return the node at the top of this hierarchy.

Returns:

the top node of the hierarchy

getBottom

public TypeHierarchyNode getBottom()

Get the node at the bottom of the hierarchy. Returns the last node set by setBottom.

Returns:

bottom node

getName

public String getName()

Get the name of this hierarchy, the one given when it was created or by setName.

Returns:

an English label for the hierarchy.

setName

public void setName(String name)

Set the human-readable name of this hierarchy.

Parameters:

name -

makeKey

public String makeKey(String value)

Apply the rules, successively transforming the value into the key.

Parameters:

value - the original value to be stored.

Returns:

The altered value, obeying the matching rules. If the value is strictly equal to TYPE_DEFAULT_TOP_LABEL or the TYPE_DEFAULT_TOP_LABEL, then the original value is returned.

isIgnoreCase

public boolean isIgnoreCase()

Convenience method to tell whether there's an ignore case rule

Returns:

true if there's an ignore case rule in this hierarchy's rule set; false otherwise.

setIgnoreCase

public void setIgnoreCase(boolean ignoreCase)

Convenience method to set an ignore/consider case rule.

Parameters:

ignoreCase - true if we want to set IgnoreCase, false if we want to set ConsiderCase. Removes a conflicting rule if present.

isIgnoreSpaces

public boolean isIgnoreSpaces()

Convenience method to tell whether there's an ignore spaces rule

Returns:

true if there's an ignore spaces rule in this hierarchy's rule set; false otherwise.

setIgnoreSpaces

public void setIgnoreSpaces(boolean ignoreSpaces)

Convenience method to set an ignore/consider spaces rule.

Parameters:

ignoreSpaces - true if we want to set IgnoreSpaces, false if we want to set ConsiderSpaces. Removes a conflicting rule if present.

isIgnoreSpecial

public boolean isIgnoreSpecial()

Convenience method to tell whether there's an ignore special characters rule

Returns:

true if there's an ignore special characters rule in this hierarchy's rule set; false otherwise.

setIgnoreSpecial

public void setIgnoreSpecial(boolean ignoreSpecial)

Convenience method to set an ignore/consider special characters rule.

Parameters:

ignoreSpecial - true if we want to set IgnoreSpecial, false if we want to set ConsiderSpecial. Removes a conflicting rule if present.

addToTopAndBottom

public void addToTopAndBottom(TypeHierarchyNode node)

Makes sure that the already added-node is linked to the top and bottom. For a regular concept label, this is all we can know. If the label already was in the hierarchy, then we wouldn't have to add it.

Parameters:

node - A node that has already been added

addTypeLabel

public TypeHierarchyNode addTypeLabel(String name)

Adds a label in a node to the hierarchy. If the label doesn't already exist, creates a TypeHierarchyNode for it, and set it as subtype to top and supertype to bottom. If a label forming the same key as this already exists, adds the name to that node (if it's not already in the node) If the label is either the top or bottom, return null.

Parameters:

name - of the label to be added.

Returns:

the node if it was added. If only a value was added to an existing node, returns null.

removeTypeLabel

public boolean removeTypeLabel(String value)

Removes a label from the hierarchy, without any super or sub types. Before deleting, must connect all of its supertypes to its subtypes.

Parameters:

value - of the label to be removed.

Returns:

true if the label was removed successfully.

getKeys

public ArrayList<String> getKeys()

Get all the type name keys in this hierarchy.

Returns:

a sorted list of type keys.

getLabelsAsValues

public ArrayList<String> getLabelsAsValues()

Get all the type labels in this hierarchy.

Returns:

a sorted list of type labels.

addSubtypeToType

public boolean addSubtypeToType(GNode subtypeObject,
                                GNode supertypeObject)

Adds the label of the supertype to the hierarchy if it isn't there. Adds the label of the subtype to the hierarchy if it isn't there. Makes the link between them. If there's already a supertype relationship (direct or indirect) then nothing is changed. If either of them is null, then return false.

Parameters:

subtypeObject -

supertypeObject -

Returns:

true if something was changed (either was added or a subsumption relationship was added; false otherwise

addSubtypeToType

public boolean addSubtypeToType(String subtypeLabel,
                                String supertypeLabel)

Basic construction unit for hierarchy. Create the sub- to super-type relationship. If there's already a direct or indirect such relationship, then return false. Create type nodes for either one if they do not already exist. If the subtype is the same as the top ("T"), then return false, since we can't create a supertype to the root. Likewise if the supertype is the same as the bottom ("absurd") type, we also return false.

Parameters:

subtypeLabel - The label being used as a subtype. will be turned into a key before inserting

supertypeLabel - The label being used as a supertype. will be turned into a key before inserting.

Returns:

true if the relationship was created, false if it failed for any of the above reasons.

removeSuperTypeFromType

public boolean removeSuperTypeFromType(GraphObject supertypeObject,
                                       GraphObject subtypeObject)

Removes the super/sub type relationship between the nodes.

Parameters:

supertypeObject -

subtypeObject -

Returns:

true if relationship was successfully removed; false otherwise.

removeSuperTypeFromType

public boolean removeSuperTypeFromType(String supertypeString,
                                       String subtypeString)

Removes the super/sub type relationship between the nodes.

Parameters:

supertypeString - The label being used as a supertype.

subtypeString -

Returns:

true if the relationship was created, false if it failed for any of the above reasons.

removeSuperTypeFromType

public boolean removeSuperTypeFromType(TypeHierarchyNode sup,
                                       TypeHierarchyNode sub)

matchByRules

public boolean matchByRules(TypeMatchingRuleSet rules,
                            TypeHierarchyNode node1,
                            TypeHierarchyNode node2)

Determine whether two nodes match values after applying the rules. In theory, the keys should already reflect the values' transformations into the keys, but since rules may have changed, we re-do the check.

Parameters:

rules - The rules to be applied

node1 - A first node -- the order does not matter

node2 - a second node

Returns:

true if the node's values match after being transformed by the rules.

matchByRules

public boolean matchByRules(TypeMatchingRuleSet rules,
                            TypeHierarchyNode node,
                            String value)

Determine whether a node's value matches a given value after applying the rules. In theory, the key of the node should already reflect its value's transformations into the keys, but since rules may have changed, we re-do the check.

Parameters:

rules - The rules to be applied

node - A node whose value is to be compared.

value - a string to be compared

Returns:

true if the node's value matches the string after being transformed by the rules.

getNodeByValue

public TypeHierarchyNode getNodeByValue(String value)

Finds a node whose key (previously transformed from its value) matches the value once it is also transformed.

Parameters:

value - The value to be transformed and matched

Returns:

the node that matches; null otherwise

isRedundantSuperSubtype

public String isRedundantSuperSubtype(String supertypeString,
                                      String subtypeString)

Detects whether adding a specialization between the two terms will create a redundant or cyclic hierarchy.

Parameters:

supertypeString -

subtypeString -

Returns:

explanation if the redundancy would exist; null otherwise (meaning it's okay to add such a link)

showHierarchy

public String showHierarchy(String start)

Displays all hierarchy nodes in very clunky text

Parameters:

start - An initial string; if null, then use the hierarchy title.

Returns:

a human-readable text version of what's in the hierarchy

See Also:

TypeHierarchyNode.toString(boolean)

showHierarchy

public String showHierarchy()