BasicVertex

java.lang.Object
- org.botlibre.knowledge.BasicVertex

All Implemented Interfaces:

java.io.Serializable, Vertex
```
public class BasicVertex
extends java.lang.Object
implements Vertex, java.io.Serializable
```
Represents a piece of knowledge. Vertex is a very simple structure mainly comprised of its relationships, this gives the system a very simple and extendable structure. Basic implementation to allow subclasses to avoid defining some of the basic stuff. The data attribute allows for vertices that represents something tangible such as text, sound, image, number, etc. The data is also indexed within a network, so is the only guaranteed way to lookup an existing vertex.

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type Field and Description

static int LARGE

static int MEDIUM

static java.lang.String SELF

static int SMALL

Fields
Modifier and Type	Field and Description
`static int`	`LARGE`
`static int`	`MEDIUM`
`static java.lang.String`	`SELF`
`static int`	`SMALL`

Constructor Summary

Constructors
Constructor and Description

BasicVertex()

BasicVertex(java.lang.Object data)

BasicVertex(Vertex original)
Create the vertex as a clone of the original.

Constructors
Constructor and Description
`BasicVertex()`
`BasicVertex(java.lang.Object data)`
`BasicVertex(Vertex original)` Create the vertex as a clone of the original.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Relationship`	`addRelationship(Primitive type, Primitive target)` Add the relation of the relationship primitive type to the target primitive.
`Relationship`	`addRelationship(Primitive type, Primitive target, int index)` Add the relation of the relationship type to the target vertex.
`Relationship`	`addRelationship(Primitive type, Vertex target)` Add the relation of the relationship primitive type to the target vertex.
`Relationship`	`addRelationship(Primitive type, Vertex target, int index)` Add the relation of the relationship type to the target vertex.
`Relationship`	`addRelationship(Relationship relationship, boolean internal)` Add the relation ensuring uniqueness.
`Relationship`	`addRelationship(Relationship relationship, boolean internal, boolean init, float correctnessMultiplier)` Add the relation ensuring uniqueness.
`Relationship`	`addRelationship(Vertex type, Vertex target)` Add the relation of the relationship type to the target vertex.
`Relationship`	`addRelationship(Vertex type, Vertex target, int index)` Add the relation of the relationship type to the target vertex.
`Relationship`	`addRelationship(Vertex type, Vertex target, int index, boolean internal)` Add the relation of the relationship type to the target vertex.
`Relationship`	`addWeakRelationship(Primitive type, Primitive target, float correctnessMultiplier)` Add the relation of the relationship type to the target vertex.
`Relationship`	`addWeakRelationship(Primitive type, Vertex target, float correctnessMultiplier)` Add the relation of the relationship type to the target vertex.
`Relationship`	`addWeakRelationship(Vertex type, Vertex target, float correctnessMultiplier)` Add the relation of the relationship type to the target vertex.
`java.util.Iterator<Relationship>`	`allRelationships()` Provides an easier method of traversing all the relations of all types of a vertex.
`Relationship`	`appendRelationship(Primitive type, Vertex target)` Add the relation of the relationship type to the end of the target vertex relationships.
`Relationship`	`appendRelationship(Vertex type, Vertex target)` Add the relation of the relationship type to the end of the target vertex relationships.
`Vertex`	`applyALL(java.util.List<Relationship> arguments, java.util.Map<Vertex,Vertex> variables, Network network)` Apply the ALL operation.
`Vertex`	`applyAPPEND(java.util.List<Relationship> arguments, java.util.Map<Vertex,Vertex> variables, Network network)` Append the relationship in order.
`Vertex`	`applyASSOCIATE(Vertex operator, java.util.List<Relationship> arguments, java.util.Map<Vertex,Vertex> variables, Network network)` Apply the ASSOCIATE or DISSOCIATE operation.
`Vertex`	`applyCALL(java.util.List<Relationship> arguments, java.util.Map<Vertex,Vertex> variables, Network network)` Apply the call operation.
`Vertex`	`applyCONDITION(java.util.List<Relationship> arguments, java.util.Map<Vertex,Vertex> variables, Network network)` Apply the OR/AND condition.
`Vertex`	`applyCOUNT(java.util.List<Relationship> arguments, java.util.Map<Vertex,Vertex> variables, Network network)` Apply the COUNT operation.
`Vertex`	`applyDEBUG(java.util.List<Relationship> arguments, java.util.Map<Vertex,Vertex> variables, Network network)` Apply the DEBUG operation.
`Vertex`	`applyEQUAL(java.util.List<Relationship> arguments, java.util.Map<Vertex,Vertex> variables, Network network)` Apply the LESS operation.
`Vertex`	`applyEval(java.util.Map<Vertex,Vertex> variables, Network network)` Evaluates any eval functions in the equation or formula..
`Vertex`	`applyFOR(java.util.List<Relationship> arguments, java.util.Map<Vertex,Vertex> variables, Network network)` Apply the FOR operation.
`Vertex`	`applyFRAGMENT(java.util.List<Relationship> arguments, java.util.Map<Vertex,Vertex> variables, Network network, Primitive format)` Apply the FRAGMENT operation.
`Vertex`	`applyGET(java.util.List<Relationship> arguments, java.util.Map<Vertex,Vertex> variables, Network network)` Apply the GET operation.
`Vertex`	`applyGREATER(java.util.List<Relationship> arguments, java.util.Map<Vertex,Vertex> variables, Network network)` Apply the GREATER operation.
`Vertex`	`applyIF(java.util.List<Relationship> arguments, java.util.Map<Vertex,Vertex> variables, Network network)` Apply the IF operation.
`Vertex`	`applyINPUT(java.util.List<Relationship> arguments, java.util.Map<Vertex,Vertex> variables, Network network)` Apply the INPUT operation.
`Vertex`	`applyLEARN(java.util.List<Relationship> arguments, java.util.Map<Vertex,Vertex> variables, Network network)` Apply the LEARN operation.
`Vertex`	`applyLESS(java.util.List<Relationship> arguments, java.util.Map<Vertex,Vertex> variables, Network network)` Apply the LESS operation.
`Vertex`	`applyNEW(java.util.List<Relationship> arguments, java.util.Map<Vertex,Vertex> variables, Network network)` Apply the NEW operation.
`Vertex`	`applyQuotient(java.util.Map<Vertex,Vertex> variables, Network network)` Apply the quotient.
`Vertex`	`applyRANDOM(java.util.List<Relationship> arguments, java.util.Map<Vertex,Vertex> variables, Network network)` Apply the RANDOM operation.
`Vertex`	`applyRELATED(java.util.List<Relationship> arguments, java.util.Map<Vertex,Vertex> variables, Network network)` Apply the related operation.
`Vertex`	`applyRELATION(java.util.List<Relationship> arguments, java.util.Map<Vertex,Vertex> variables, Network network)` Apply the relation operation.
`Vertex`	`applySENTENCE(java.util.List<Relationship> arguments, java.util.Map<Vertex,Vertex> variables, Network network)` Apply the SENTENCE operation.
`Vertex`	`applySET(java.util.List<Relationship> arguments, java.util.Map<Vertex,Vertex> variables, Network network)` Apply the SET operation.
`Vertex`	`applySRAI(java.util.List<Relationship> arguments, java.util.Map<Vertex,Vertex> variables, Network network)` Apply the SRAI operation.
`Vertex`	`applySRAIX(java.util.List<Relationship> arguments, java.util.Map<Vertex,Vertex> variables, Network network)` Apply the SRAIX operation.
`Vertex`	`applyWHILE(java.util.List<Relationship> arguments, java.util.Map<Vertex,Vertex> variables, Network network)` Apply the WHILE operation.
`Vertex`	`applyWORD(java.util.List<Relationship> arguments, java.util.Map<Vertex,Vertex> variables, Network network)` Apply the WORD operation.
`void`	`associateAll(Primitive associate, Vertex target, Primitive type)` Associate each of the relationship target vertices with the target vertex by the type.
`void`	`associateAll(Vertex associate, Vertex target, Vertex type)` Associate each of the relationship target vertices with the target vertex by the type.
`Vertex`	`checkRelationRelationshipForAllWords(java.util.List<Relationship> arguments, java.util.Map<Vertex,Vertex> variables, Network network, Vertex left, Vertex right, Vertex relation, java.util.Collection<Relationship> words)` Check if any of the words have the relationship.
`Vertex`	`checkRelationTargetForAllWords(java.util.List<Relationship> arguments, java.util.Map<Vertex,Vertex> variables, Network network, Vertex left, Vertex right, Vertex relation, java.util.Collection<Relationship> words)` Check if any of the words have the relationship.
`boolean`	`collectMatches(Vertex vertex, java.util.Map<Vertex,java.util.Set<Vertex>> variables)` Compare if the two vertices match.
`int`	`compare(Vertex vertex)` Compare if the two vertices match.
`static float`	`computeCorrectness(Relationship relationship)`
`static java.lang.String`	`convertDataType(java.lang.Object data)`
`static java.lang.String`	`convertDataValue(java.lang.Object data)`
`Vertex`	`copy()` Create a copy of the vertex with all of the same relationships.
`void`	`decrementConsciousnessLevel()` Decrease the vertices's level of consciousness.
`void`	`decrementConsciousnessLevel(int amount)` Decrease the vertices's level of consciousness by the amount.
`java.lang.String`	`description()` Return a short toString, or header of the vertex.
`Vertex`	`detach()` Create a copy of the vertex with only the id.
`java.lang.String`	`displayString()` User friendly toString.
`boolean`	`equals(java.lang.Object object)` Two vertices are equal if they have the same data.
`boolean`	`equalsIgnoreCase(Vertex vertex)` Compare the vertices ignoring case.
`void`	`fixRelationships(Vertex type)` Fix the corrupted relationship index order.
`int`	`getAccessCount()` Return the number of times the vertex has been accessed.
`java.util.Date`	`getAccessDate()` Return the date the vertex was last accessed.
`java.util.Collection<Relationship>`	`getAllRelationships()` Return all of the relationships.
`Vertex`	`getAssoiate(Vertex type, Vertex associate, Vertex associateType)` Return the target vertex related by the type, that has the relationship to the previous, otherwise null if not found.
`Vertex`	`getAssoiate(Vertex type, Vertex associate, Vertex associateType, java.util.Collection<Relationship> associates2, Vertex associateType2, java.util.Collection<Relationship> associates3, Vertex associateType3, Vertex defaultAssociate)` Return the target vertex related by the type, that has the relationship to the previous, otherwise null if not found.
`Vertex`	`getAssoiate(Vertex type, Vertex associate, Vertex associateType, Vertex defaultAssociate)` Return the target vertex related by the type, that has the relationship to the previous, otherwise null if not found.
`Vertex`	`getAssoiate(Vertex type, Vertex associate, Vertex associateType, Vertex associate2, Vertex associateType2)` Return the target vertex related by the type, that has the relationship to the previous, otherwise null if not found.
`Vertex`	`getAssoiate(Vertex type, Vertex associate, Vertex associateType, Vertex associate2, Vertex associateType2, java.util.Collection<Relationship> associates3, Vertex associateType3, Vertex defaultAssociate)` Return the target vertex related by the type, that has the relationship to the previous, otherwise null if not found.
`Vertex`	`getAssoiate(Vertex type, Vertex associate, Vertex associateType, Vertex associate2, Vertex associateType2, Vertex associate3, Vertex associateType3)` Return the target vertex related by the type, that has the relationship to the previous, otherwise null if not found.
`Vertex`	`getAssoiate(Vertex type, Vertex associate, Vertex associateType, Vertex associate2, Vertex associateType2, Vertex associate3, Vertex associateType3, Vertex defaultAssociate)` Return the target vertex related by the type, that has the relationship to the previous, otherwise null if not found.
`int`	`getConsciousnessLevel()` Return the vertices's level of consciousness.
`java.util.Date`	`getCreationDate()` Return the date the vertex was created.
`java.lang.Object`	`getData()` Return the data value that the vertex represents.
`java.lang.String`	`getDataType()` Return the String name of the data's type.
`java.lang.String`	`getDataValue()` Return the String value of the data.
`long`	`getGroupId()` Return group id of script.
`java.lang.Boolean`	`getHasResponse()`
`java.lang.Long`	`getId()` Unique id for the vertex.
`java.lang.String`	`getName()` Return the name of the vertex.
`Network`	`getNetwork()` Return the network the vertex is derived from.
`Vertex`	`getRelationship(Primitive type)` Return any relationship target of the primitive type.
`Relationship`	`getRelationship(Primitive type, Primitive target)` Return the relationship of the type primitive to the target.
`Relationship`	`getRelationship(Primitive type, Vertex target)` Return the relationship of the type primitive to the target.
`Vertex`	`getRelationship(Vertex type)` Return any relationship target of the type.
`Relationship`	`getRelationship(Vertex type, Vertex target)` Return the relationship of the type primitive to the target.
`java.util.Map<Vertex,java.util.Map<Relationship,Relationship>>`	`getRelationships()` Return all relationships.
`java.util.Collection<Relationship>`	`getRelationships(Primitive type)` Return any relationship target of the primitive type.
`java.util.Collection<Relationship>`	`getRelationships(Vertex relationshipType)` Return all of the relationships of the type.
`int`	`getWordCount()` Return word count for a sentence.
`boolean`	`hasAnyAssociatedInverseRelationship(Primitive associate, Vertex target, Primitive type)` Return if any of the associates of the vertex have an inverse/negative relationship of the type to the target.
`boolean`	`hasAnyAssociatedInverseRelationship(Vertex associate, Vertex target, Vertex type)` Return if any of the associates of the vertex have an inverse/negative relationship of the type to the target.
`boolean`	`hasAnyRelationshipToTarget(Vertex target)` Return if the vertex has any relationship to any target.
`boolean`	`hasAnyRelationshipToTargetOfType(Vertex classification)` Return if the vertex has any relationship to any target that is an instantiation of the classification.
`boolean`	`hasAnyResponseRelationship()` PERF: Used to check response without accessing relationships.
`boolean`	`hasData()` Return if the vertex has a data value that it represents.
`int`	`hashCode()` Hash first on data then id for equality compatibility.
`boolean`	`hasInverseRelationship(Primitive type, Primitive target)` Return if the vertex has an inverse relationship of the type to the target.
`boolean`	`hasInverseRelationship(Primitive type, Vertex target)` Return if the vertex has an inverse relationship of the type to the target.
`boolean`	`hasInverseRelationship(Vertex type, Vertex target)` Return if the vertex has an inverse relationship of the type to the target.
`boolean`	`hasName()` Some vertices have no name, this provides an easy test method.
`boolean`	`hasOrInheritsInverseRelationship(Vertex type, Vertex target)` Return if the vertex has a relationship of the type to the target.
`boolean`	`hasOrInheritsInverseRelationship(Vertex type, Vertex target, java.util.Map<Vertex,Vertex> recursion)` Return if the vertex has a relationship of the type to the target.
`boolean`	`hasOrInheritsRelationship(Vertex type, Vertex target)` Return if the vertex has a relationship of the type to the target.
`boolean`	`hasOrInheritsRelationship(Vertex type, Vertex target, java.util.Map<Vertex,Vertex> recursion)` Return if the vertex has a relationship of the type to the target.
`boolean`	`hasRelationship(Primitive type)` Return if the vertex has a relationship of the type primitive.
`boolean`	`hasRelationship(Primitive type, Primitive target)` Return if the vertex has a relationship of the type primitive to the target primitive.
`boolean`	`hasRelationship(Primitive type, Vertex target)` Return if the vertex has a relationship of the type primitive to the target.
`boolean`	`hasRelationship(Vertex type)` Return if the vertex has any (non-inverse) relationship of the type.
`boolean`	`hasRelationship(Vertex type, Vertex target)` Return if the vertex has a relationship of the type to the target.
`boolean`	`hasRelationships()` Return if the relationships have been instantiated.
`void`	`incrementAccessCount()` Record that the vertex was accessed, update the access time and increment the access count.
`void`	`incrementConsciousnessLevel()` Increase the vertices's level of consciousness.
`void`	`incrementConsciousnessLevel(int amount)` Increase the vertices's level of consciousness by the amount.
`void`	`init()`
`boolean`	`instanceOf(Primitive type)` Return if the vertex is an instantiation of the primitive type.
`boolean`	`instanceOf(Vertex type)` Return if the vertex is an instantiation of the type.
`boolean`	`internalHasRelationship(Vertex type, Vertex target)` Return if the vertex has a relationship of the type to the target.
`void`	`internalRemoveAllRelationships()` Remove all relationships.
`void`	`internalRemoveRelationship(Primitive type, Primitive target)` Remove the relationship.
`void`	`internalRemoveRelationship(Relationship relationship)` Remove the relationship.
`void`	`internalRemoveRelationship(Vertex type, Vertex target)` Remove the relationship.
`void`	`internalRemoveRelationships(Primitive type)` Remove the relationships of the type.
`void`	`internalRemoveRelationships(Vertex type)` Remove the relationships of the type.
`void`	`inverseAssociateAll(Primitive associate, Vertex target, Primitive type)` Dissociate the source with each of the relationship targets by the type.
`void`	`inverseAssociateAll(Vertex associate, Vertex target, Vertex type)` Dissociate the source with each of the relationship targets by the type.
`boolean`	`is(java.lang.Object data)` Return if the vertex data is equal to the data.
`boolean`	`isArray()` Return if the vertex is an array.
`boolean`	`isDirty()` Return the the vertex has exceeded it relationships maximum.
`boolean`	`isEquation()` Return if the vertex is a equation.
`boolean`	`isList()` Return if the vertex is a list.
`boolean`	`isMeta()` Return if the vertex is for a meta relationship.
`boolean`	`isPinned()` Return if the vertex is pinned to memory, and will not be forgotten.
`boolean`	`isPrimitive()` Return if the vertex is a system primitive.
`boolean`	`isTemporary()` Return if the vertex is temporary, and not persistent.
`boolean`	`isVariable()` Return if the vertex is a variable.
`void`	`iterate(VertexIterator iterator)` Iterator over all related vertices to the vertex.
`Vertex`	`lastRelationship(Primitive type)` Return the fromLast last of the ordered relationship, or null.
`Vertex`	`lastRelationship(Primitive type, int fromLast)` Return the last of the ordered relationship, or null.
`Vertex`	`lastRelationship(Vertex type)` Return the last of the ordered relationship, or null.
`Vertex`	`lastRelationship(Vertex type, int fromLast)` Return the fromLast last of the ordered relationship, or null.
`java.lang.Boolean`	`matches(Vertex vertex, java.util.Map<Vertex,Vertex> variables)` Compare if the two vertices match.
`Vertex`	`mostConscious(Primitive type)` Return the target vertex related by the type with the high consciousness level.
`Vertex`	`mostConscious(Primitive type, float min)` Return the target vertex related by the type, with the high consciousness level greater than the value.
`Vertex`	`mostConscious(Vertex type)` Return the target vertex related by the type with the high consciousness level.
`Vertex`	`mostConscious(Vertex type, float min)` Return the target vertex related by the type, with the high consciousness level greater than the value.
`Vertex`	`mostConscious(Vertex type, float min, boolean inverse)` Return the target vertex related by the type, with the high consciousness level greater than the value.
`Vertex`	`mostConscious(Vertex type, Vertex classification)` Return the target vertex related by the type, with the high consciousness level.
`Relationship`	`mostConsciousRelationship(Primitive type)` Return the relationship related by the type, with the high consciousness level.
`Relationship`	`mostConsciousRelationship(Primitive type, float correctness)` Return the relationship related by the type, with the high consciousness level.
`Relationship`	`mostConsciousRelationship(Vertex type)` Return the relationship related by the type, with the high consciousness level.
`Vertex`	`mostConsciousTargetOfType(Vertex classification)` Return the most conscious target the vertex has any relationship to that is an instantiation of the classification.
`Vertex`	`mostConsciousWithAssoiate(Vertex type, Vertex associate, Vertex associateType)` Return the target vertex related by the type, that is also most correctly related to the associate vertex by the relationship.
`Vertex`	`mostConsciousWithAssoiates(Vertex type, Vertex associate, Vertex associateType, Vertex associate2, Vertex associateType2)` Return the target vertex related by the type, that is also most correctly related to the associate vertex by the relationship.
`Vertex`	`nextMostConscious(Primitive type, java.util.Set<Vertex> ignoring)` Return the target vertex related by the type, with the high consciousness level greater than the value.
`Vertex`	`nextMostConscious(Primitive type, Vertex ignoring, float min)` Return the target vertex related by the type, with the high consciousness level greater than the value.
`Vertex`	`nextMostConscious(Primitive type, Vertex ignoring, float min, boolean inverse)` Return the target vertex inversely/negatively related by the type, with the high consciousness level.
`Vertex`	`nextMostConscious(Vertex type, java.util.Set<Vertex> ignoring, float min, boolean inverse)` Return the target vertex inversely/negatively related by the type, with the high consciousness level.
`Vertex`	`nextMostConscious(Vertex type, Vertex ignoring, float min)` Return the target vertex related by the type, with the high consciousness level greater than the value.
`Vertex`	`nextMostConscious(Vertex type, Vertex ignoring, float min, boolean inverse)` Return the target vertex inversely/negatively related by the type, with the high consciousness level.
`Relationship`	`nextMostConsciousRelationship(Primitive type, Vertex ignoring)` Return the relationship related by the type, with the high consciousness level.
`Relationship`	`nextMostConsciousRelationship(Primitive type, Vertex ignoring, float min)` Return the target vertex related by the type, with the high consciousness level greater than the value.
`Relationship`	`nextMostConsciousRelationship(Vertex type, java.util.Set<Vertex> ignoring, float min, boolean inverse)` Return the target vertex inversely/negatively related by the type, with the high consciousness level.
`Relationship`	`nextMostConsciousRelationship(Vertex type, Vertex ignoring)` Return the relationship related by the type, with the high consciousness level.
`Relationship`	`nextMostConsciousRelationship(Vertex type, Vertex ignoring, float min, boolean inverse)` Return the target vertex inversely/negatively related by the type, with the high consciousness level.
`java.util.Iterator<Relationship>`	`orderedAllRelationships()` Provides an easier method of traversing all the relations of all types of a vertex.
`java.util.List<Vertex>`	`orderedRelations(Primitive primitive)` Return all of the relationships targets of the primitive type, sorted by index.
`java.util.List<Vertex>`	`orderedRelations(Vertex relationshipType)` Return all of the relationship targets of the type, sorted by index.
`java.util.List<Relationship>`	`orderedRelationships(Primitive primitive)` Return all of the relationships of the primitive type, sorted by index.
`java.util.List<Relationship>`	`orderedRelationships(Vertex relationshipType)` Return all of the relationships of the type, sorted by index.
`java.util.List<Relationship>`	`orderedRelationshipsByConsciousness(Primitive primitive)` Return all of the relationships of the type, sorted by consciousness level.
`java.util.List<Relationship>`	`orderedRelationshipsByConsciousness(Vertex relationshipType)` Return all of the relationships of the type, sorted by consciousness level.
`void`	`pinChildren()` Pin the targets of all relationships to memory.
`void`	`pinDescendants()` Pin the vertex and all of its descendants into memory.
`java.lang.String`	`printString()` Print the object's data such as a sentence or paragraph.
`java.lang.String`	`printString(int depth)` Print the object's data such as a sentence or paragraph.
`Relationship`	`removeRelationship(Primitive type, Primitive target)` Remove the relationship of the relation primitive type to the target vertex.
`Relationship`	`removeRelationship(Primitive type, Vertex target)` Remove the relationship of the relation primitive type to the target vertex.
`Relationship`	`removeRelationship(Relationship relationship)` Remove the relationship.
`Relationship`	`removeRelationship(Vertex type, Vertex target)` Remove the relationship of the relation type to the target vertex.
`void`	`replaceRelationship(Relationship oldRelationship, Vertex newTarget)` Replace the relationship with the new target at the same index.
`void`	`setAccessCount(int accessCount)` Set the number of times the vertex has been accessed.
`void`	`setAccessDate(java.util.Date accessDate)` Set the date the vertex was last accessed.
`void`	`setConsciousnessLevel(int consciousnessLevel)` Set the vertices's level of consciousness.
`void`	`setCreationDate(java.util.Date creationDate)` Set the date the vertex was created.
`void`	`setData(java.lang.Object data)` Set the data value that the vertex represents.
`void`	`setDataType(java.lang.String type)`
`void`	`setDataValue(java.lang.String value)`
`void`	`setGroupId(long groupId)` Set group id of script.
`void`	`setHasResponse(java.lang.Boolean hasResponse)`
`void`	`setId(java.lang.Long id)` Set the vertex id.
`void`	`setIsDirty(boolean isDirty)` Mark the vertex for forgetfullness.
`void`	`setIsTemporary(boolean isTemporary)` Set if the vertex is temporary, and not persistent.
`void`	`setName(java.lang.String name)` Set the name of the vertex.
`void`	`setNetwork(Network network)` Set the network the vertex is derived from.
`void`	`setOriginal(Vertex original)` Set the original long term vertex the short term vertex was derived from.
`void`	`setPinned(boolean pinned)` Set if the vertex should be pinned to memory.
`void`	`setRelationship(Primitive type, Primitive newValue)` Set the relationship, removing the old value.
`void`	`setRelationship(Primitive type, Vertex newValue)` Set the relationship, removing the old value.
`void`	`setRelationship(Vertex type, Vertex newValue)` Set the relationship, removing the old value.
`void`	`setRelationships(java.util.Map<Vertex,java.util.Map<Relationship,Relationship>> relationships)`
`void`	`setType(java.lang.String type)` Set the internal data-type of the vertex.
`void`	`setWordCount(int wordCount)` Set word count for a sentence.
`java.lang.String`	`toString()`
`int`	`totalRelationships()` Return the total number of all relationships.
`void`	`unpinChildren()` Unpin the targets of all relationships from memory.
`void`	`unpinDescendants()` Unpin the vertex and all of its descendants from memory.
`void`	`weakAssociateAll(Primitive associate, Vertex target, Primitive type, float correctnessMultiplier)` Associate each of the relationship target vertices with the target vertex by the type.
`void`	`weakAssociateAll(Vertex associate, Vertex target, Vertex type, float correctnessMultiplier)` Associate each of the relationship target vertices with the target vertex by the type.
`static void`	`writeHeader(Vertex vertex, java.io.PrintWriter writer)`

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - SELF
```
public static java.lang.String SELF
```
  - SMALL
```
public static int SMALL
```
  - MEDIUM
```
public static int MEDIUM
```
  - LARGE
```
public static int LARGE
```
- Constructor Detail
  - BasicVertex
```
public BasicVertex()
```
  - BasicVertex
```
public BasicVertex(java.lang.Object data)
```
  - BasicVertex
```
public BasicVertex(Vertex original)
```
    Create the vertex as a clone of the original.
- Method Detail
  - init
```
public void init()
```
    Specified by:
    
    init in interface Vertex
  - isTemporary
```
public boolean isTemporary()
```
    Description copied from interface: Vertex
    
    Return if the vertex is temporary, and not persistent.
    
    Specified by:
    
    isTemporary in interface Vertex
  - setIsTemporary
```
public void setIsTemporary(boolean isTemporary)
```
    Description copied from interface: Vertex
    
    Set if the vertex is temporary, and not persistent.
    
    Specified by:
    
    setIsTemporary in interface Vertex
  - getWordCount
```
public int getWordCount()
```
    Description copied from interface: Vertex
    
    Return word count for a sentence. Used to detect corrupt/forgotten sentences.
    
    Specified by:
    
    getWordCount in interface Vertex
  - setWordCount
```
public void setWordCount(int wordCount)
```
    Description copied from interface: Vertex
    
    Set word count for a sentence. Used to detect corrupt/forgotten sentences.
    
    Specified by:
    
    setWordCount in interface Vertex
  - getGroupId
```
public long getGroupId()
```
    Description copied from interface: Vertex
    
    Return group id of script. Used to optimize script loading.
    
    Specified by:
    
    getGroupId in interface Vertex
  - setGroupId
```
public void setGroupId(long groupId)
```
    Description copied from interface: Vertex
    
    Set group id of script. Used to optimize script loading.
    
    Specified by:
    
    setGroupId in interface Vertex
  - hasAnyResponseRelationship
```
public boolean hasAnyResponseRelationship()
```
    PERF: Used to check response without accessing relationships.
    
    Specified by:
    
    hasAnyResponseRelationship in interface Vertex
  - getHasResponse
```
public java.lang.Boolean getHasResponse()
```
  - setHasResponse
```
public void setHasResponse(java.lang.Boolean hasResponse)
```
  - isDirty
```
public boolean isDirty()
```
    Description copied from interface: Vertex
    
    Return the the vertex has exceeded it relationships maximum.
    
    Specified by:
    
    isDirty in interface Vertex
  - setIsDirty
```
public void setIsDirty(boolean isDirty)
```
    Description copied from interface: Vertex
    
    Mark the vertex for forgetfullness.
    
    Specified by:
    
    setIsDirty in interface Vertex
  - setOriginal
```
public void setOriginal(Vertex original)
```
    Set the original long term vertex the short term vertex was derived from.
    
    Specified by:
    
    setOriginal in interface Vertex
  - getNetwork
```
public Network getNetwork()
```
    Return the network the vertex is derived from.
    
    Specified by:
    
    getNetwork in interface Vertex
  - setNetwork
```
public void setNetwork(Network network)
```
    Set the network the vertex is derived from.
    
    Specified by:
    
    setNetwork in interface Vertex
  - getCreationDate
```
public java.util.Date getCreationDate()
```
    Return the date the vertex was created.
    
    Specified by:
    
    getCreationDate in interface Vertex
  - setCreationDate
```
public void setCreationDate(java.util.Date creationDate)
```
    Set the date the vertex was created.
    
    Specified by:
    
    setCreationDate in interface Vertex
  - getAccessDate
```
public java.util.Date getAccessDate()
```
    Return the date the vertex was last accessed.
    
    Specified by:
    
    getAccessDate in interface Vertex
  - setAccessDate
```
public void setAccessDate(java.util.Date accessDate)
```
    Set the date the vertex was last accessed. Access is considered moving from long term to short term memory.
    
    Specified by:
    
    setAccessDate in interface Vertex
  - getAccessCount
```
public int getAccessCount()
```
    Return the number of times the vertex has been accessed. Access is considered moving from long term to short term memory.
    
    Specified by:
    
    getAccessCount in interface Vertex
  - setAccessCount
```
public void setAccessCount(int accessCount)
```
    Set the number of times the vertex has been accessed.
    
    Specified by:
    
    setAccessCount in interface Vertex
  - incrementAccessCount
```
public void incrementAccessCount()
```
    Record that the vertex was accessed, update the access time and increment the access count.
    
    Specified by:
    
    incrementAccessCount in interface Vertex
  - incrementConsciousnessLevel
```
public void incrementConsciousnessLevel()
```
    Increase the vertices's level of consciousness.
    
    Specified by:
    
    incrementConsciousnessLevel in interface Vertex
  - decrementConsciousnessLevel
```
public void decrementConsciousnessLevel()
```
    Decrease the vertices's level of consciousness.
    
    Specified by:
    
    decrementConsciousnessLevel in interface Vertex
  - decrementConsciousnessLevel
```
public void decrementConsciousnessLevel(int amount)
```
    Decrease the vertices's level of consciousness by the amount.
    
    Specified by:
    
    decrementConsciousnessLevel in interface Vertex
  - incrementConsciousnessLevel
```
public void incrementConsciousnessLevel(int amount)
```
    Increase the vertices's level of consciousness by the amount.
    
    Specified by:
    
    incrementConsciousnessLevel in interface Vertex
  - getConsciousnessLevel
```
public int getConsciousnessLevel()
```
    Return the vertices's level of consciousness.
    
    Specified by:
    
    getConsciousnessLevel in interface Vertex
  - setConsciousnessLevel
```
public void setConsciousnessLevel(int consciousnessLevel)
```
    Set the vertices's level of consciousness.
    
    Specified by:
    
    setConsciousnessLevel in interface Vertex
  - addRelationship
```
public Relationship addRelationship(Primitive type,
                                    Primitive target)
```
    Add the relation of the relationship primitive type to the target primitive.
    
    Specified by:
    
    addRelationship in interface Vertex
  - addRelationship
```
public Relationship addRelationship(Primitive type,
                                    Vertex target)
```
    Add the relation of the relationship primitive type to the target vertex.
    
    Specified by:
    
    addRelationship in interface Vertex
  - addRelationship
```
public Relationship addRelationship(Vertex type,
                                    Vertex target)
```
    Add the relation of the relationship type to the target vertex. These are currently uni-directional. Only a single relation of a type can be defined to the same target, i.e. relationships to the same vertex are unique. unless the relationship is ordered, then they are only equal if the same index.
    
    Specified by:
    
    addRelationship in interface Vertex
  - appendRelationship
```
public Relationship appendRelationship(Vertex type,
                                       Vertex target)
```
    Add the relation of the relationship type to the end of the target vertex relationships.
    
    Specified by:
    
    appendRelationship in interface Vertex
  - appendRelationship
```
public Relationship appendRelationship(Primitive type,
                                       Vertex target)
```
    Add the relation of the relationship type to the end of the target vertex relationships.
    
    Specified by:
    
    appendRelationship in interface Vertex
  - addRelationship
```
public Relationship addRelationship(Primitive type,
                                    Vertex target,
                                    int index)
```
    Add the relation of the relationship type to the target vertex. These are currently uni-directional. Only a single relation of a type can be defined to the same target, i.e. relationships to the same vertex are unique. unless the relationship is ordered, then they are only equal if the same index.
    
    Specified by:
    
    addRelationship in interface Vertex
  - addRelationship
```
public Relationship addRelationship(Primitive type,
                                    Primitive target,
                                    int index)
```
    Add the relation of the relationship type to the target vertex. These are currently uni-directional. Only a single relation of a type can be defined to the same target, i.e. relationships to the same vertex are unique. unless the relationship is ordered, then they are only equal if the same index.
    
    Specified by:
    
    addRelationship in interface Vertex
  - addRelationship
```
public Relationship addRelationship(Vertex type,
                                    Vertex target,
                                    int index)
```
    Add the relation of the relationship type to the target vertex. These are currently uni-directional. Only a single relation of a type can be defined to the same target, i.e. relationships to the same vertex are unique. unless the relationship is ordered, then they are only equal if the same index.
    
    Specified by:
    
    addRelationship in interface Vertex
  - addRelationship
```
public Relationship addRelationship(Vertex type,
                                    Vertex target,
                                    int index,
                                    boolean internal)
```
    Add the relation of the relationship type to the target vertex. Only increment the correctness if not internal.
    
    Specified by:
    
    addRelationship in interface Vertex
  - addWeakRelationship
```
public Relationship addWeakRelationship(Primitive type,
                                        Primitive target,
                                        float correctnessMultiplier)
```
    Add the relation of the relationship type to the target vertex. The correctness decreases the correctness of the relation.
    
    Specified by:
    
    addWeakRelationship in interface Vertex
  - addWeakRelationship
```
public Relationship addWeakRelationship(Primitive type,
                                        Vertex target,
                                        float correctnessMultiplier)
```
    Add the relation of the relationship type to the target vertex. The correctness decreases the correctness of the relation.
    
    Specified by:
    
    addWeakRelationship in interface Vertex
  - addWeakRelationship
```
public Relationship addWeakRelationship(Vertex type,
                                        Vertex target,
                                        float correctnessMultiplier)
```
    Add the relation of the relationship type to the target vertex. The correctness decreases the correctness of the relation.
    
    Specified by:
    
    addWeakRelationship in interface Vertex
  - addRelationship
```
public Relationship addRelationship(Relationship relationship,
                                    boolean internal)
```
    Add the relation ensuring uniqueness.
    
    Specified by:
    
    addRelationship in interface Vertex
  - addRelationship
```
public Relationship addRelationship(Relationship relationship,
                                    boolean internal,
                                    boolean init,
                                    float correctnessMultiplier)
```
    Add the relation ensuring uniqueness.
  - equals
```
public boolean equals(java.lang.Object object)
```
    Two vertices are equal if they have the same data.
    
    Overrides:
    
    equals in class java.lang.Object
  - equalsIgnoreCase
```
public boolean equalsIgnoreCase(Vertex vertex)
```
    Compare the vertices ignoring case.
    
    Specified by:
    
    equalsIgnoreCase in interface Vertex
  - getId
```
public java.lang.Long getId()
```
    Description copied from interface: Vertex
    
    Unique id for the vertex. All vertices should define a unique identifier.
    
    Specified by:
    
    getId in interface Vertex
  - setId
```
public void setId(java.lang.Long id)
```
    Set the vertex id. The id can only be set when loading or creating a vertex.
    
    Specified by:
    
    setId in interface Vertex
  - hashCode
```
public int hashCode()
```
    Hash first on data then id for equality compatibility.
    
    Overrides:
    
    hashCode in class java.lang.Object
  - getData
```
public java.lang.Object getData()
```
    Return the data value that the vertex represents.
    
    Specified by:
    
    getData in interface Vertex
  - setData
```
public void setData(java.lang.Object data)
```
    Set the data value that the vertex represents.
    
    Specified by:
    
    setData in interface Vertex
  - hasData
```
public boolean hasData()
```
    Return if the vertex has a data value that it represents.
    
    Specified by:
    
    hasData in interface Vertex
  - hasRelationships
```
public boolean hasRelationships()
```
    Return if the relationships have been instantiated.
    
    Specified by:
    
    hasRelationships in interface Vertex
  - getRelationships
```
public java.util.Map<Vertex,java.util.Map<Relationship,Relationship>> getRelationships()
```
    Return all relationships. Relationships are stored as a map keyed on the relationship type, with ordered list of relationship targets.
    
    Specified by:
    
    getRelationships in interface Vertex
  - applyQuotient
```
public Vertex applyQuotient(java.util.Map<Vertex,Vertex> variables,
                            Network network)
```
    Apply the quotient. Apply the equation to the variable matches. This is basically a meta-language (4GL) based on Equation objects (vertices).
    
    Specified by:
    
    applyQuotient in interface Vertex
  - applyEval
```
public Vertex applyEval(java.util.Map<Vertex,Vertex> variables,
                        Network network)
```
    Evaluates any eval functions in the equation or formula.. This is used by learn.
    
    Specified by:
    
    applyEval in interface Vertex
  - applyWORD
```
public Vertex applyWORD(java.util.List<Relationship> arguments,
                        java.util.Map<Vertex,Vertex> variables,
                        Network network)
```
    Apply the WORD operation. WORD (:0, :1, :2, ...) Create a compound word from the arguments.
  - applySENTENCE
```
public Vertex applySENTENCE(java.util.List<Relationship> arguments,
                            java.util.Map<Vertex,Vertex> variables,
                            Network network)
```
    Apply the SENTENCE operation. SENTENCE (:0, :1, :2, ...) Create a sentence from printing the arguments.
  - applyFRAGMENT
```
public Vertex applyFRAGMENT(java.util.List<Relationship> arguments,
                            java.util.Map<Vertex,Vertex> variables,
                            Network network,
                            Primitive format)
```
    Apply the FRAGMENT operation. FRAGMENT (:0, :1, :2, ...) Create a fragment from printing the arguments.
  - applyALL
```
public Vertex applyALL(java.util.List<Relationship> arguments,
                       java.util.Map<Vertex,Vertex> variables,
                       Network network)
```
    Apply the ALL operation. ALL :0 FROM :1 Get all the relationship value of type ARGUMENT(0) from ARGUMENT(1) as a new list
  - applyASSOCIATE
```
public Vertex applyASSOCIATE(Vertex operator,
                             java.util.List<Relationship> arguments,
                             java.util.Map<Vertex,Vertex> variables,
                             Network network)
```
    Apply the ASSOCIATE or DISSOCIATE operation. ASSOCIATE :0 TO :1 BY :3 ASSOCIATE :0 TO :1 BY :3 WITH META :4 AS :5 DISSOCIATE :0 TO :1 BY :3 Associate the left with the right by the association, or remove association if negated. i.e. "Bob loves Jill" (associate Bob to Jill by #loves)
  - applyAPPEND
```
public Vertex applyAPPEND(java.util.List<Relationship> arguments,
                          java.util.Map<Vertex,Vertex> variables,
                          Network network)
```
    Append the relationship in order. APPEND :0 TO :1 OF :2 APPEND :0 TO :1 OF :2 WITH META :3 AS :4 Add the relationship value ARGUMENT(2) of type ARGUMENT(1) to ARGUMENT(0)
  - applyCONDITION
```
public Vertex applyCONDITION(java.util.List<Relationship> arguments,
                             java.util.Map<Vertex,Vertex> variables,
                             Network network)
```
    Apply the OR/AND condition. IF (:0, :1) OR (:2, :3) THEN :0 ELSE :1
  - applyIF
```
public Vertex applyIF(java.util.List<Relationship> arguments,
                      java.util.Map<Vertex,Vertex> variables,
                      Network network)
```
    Apply the IF operation. IF (:0, :1) OR (:2, :3) THEN :0 ELSE :1 If the first argument matches the second then apply the then, else apply the last then.
  - applySET
```
public Vertex applySET(java.util.List<Relationship> arguments,
                       java.util.Map<Vertex,Vertex> variables,
                       Network network)
```
    Apply the SET operation. SET :0 TO :1 ON :3 SET the left with the right by the association, replace any existing relationship. i.e. "Bob only loves Jill" (set #loves to Jill on Bob)
  - applyRANDOM
```
public Vertex applyRANDOM(java.util.List<Relationship> arguments,
                          java.util.Map<Vertex,Vertex> variables,
                          Network network)
```
    Apply the RANDOM operation. RANDOM (:0, :1, ...) Return a random argument.
  - applyDEBUG
```
public Vertex applyDEBUG(java.util.List<Relationship> arguments,
                         java.util.Map<Vertex,Vertex> variables,
                         Network network)
```
    Apply the DEBUG operation. DEBUG ("debug", :0, :2) Log the arguments to the log.
  - applyCOUNT
```
public Vertex applyCOUNT(java.util.List<Relationship> arguments,
                         java.util.Map<Vertex,Vertex> variables,
                         Network network)
```
    Apply the COUNT operation. COUNT :0 OF :1 Return if the number of elements.
  - applyGREATER
```
public Vertex applyGREATER(java.util.List<Relationship> arguments,
                           java.util.Map<Vertex,Vertex> variables,
                           Network network)
```
    Apply the GREATER operation. GREATER (:0, :2) Return if the left is bigger than the right.
  - applyLESS
```
public Vertex applyLESS(java.util.List<Relationship> arguments,
                        java.util.Map<Vertex,Vertex> variables,
                        Network network)
```
    Apply the LESS operation. LESS (:0, :2) Return if the left is smaller than the right.
  - applyEQUAL
```
public Vertex applyEQUAL(java.util.List<Relationship> arguments,
                         java.util.Map<Vertex,Vertex> variables,
                         Network network)
```
    Apply the LESS operation. RQUAL (:0, :2) Return if the left is equal to the right.
  - applyFOR
```
public Vertex applyFOR(java.util.List<Relationship> arguments,
                       java.util.Map<Vertex,Vertex> variables,
                       Network network)
```
    Apply the FOR operation. FOR EACH #word OF :sentence AS :word [AND EACH :3 OF :4 AS :5] DO (:0, :1, ...) Evaluate the DO for each relationship.
  - applyWHILE
```
public Vertex applyWHILE(java.util.List<Relationship> arguments,
                         java.util.Map<Vertex,Vertex> variables,
                         Network network)
```
    Apply the WHILE operation. WHILE (:0, :1) DO (:0, :1, ...) Evaluate the DO while true or matching.
  - applyINPUT
```
public Vertex applyINPUT(java.util.List<Relationship> arguments,
                         java.util.Map<Vertex,Vertex> variables,
                         Network network)
```
    Apply the INPUT operation. INPUT :0 PART :1 FOR :2 Get the last input from the conversation for the speaker.
  - applyGET
```
public Vertex applyGET(java.util.List<Relationship> arguments,
                       java.util.Map<Vertex,Vertex> variables,
                       Network network)
```
    Apply the GET operation. GET :0 FROM :1 Get the relationship value of type ARGUMENT(0) from ARGUMENT(1)
  - applyNEW
```
public Vertex applyNEW(java.util.List<Relationship> arguments,
                       java.util.Map<Vertex,Vertex> variables,
                       Network network)
```
    Apply the NEW operation. NEW (:0, :1, ...) i.e. new Number, Sequence Create a new vertex as an instance of the argument types.
  - applyCALL
```
public Vertex applyCALL(java.util.List<Relationship> arguments,
                        java.util.Map<Vertex,Vertex> variables,
                        Network network)
                 throws java.lang.Exception
```
    Apply the call operation. CALL :0 ON :1 [WITH (:2, :3, ...)] i.e. CALL #push ON #Context WITH :thing1 Call out to the named sense, arguments and return value must be vertices.
    
    Throws:
    
    java.lang.Exception
  - applyLEARN
```
public Vertex applyLEARN(java.util.List<Relationship> arguments,
                         java.util.Map<Vertex,Vertex> variables,
                         Network network)
                  throws java.lang.Exception
```
    Apply the LEARN operation. LEARN :0 THAT :that TOPIC :topic TEMPLATE :1 Evaluate and add the new response.
    
    Throws:
    
    java.lang.Exception
  - applySRAI
```
public Vertex applySRAI(java.util.List<Relationship> arguments,
                        java.util.Map<Vertex,Vertex> variables,
                        Network network)
                 throws java.lang.Exception
```
    Apply the SRAI operation. SRAI "Hello" Return the response to processing the input.
    
    Throws:
    
    java.lang.Exception
  - applySRAIX
```
public Vertex applySRAIX(java.util.List<Relationship> arguments,
                         java.util.Map<Vertex,Vertex> variables,
                         Network network)
                  throws java.lang.Exception
```
    Apply the SRAIX operation. SRAIX "what is love" BOT "Brain Bot" LIMIT 5 SERVICE #botlibre APIKEY 12345 BOTID 12345 HINT "google" DEFAULT "Brain Bot is offline" Execute the remote service call, and return the response.
    
    Throws:
    
    java.lang.Exception
  - checkRelationTargetForAllWords
```
public Vertex checkRelationTargetForAllWords(java.util.List<Relationship> arguments,
                                             java.util.Map<Vertex,Vertex> variables,
                                             Network network,
                                             Vertex left,
                                             Vertex right,
                                             Vertex relation,
                                             java.util.Collection<Relationship> words)
```
    Check if any of the words have the relationship.
  - checkRelationRelationshipForAllWords
```
public Vertex checkRelationRelationshipForAllWords(java.util.List<Relationship> arguments,
                                                   java.util.Map<Vertex,Vertex> variables,
                                                   Network network,
                                                   Vertex left,
                                                   Vertex right,
                                                   Vertex relation,
                                                   java.util.Collection<Relationship> words)
```
    Check if any of the words have the relationship.
  - applyRELATION
```
public Vertex applyRELATION(java.util.List<Relationship> arguments,
                            java.util.Map<Vertex,Vertex> variables,
                            Network network)
```
    Apply the relation operation. IS :0 RELATED TO :1 [BY :2] Return if the left has the relation to the right i.e. "Bob love's Jill" (does Bob have #loves relationship to Jill) or also "Bob love's?" (what does Bob have a #loves relationship to?) or "Bob feels how to Jill?" (what is Bob's relationship to Jill?)
  - applyRELATED
```
public Vertex applyRELATED(java.util.List<Relationship> arguments,
                           java.util.Map<Vertex,Vertex> variables,
                           Network network)
```
    Apply the related operation. RELATED TO :0 [BY :1] Return what has a relationship to :0 by the relationships :1, or what has any relationship to :0.
  - matches
```
public java.lang.Boolean matches(Vertex vertex,
                                 java.util.Map<Vertex,Vertex> variables)
```
    Compare if the two vertices match. Used for rule processing.
    
    Specified by:
    
    matches in interface Vertex
  - collectMatches
```
public boolean collectMatches(Vertex vertex,
                              java.util.Map<Vertex,java.util.Set<Vertex>> variables)
```
    Compare if the two vertices match. Depth allows breadth first search for variables. Used for rule processing.
    
    Specified by:
    
    collectMatches in interface Vertex
  - compare
```
public int compare(Vertex vertex)
```
    Compare if the two vertices match. 0 means perfect match. -n means n relationships that do not match. +n means n relationships that do match.
  - fixRelationships
```
public void fixRelationships(Vertex type)
```
    Fix the corrupted relationship index order. The order can get corrupted when relationships are forgotten.
    
    Specified by:
    
    fixRelationships in interface Vertex
  - totalRelationships
```
public int totalRelationships()
```
    Return the total number of all relationships.
    
    Specified by:
    
    totalRelationships in interface Vertex
  - getRelationship
```
public Vertex getRelationship(Primitive type)
```
    Return any relationship target of the primitive type.
    
    Specified by:
    
    getRelationship in interface Vertex
  - getRelationship
```
public Vertex getRelationship(Vertex type)
```
    Return any relationship target of the type.
    
    Specified by:
    
    getRelationship in interface Vertex
  - getRelationships
```
public java.util.Collection<Relationship> getRelationships(Primitive type)
```
    Return any relationship target of the primitive type.
    
    Specified by:
    
    getRelationships in interface Vertex
  - getRelationships
```
public java.util.Collection<Relationship> getRelationships(Vertex relationshipType)
```
    Return all of the relationships of the type.
    
    Specified by:
    
    getRelationships in interface Vertex
  - lastRelationship
```
public Vertex lastRelationship(Vertex type)
```
    Return the last of the ordered relationship, or null.
    
    Specified by:
    
    lastRelationship in interface Vertex
  - lastRelationship
```
public Vertex lastRelationship(Vertex type,
                               int fromLast)
```
    Return the fromLast last of the ordered relationship, or null. i.e. 2nd last, or 3rd last, etc.
    
    Specified by:
    
    lastRelationship in interface Vertex
  - lastRelationship
```
public Vertex lastRelationship(Primitive type)
```
    Return the fromLast last of the ordered relationship, or null.
    
    Specified by:
    
    lastRelationship in interface Vertex
  - lastRelationship
```
public Vertex lastRelationship(Primitive type,
                               int fromLast)
```
    Return the last of the ordered relationship, or null.
    
    Specified by:
    
    lastRelationship in interface Vertex
  - orderedRelationships
```
public java.util.List<Relationship> orderedRelationships(Primitive primitive)
```
    Return all of the relationships of the primitive type, sorted by index.
    
    Specified by:
    
    orderedRelationships in interface Vertex
  - orderedRelationships
```
public java.util.List<Relationship> orderedRelationships(Vertex relationshipType)
```
    Return all of the relationships of the type, sorted by index.
    
    Specified by:
    
    orderedRelationships in interface Vertex
  - orderedRelationshipsByConsciousness
```
public java.util.List<Relationship> orderedRelationshipsByConsciousness(Primitive primitive)
```
    Return all of the relationships of the type, sorted by consciousness level.
    
    Specified by:
    
    orderedRelationshipsByConsciousness in interface Vertex
  - orderedRelationshipsByConsciousness
```
public java.util.List<Relationship> orderedRelationshipsByConsciousness(Vertex relationshipType)
```
    Return all of the relationships of the type, sorted by consciousness level.
    
    Specified by:
    
    orderedRelationshipsByConsciousness in interface Vertex
  - orderedRelations
```
public java.util.List<Vertex> orderedRelations(Primitive primitive)
```
    Return all of the relationships targets of the primitive type, sorted by index.
    
    Specified by:
    
    orderedRelations in interface Vertex
  - orderedRelations
```
public java.util.List<Vertex> orderedRelations(Vertex relationshipType)
```
    Return all of the relationship targets of the type, sorted by index.
    
    Specified by:
    
    orderedRelations in interface Vertex
  - mostConscious
```
public Vertex mostConscious(Vertex type,
                            float min)
```
    Return the target vertex related by the type, with the high consciousness level greater than the value.
    
    Specified by:
    
    mostConscious in interface Vertex
  - mostConsciousRelationship
```
public Relationship mostConsciousRelationship(Vertex type)
```
    Return the relationship related by the type, with the high consciousness level.
    
    Specified by:
    
    mostConsciousRelationship in interface Vertex
  - nextMostConsciousRelationship
```
public Relationship nextMostConsciousRelationship(Vertex type,
                                                  Vertex ignoring)
```
    Return the relationship related by the type, with the high consciousness level.
    
    Specified by:
    
    nextMostConsciousRelationship in interface Vertex
  - mostConsciousRelationship
```
public Relationship mostConsciousRelationship(Primitive type)
```
    Return the relationship related by the type, with the high consciousness level.
    
    Specified by:
    
    mostConsciousRelationship in interface Vertex
  - mostConsciousRelationship
```
public Relationship mostConsciousRelationship(Primitive type,
                                              float correctness)
```
    Return the relationship related by the type, with the high consciousness level.
    
    Specified by:
    
    mostConsciousRelationship in interface Vertex
  - nextMostConsciousRelationship
```
public Relationship nextMostConsciousRelationship(Primitive type,
                                                  Vertex ignoring)
```
    Return the relationship related by the type, with the high consciousness level.
    
    Specified by:
    
    nextMostConsciousRelationship in interface Vertex
  - mostConscious
```
public Vertex mostConscious(Primitive type,
                            float min)
```
    Return the target vertex related by the type, with the high consciousness level greater than the value.
    
    Specified by:
    
    mostConscious in interface Vertex
  - mostConscious
```
public Vertex mostConscious(Vertex type,
                            float min,
                            boolean inverse)
```
    Return the target vertex related by the type, with the high consciousness level greater than the value.
    
    Specified by:
    
    mostConscious in interface Vertex
  - nextMostConscious
```
public Vertex nextMostConscious(Primitive type,
                                java.util.Set<Vertex> ignoring)
```
    Return the target vertex related by the type, with the high consciousness level greater than the value.
    
    Specified by:
    
    nextMostConscious in interface Vertex
  - nextMostConscious
```
public Vertex nextMostConscious(Primitive type,
                                Vertex ignoring,
                                float min)
```
    Return the target vertex related by the type, with the high consciousness level greater than the value.
    
    Specified by:
    
    nextMostConscious in interface Vertex
  - nextMostConsciousRelationship
```
public Relationship nextMostConsciousRelationship(Primitive type,
                                                  Vertex ignoring,
                                                  float min)
```
    Return the target vertex related by the type, with the high consciousness level greater than the value.
    
    Specified by:
    
    nextMostConsciousRelationship in interface Vertex
  - nextMostConscious
```
public Vertex nextMostConscious(Vertex type,
                                Vertex ignoring,
                                float min)
```
    Return the target vertex related by the type, with the high consciousness level greater than the value.
    
    Specified by:
    
    nextMostConscious in interface Vertex
  - mostConscious
```
public Vertex mostConscious(Primitive type)
```
    Return the target vertex related by the type with the high consciousness level.
    
    Specified by:
    
    mostConscious in interface Vertex
  - mostConscious
```
public Vertex mostConscious(Vertex type)
```
    Return the target vertex related by the type with the high consciousness level.
    
    Specified by:
    
    mostConscious in interface Vertex
  - nextMostConscious
```
public Vertex nextMostConscious(Primitive type,
                                Vertex ignoring,
                                float min,
                                boolean inverse)
```
    Return the target vertex inversely/negatively related by the type, with the high consciousness level. The level is multiplied by the relationship correctness.
  - nextMostConscious
```
public Vertex nextMostConscious(Vertex type,
                                Vertex ignoring,
                                float min,
                                boolean inverse)
```
    Return the target vertex inversely/negatively related by the type, with the high consciousness level. The level is multiplied by the relationship correctness.
  - nextMostConscious
```
public Vertex nextMostConscious(Vertex type,
                                java.util.Set<Vertex> ignoring,
                                float min,
                                boolean inverse)
```
    Return the target vertex inversely/negatively related by the type, with the high consciousness level. The level is multiplied by the relationship correctness.
    
    Specified by:
    
    nextMostConscious in interface Vertex
  - computeCorrectness
```
public static float computeCorrectness(Relationship relationship)
```
  - nextMostConsciousRelationship
```
public Relationship nextMostConsciousRelationship(Vertex type,
                                                  Vertex ignoring,
                                                  float min,
                                                  boolean inverse)
```
    Return the target vertex inversely/negatively related by the type, with the high consciousness level. The level is multiplied by the relationship correctness.
  - nextMostConsciousRelationship
```
public Relationship nextMostConsciousRelationship(Vertex type,
                                                  java.util.Set<Vertex> ignoring,
                                                  float min,
                                                  boolean inverse)
```
    Return the target vertex inversely/negatively related by the type, with the high consciousness level. The level is multiplied by the relationship correctness.
    
    Specified by:
    
    nextMostConsciousRelationship in interface Vertex
  - mostConsciousTargetOfType
```
public Vertex mostConsciousTargetOfType(Vertex classification)
```
    Return the most conscious target the vertex has any relationship to that is an instantiation of the classification.
    
    Specified by:
    
    mostConsciousTargetOfType in interface Vertex
  - mostConscious
```
public Vertex mostConscious(Vertex type,
                            Vertex classification)
```
    Return the target vertex related by the type, with the high consciousness level.
    
    Specified by:
    
    mostConscious in interface Vertex
  - getAssoiate
```
public Vertex getAssoiate(Vertex type,
                          Vertex associate,
                          Vertex associateType)
```
    Return the target vertex related by the type, that has the relationship to the previous, otherwise null if not found.
    
    Specified by:
    
    getAssoiate in interface Vertex
  - getAssoiate
```
public Vertex getAssoiate(Vertex type,
                          Vertex associate,
                          Vertex associateType,
                          Vertex defaultAssociate)
```
    Return the target vertex related by the type, that has the relationship to the previous, otherwise null if not found.
    
    Specified by:
    
    getAssoiate in interface Vertex
  - getAssoiate
```
public Vertex getAssoiate(Vertex type,
                          Vertex associate,
                          Vertex associateType,
                          Vertex associate2,
                          Vertex associateType2)
```
    Return the target vertex related by the type, that has the relationship to the previous, otherwise null if not found.
    
    Specified by:
    
    getAssoiate in interface Vertex
  - getAssoiate
```
public Vertex getAssoiate(Vertex type,
                          Vertex associate,
                          Vertex associateType,
                          Vertex associate2,
                          Vertex associateType2,
                          Vertex associate3,
                          Vertex associateType3)
```
    Return the target vertex related by the type, that has the relationship to the previous, otherwise null if not found.
    
    Specified by:
    
    getAssoiate in interface Vertex
  - getAssoiate
```
public Vertex getAssoiate(Vertex type,
                          Vertex associate,
                          Vertex associateType,
                          Vertex associate2,
                          Vertex associateType2,
                          Vertex associate3,
                          Vertex associateType3,
                          Vertex defaultAssociate)
```
    Return the target vertex related by the type, that has the relationship to the previous, otherwise null if not found. Ideally the target also has associate2.
  - getAssoiate
```
public Vertex getAssoiate(Vertex type,
                          Vertex associate,
                          Vertex associateType,
                          Vertex associate2,
                          Vertex associateType2,
                          java.util.Collection<Relationship> associates3,
                          Vertex associateType3,
                          Vertex defaultAssociate)
```
    Return the target vertex related by the type, that has the relationship to the previous, otherwise null if not found. Ideally the target also has associate2.
    
    Specified by:
    
    getAssoiate in interface Vertex
  - getAssoiate
```
public Vertex getAssoiate(Vertex type,
                          Vertex associate,
                          Vertex associateType,
                          java.util.Collection<Relationship> associates2,
                          Vertex associateType2,
                          java.util.Collection<Relationship> associates3,
                          Vertex associateType3,
                          Vertex defaultAssociate)
```
    Return the target vertex related by the type, that has the relationship to the previous, otherwise null if not found. Ideally the target also has associate2.
    
    Specified by:
    
    getAssoiate in interface Vertex
  - mostConsciousWithAssoiate
```
public Vertex mostConsciousWithAssoiate(Vertex type,
                                        Vertex associate,
                                        Vertex associateType)
```
    Return the target vertex related by the type, that is also most correctly related to the associate vertex by the relationship. If no related vertices are related to the associate, then return the most conscious.
    
    Specified by:
    
    mostConsciousWithAssoiate in interface Vertex
  - mostConsciousWithAssoiates
```
public Vertex mostConsciousWithAssoiates(Vertex type,
                                         Vertex associate,
                                         Vertex associateType,
                                         Vertex associate2,
                                         Vertex associateType2)
```
    Return the target vertex related by the type, that is also most correctly related to the associate vertex by the relationship. If no related vertices are related to the associate, then return the most conscious.
    
    Specified by:
    
    mostConsciousWithAssoiates in interface Vertex
  - weakAssociateAll
```
public void weakAssociateAll(Primitive associate,
                             Vertex target,
                             Primitive type,
                             float correctnessMultiplier)
```
    Associate each of the relationship target vertices with the target vertex by the type.
    
    Specified by:
    
    weakAssociateAll in interface Vertex
  - weakAssociateAll
```
public void weakAssociateAll(Vertex associate,
                             Vertex target,
                             Vertex type,
                             float correctnessMultiplier)
```
    Associate each of the relationship target vertices with the target vertex by the type.
    
    Specified by:
    
    weakAssociateAll in interface Vertex
  - associateAll
```
public void associateAll(Primitive associate,
                         Vertex target,
                         Primitive type)
```
    Associate each of the relationship target vertices with the target vertex by the type.
    
    Specified by:
    
    associateAll in interface Vertex
  - associateAll
```
public void associateAll(Vertex associate,
                         Vertex target,
                         Vertex type)
```
    Associate each of the relationship target vertices with the target vertex by the type.
    
    Specified by:
    
    associateAll in interface Vertex
  - inverseAssociateAll
```
public void inverseAssociateAll(Primitive associate,
                                Vertex target,
                                Primitive type)
```
    Dissociate the source with each of the relationship targets by the type.
    
    Specified by:
    
    inverseAssociateAll in interface Vertex
  - inverseAssociateAll
```
public void inverseAssociateAll(Vertex associate,
                                Vertex target,
                                Vertex type)
```
    Dissociate the source with each of the relationship targets by the type.
    
    Specified by:
    
    inverseAssociateAll in interface Vertex
  - hasAnyAssociatedInverseRelationship
```
public boolean hasAnyAssociatedInverseRelationship(Primitive associate,
                                                   Vertex target,
                                                   Primitive type)
```
    Return if any of the associates of the vertex have an inverse/negative relationship of the type to the target.
    
    Specified by:
    
    hasAnyAssociatedInverseRelationship in interface Vertex
  - hasAnyAssociatedInverseRelationship
```
public boolean hasAnyAssociatedInverseRelationship(Vertex associate,
                                                   Vertex target,
                                                   Vertex type)
```
    Return if any of the associates of the vertex have an inverse/negative relationship of the type to the target.
    
    Specified by:
    
    hasAnyAssociatedInverseRelationship in interface Vertex
  - removeRelationship
```
public Relationship removeRelationship(Vertex type,
                                       Vertex target)
```
    Remove the relationship of the relation type to the target vertex. This records the relationships with a negative correctness, or subtracts from the current correctness.
    
    Specified by:
    
    removeRelationship in interface Vertex
  - removeRelationship
```
public Relationship removeRelationship(Primitive type,
                                       Vertex target)
```
    Remove the relationship of the relation primitive type to the target vertex. This records the relationships with a negative correctness, or subtracts from the current correctness.
    
    Specified by:
    
    removeRelationship in interface Vertex
  - removeRelationship
```
public Relationship removeRelationship(Primitive type,
                                       Primitive target)
```
    Remove the relationship of the relation primitive type to the target vertex. This records the relationships with a negative correctness, or subtracts from the current correctness.
    
    Specified by:
    
    removeRelationship in interface Vertex
  - removeRelationship
```
public Relationship removeRelationship(Relationship relationship)
```
    Remove the relationship. This records the relationships with a negative correctness, or subtracts from the current correctness.
  - internalRemoveRelationship
```
public void internalRemoveRelationship(Relationship relationship)
```
    Remove the relationship.
    
    Specified by:
    
    internalRemoveRelationship in interface Vertex
  - internalRemoveRelationship
```
public void internalRemoveRelationship(Primitive type,
                                       Primitive target)
```
    Remove the relationship.
    
    Specified by:
    
    internalRemoveRelationship in interface Vertex
  - internalRemoveRelationship
```
public void internalRemoveRelationship(Vertex type,
                                       Vertex target)
```
    Remove the relationship.
    
    Specified by:
    
    internalRemoveRelationship in interface Vertex
  - internalRemoveRelationships
```
public void internalRemoveRelationships(Primitive type)
```
    Remove the relationships of the type.
    
    Specified by:
    
    internalRemoveRelationships in interface Vertex
  - internalRemoveRelationships
```
public void internalRemoveRelationships(Vertex type)
```
    Remove the relationships of the type.
    
    Specified by:
    
    internalRemoveRelationships in interface Vertex
  - pinChildren
```
public void pinChildren()
```
    Pin the targets of all relationships to memory.
    
    Specified by:
    
    pinChildren in interface Vertex
  - unpinChildren
```
public void unpinChildren()
```
    Unpin the targets of all relationships from memory.
    
    Specified by:
    
    unpinChildren in interface Vertex
  - internalRemoveAllRelationships
```
public void internalRemoveAllRelationships()
```
    Remove all relationships.
    
    Specified by:
    
    internalRemoveAllRelationships in interface Vertex
  - replaceRelationship
```
public void replaceRelationship(Relationship oldRelationship,
                                Vertex newTarget)
```
    Replace the relationship with the new target at the same index.
    
    Specified by:
    
    replaceRelationship in interface Vertex
  - setRelationship
```
public void setRelationship(Primitive type,
                            Vertex newValue)
```
    Set the relationship, removing the old value.
    
    Specified by:
    
    setRelationship in interface Vertex
  - setRelationship
```
public void setRelationship(Primitive type,
                            Primitive newValue)
```
    Set the relationship, removing the old value.
    
    Specified by:
    
    setRelationship in interface Vertex
  - setRelationship
```
public void setRelationship(Vertex type,
                            Vertex newValue)
```
    Set the relationship, removing the old value.
    
    Specified by:
    
    setRelationship in interface Vertex
  - setRelationships
```
public void setRelationships(java.util.Map<Vertex,java.util.Map<Relationship,Relationship>> relationships)
```
  - allRelationships
```
public java.util.Iterator<Relationship> allRelationships()
```
    Provides an easier method of traversing all the relations of all types of a vertex.
    
    Specified by:
    
    allRelationships in interface Vertex
  - iterate
```
public void iterate(VertexIterator iterator)
```
    Iterator over all related vertices to the vertex.
    
    Specified by:
    
    iterate in interface Vertex
  - pinDescendants
```
public void pinDescendants()
```
    Pin the vertex and all of its descendants into memory. This can be used for important data such as language rules. ** This does not work, and will cause a stack overflow **
    
    Specified by:
    
    pinDescendants in interface Vertex
  - unpinDescendants
```
public void unpinDescendants()
```
    Unpin the vertex and all of its descendants from memory. This can be used to release removed language rules.
    
    Specified by:
    
    unpinDescendants in interface Vertex
  - orderedAllRelationships
```
public java.util.Iterator<Relationship> orderedAllRelationships()
```
    Provides an easier method of traversing all the relations of all types of a vertex.
    
    Specified by:
    
    orderedAllRelationships in interface Vertex
  - displayString
```
public java.lang.String displayString()
```
    Description copied from interface: Vertex
    
    User friendly toString.
    
    Specified by:
    
    displayString in interface Vertex
  - writeHeader
```
public static void writeHeader(Vertex vertex,
                               java.io.PrintWriter writer)
```
  - isPrimitive
```
public boolean isPrimitive()
```
    Return if the vertex is a system primitive.
    
    Specified by:
    
    isPrimitive in interface Vertex
  - isMeta
```
public boolean isMeta()
```
    Return if the vertex is for a meta relationship.
  - isVariable
```
public boolean isVariable()
```
    Return if the vertex is a variable.
    
    Specified by:
    
    isVariable in interface Vertex
  - isList
```
public boolean isList()
```
    Return if the vertex is a list.
  - isArray
```
public boolean isArray()
```
    Return if the vertex is an array.
    
    Specified by:
    
    isArray in interface Vertex
  - isEquation
```
public boolean isEquation()
```
    Return if the vertex is a equation.
    
    Specified by:
    
    isEquation in interface Vertex
  - is
```
public boolean is(java.lang.Object data)
```
    Return if the vertex data is equal to the data.
    
    Specified by:
    
    is in interface Vertex
  - instanceOf
```
public boolean instanceOf(Primitive type)
```
    Return if the vertex is an instantiation of the primitive type.
    
    Specified by:
    
    instanceOf in interface Vertex
  - instanceOf
```
public boolean instanceOf(Vertex type)
```
    Return if the vertex is an instantiation of the type.
    
    Specified by:
    
    instanceOf in interface Vertex
  - hasRelationship
```
public boolean hasRelationship(Primitive type)
```
    Return if the vertex has a relationship of the type primitive.
    
    Specified by:
    
    hasRelationship in interface Vertex
  - hasRelationship
```
public boolean hasRelationship(Primitive type,
                               Primitive target)
```
    Return if the vertex has a relationship of the type primitive to the target primitive.
    
    Specified by:
    
    hasRelationship in interface Vertex
  - hasRelationship
```
public boolean hasRelationship(Primitive type,
                               Vertex target)
```
    Return if the vertex has a relationship of the type primitive to the target.
    
    Specified by:
    
    hasRelationship in interface Vertex
  - getRelationship
```
public Relationship getRelationship(Primitive type,
                                    Vertex target)
```
    Return the relationship of the type primitive to the target.
    
    Specified by:
    
    getRelationship in interface Vertex
  - getRelationship
```
public Relationship getRelationship(Primitive type,
                                    Primitive target)
```
    Return the relationship of the type primitive to the target.
    
    Specified by:
    
    getRelationship in interface Vertex
  - hasRelationship
```
public boolean hasRelationship(Vertex type,
                               Vertex target)
```
    Return if the vertex has a relationship of the type to the target.
    
    Specified by:
    
    hasRelationship in interface Vertex
  - hasOrInheritsRelationship
```
public boolean hasOrInheritsRelationship(Vertex type,
                                         Vertex target)
```
    Return if the vertex has a relationship of the type to the target.
    
    Specified by:
    
    hasOrInheritsRelationship in interface Vertex
  - hasOrInheritsRelationship
```
public boolean hasOrInheritsRelationship(Vertex type,
                                         Vertex target,
                                         java.util.Map<Vertex,Vertex> recursion)
```
    Return if the vertex has a relationship of the type to the target.
    
    Specified by:
    
    hasOrInheritsRelationship in interface Vertex
  - getRelationship
```
public Relationship getRelationship(Vertex type,
                                    Vertex target)
```
    Return the relationship of the type primitive to the target.
    
    Specified by:
    
    getRelationship in interface Vertex
  - internalHasRelationship
```
public boolean internalHasRelationship(Vertex type,
                                       Vertex target)
```
    Return if the vertex has a relationship of the type to the target. Include inverses.
    
    Specified by:
    
    internalHasRelationship in interface Vertex
  - hasRelationship
```
public boolean hasRelationship(Vertex type)
```
    Return if the vertex has any (non-inverse) relationship of the type.
    
    Specified by:
    
    hasRelationship in interface Vertex
  - hasAnyRelationshipToTarget
```
public boolean hasAnyRelationshipToTarget(Vertex target)
```
    Return if the vertex has any relationship to any target.
    
    Specified by:
    
    hasAnyRelationshipToTarget in interface Vertex
  - hasAnyRelationshipToTargetOfType
```
public boolean hasAnyRelationshipToTargetOfType(Vertex classification)
```
    Return if the vertex has any relationship to any target that is an instantiation of the classification.
    
    Specified by:
    
    hasAnyRelationshipToTargetOfType in interface Vertex
  - hasInverseRelationship
```
public boolean hasInverseRelationship(Primitive type,
                                      Primitive target)
```
    Return if the vertex has an inverse relationship of the type to the target.
    
    Specified by:
    
    hasInverseRelationship in interface Vertex
  - hasInverseRelationship
```
public boolean hasInverseRelationship(Primitive type,
                                      Vertex target)
```
    Return if the vertex has an inverse relationship of the type to the target.
    
    Specified by:
    
    hasInverseRelationship in interface Vertex
  - hasInverseRelationship
```
public boolean hasInverseRelationship(Vertex type,
                                      Vertex target)
```
    Return if the vertex has an inverse relationship of the type to the target.
    
    Specified by:
    
    hasInverseRelationship in interface Vertex
  - hasOrInheritsInverseRelationship
```
public boolean hasOrInheritsInverseRelationship(Vertex type,
                                                Vertex target)
```
    Return if the vertex has a relationship of the type to the target.
    
    Specified by:
    
    hasOrInheritsInverseRelationship in interface Vertex
  - hasOrInheritsInverseRelationship
```
public boolean hasOrInheritsInverseRelationship(Vertex type,
                                                Vertex target,
                                                java.util.Map<Vertex,Vertex> recursion)
```
    Return if the vertex has a relationship of the type to the target.
    
    Specified by:
    
    hasOrInheritsInverseRelationship in interface Vertex
  - description
```
public java.lang.String description()
```
    Description copied from interface: Vertex
    
    Return a short toString, or header of the vertex.
    
    Specified by:
    
    description in interface Vertex
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - getDataType
```
public java.lang.String getDataType()
```
    Description copied from interface: Vertex
    
    Return the String name of the data's type.
    
    Specified by:
    
    getDataType in interface Vertex
  - getDataValue
```
public java.lang.String getDataValue()
```
    Description copied from interface: Vertex
    
    Return the String value of the data.
    
    Specified by:
    
    getDataValue in interface Vertex
  - setDataValue
```
public void setDataValue(java.lang.String value)
```
  - setType
```
public void setType(java.lang.String type)
```
    Set the internal data-type of the vertex.
    
    Specified by:
    
    setType in interface Vertex
  - setDataType
```
public void setDataType(java.lang.String type)
```
  - convertDataValue
```
public static java.lang.String convertDataValue(java.lang.Object data)
```
  - convertDataType
```
public static java.lang.String convertDataType(java.lang.Object data)
```
  - copy
```
public Vertex copy()
```
    Create a copy of the vertex with all of the same relationships. Since data is unique, this should only be used on vertices without data.
    
    Specified by:
    
    copy in interface Vertex
  - detach
```
public Vertex detach()
```
    Create a copy of the vertex with only the id.
    
    Specified by:
    
    detach in interface Vertex
  - getAllRelationships
```
public java.util.Collection<Relationship> getAllRelationships()
```
    Description copied from interface: Vertex
    
    Return all of the relationships.
    
    Specified by:
    
    getAllRelationships in interface Vertex
  - getName
```
public java.lang.String getName()
```
    Return the name of the vertex. The name is used as a hint to refer to what the vertex represents.
    
    Specified by:
    
    getName in interface Vertex
  - setName
```
public void setName(java.lang.String name)
```
    Set the name of the vertex. The name is used as a hint to refer to what the vertex represents.
    
    Specified by:
    
    setName in interface Vertex
  - hasName
```
public boolean hasName()
```
    Some vertices have no name, this provides an easy test method.
    
    Specified by:
    
    hasName in interface Vertex
  - isPinned
```
public boolean isPinned()
```
    Return if the vertex is pinned to memory, and will not be forgotten.
    
    Specified by:
    
    isPinned in interface Vertex
  - setPinned
```
public void setPinned(boolean pinned)
```
    Set if the vertex should be pinned to memory. Pinned vertices will not be forgotten.
    
    Specified by:
    
    setPinned in interface Vertex
  - printString
```
public java.lang.String printString()
```
    Print the object's data such as a sentence or paragraph.
    
    Specified by:
    
    printString in interface Vertex
  - printString
```
public java.lang.String printString(int depth)
```
    Print the object's data such as a sentence or paragraph.
    
    Specified by:
    
    printString in interface Vertex

Class BasicVertex

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

SELF

SMALL

MEDIUM

LARGE

Constructor Detail

BasicVertex

BasicVertex

BasicVertex

Method Detail

init

isTemporary

setIsTemporary

getWordCount

setWordCount

getGroupId

setGroupId

hasAnyResponseRelationship

getHasResponse

setHasResponse

isDirty

setIsDirty

setOriginal

getNetwork

setNetwork

getCreationDate

setCreationDate

getAccessDate

setAccessDate

getAccessCount

setAccessCount

incrementAccessCount

incrementConsciousnessLevel

decrementConsciousnessLevel

decrementConsciousnessLevel

incrementConsciousnessLevel

getConsciousnessLevel

setConsciousnessLevel

addRelationship

addRelationship

addRelationship

appendRelationship

appendRelationship

addRelationship

addRelationship

addRelationship

addRelationship

addWeakRelationship

addWeakRelationship

addWeakRelationship

addRelationship

addRelationship

equals

equalsIgnoreCase

getId

setId

hashCode

getData

setData

hasData

hasRelationships

getRelationships

applyQuotient

applyEval

applyWORD

applySENTENCE

applyFRAGMENT

applyALL

applyASSOCIATE

applyAPPEND

applyCONDITION

applyIF

applySET

applyRANDOM

applyDEBUG