Term (OpenNARS 3.0.4-SNAPSHOT API)

java.lang.Object
- org.opennars.language.Term

All Implemented Interfaces:

Serializable, Cloneable, Comparable<AbstractTerm>, AbstractTerm

Direct Known Subclasses:

CompoundTerm, Interval, Operator, Variable
```
public class Term
extends Object
implements AbstractTerm, Serializable
```
Term is the basic component of Narsese, and the object of processing in NARS.
A Term may have an associated Concept containing relations with other Terms. It is not linked in the Term, because a Concept may be forgot while the Term exists. Multiple objects may represent the same Term.

Author:

Pei Wang, Patrick Hammer

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type Class Description

static interface Term.TermVisitor

Nested Classes
Modifier and Type	Class	Description
`static interface`	`Term.TermVisitor`

Field Summary

Fields
Modifier and Type	Field	Description
`private static Map<CharSequence,Term>`	`atoms`
`static Term[]`	`EmptyTermArray`
`ImaginationSpace`	`imagination`
`String`	`index_variable`
`private CharSequence`	`name`
`static Term`	`SELF`
`static Term`	`SEQ_SPATIAL`
`static Term`	`SEQ_TEMPORAL`
`int[]`	`term_indices`

Constructor Summary

Constructors
Modifier Constructor Description

protected Term()
Default constructor that build an internal Term

Term(CharSequence name)
Constructor with a given name

Constructors
Modifier	Constructor	Description
`protected`	`Term()`	Default constructor that build an internal Term
	`Term(CharSequence name)`	Constructor with a given name

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`Term`	`clone()`	Make a new Term with the same name.
`Term`	`cloneDeep()`
`int`	`compareTo(AbstractTerm that)`
`int`	`containedTemporalRelations()`
`boolean`	`containsTerm(Term target)`	whether this contains a term in its components.
`boolean`	`containsTermRecursively(Term target)`	Recursively check if a compound contains a term
`Map<Term,Integer>`	`countTermRecursively(Map<Term,Integer> map)`	Recursively count how often the terms are contained
`boolean`	`equals(Object that)`	Equal terms have identical name, though not necessarily the same reference.
`static Term`	`get(int i)`	gets the atomic term of an integer
`static Term`	`get(CharSequence name)`	gets the atomic term given a name
`short`	`getComplexity()`
`boolean`	`getIsSpatial()`
`int`	`getTemporalOrder()`
`int`	`hashCode()`	Produce a hash code for the term
`boolean`	`hasInterval()`
`boolean`	`hasVar()`	Whether this compound term contains any variable term
`boolean`	`hasVar(char type)`
`boolean`	`hasVarDep()`
`boolean`	`hasVarIndep()`
`boolean`	`hasVarQuery()`
`boolean`	`isConstant()`	Check whether the current Term can name a Concept.
`boolean`	`isExecutable(Memory mem)`
`boolean`	`isHigherOrderStatement()`
`static boolean`	`isSelf(Term t)`
`CharSequence`	`name()`	Reporting the name of the current Term.
`protected CharSequence`	`nameInternal()`
`Symbols.NativeOperator`	`operator()`
`void`	`recurseSubtermsContainingVariables(Term.TermVisitor v)`
`void`	`recurseSubtermsContainingVariables(Term.TermVisitor v, Term parent)`
`void`	`recurseTerms(Term.TermVisitor v, Term parent)`
`protected void`	`setName(CharSequence newName)`	set the name
`boolean`	`subjectOrPredicateIsIndependentVar()`
`static Term`	`text(String t)`	Creates a quote-escaped term from a string.
`static NavigableSet<Term>`	`toSortedSet(Term... arg)`
`static Term[]`	`toSortedSetArray(Term... arg)`
`String`	`toString()`	The same as getName by default, used in display only.
`static boolean`	`valid(Term content)`	performs a thorough check of the validity of a term (by cloneDeep it) to see if it's valid

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

- Field Detail
  - imagination
```
public ImaginationSpace imagination
```
  - atoms
```
private static final Map<CharSequence,Term> atoms
```
  - SELF
```
public static final Term SELF
```
  - SEQ_SPATIAL
```
public static final Term SEQ_SPATIAL
```
  - SEQ_TEMPORAL
```
public static final Term SEQ_TEMPORAL
```
  - name
```
private CharSequence name
```
  - term_indices
```
public int[] term_indices
```
  - index_variable
```
public String index_variable
```
  - EmptyTermArray
```
public static final Term[] EmptyTermArray
```
- Constructor Detail
  - Term
```
protected Term()
```
    Default constructor that build an internal Term
  - Term
```
public Term(CharSequence name)
```
    Constructor with a given name
    
    Parameters:
    
    name - A String as the name of the Term
- Method Detail
  - isSelf
```
public static final boolean isSelf(Term t)
```
  - operator
```
public Symbols.NativeOperator operator()
```
  - isHigherOrderStatement
```
public boolean isHigherOrderStatement()
```
  - isExecutable
```
public boolean isExecutable(Memory mem)
```
  - get
```
public static final Term get(CharSequence name)
```
    gets the atomic term given a name
  - get
```
public static final Term get(int i)
```
    gets the atomic term of an integer
  - name
```
public CharSequence name()
```
    Reporting the name of the current Term.
    
    Specified by:
    
    name in interface AbstractTerm
    
    Returns:
    
    The name of the term as a String
  - nameInternal
```
protected CharSequence nameInternal()
```
  - clone
```
public Term clone()
```
    Make a new Term with the same name.
    
    Overrides:
    
    clone in class Object
    
    Returns:
    
    The new Term
  - cloneDeep
```
public Term cloneDeep()
```
  - equals
```
public boolean equals(Object that)
```
    Equal terms have identical name, though not necessarily the same reference.
    
    Overrides:
    
    equals in class Object
    
    Parameters:
    
    that - The Term to be compared with the current Term
    
    Returns:
    
    Whether the two Terms are equal
  - hashCode
```
public int hashCode()
```
    Produce a hash code for the term
    
    Overrides:
    
    hashCode in class Object
    
    Returns:
    
    An integer hash code
  - isConstant
```
public boolean isConstant()
```
    Check whether the current Term can name a Concept. isConstant means if the term contains free variable True if: has zero variables, or uses several instances of the same variable False if it uses one instance of a variable ("free" like a "free radical" in chemistry). Therefore it may be considered Constant, yet actually contain variables.
    
    Specified by:
    
    isConstant in interface AbstractTerm
    
    Returns:
    
    A Term is constant by default
  - getTemporalOrder
```
public int getTemporalOrder()
```
  - getIsSpatial
```
public boolean getIsSpatial()
```
  - recurseTerms
```
public void recurseTerms(Term.TermVisitor v,
                         Term parent)
```
  - recurseSubtermsContainingVariables
```
public void recurseSubtermsContainingVariables(Term.TermVisitor v)
```
  - recurseSubtermsContainingVariables
```
public void recurseSubtermsContainingVariables(Term.TermVisitor v,
                                               Term parent)
```
  - getComplexity
```
public short getComplexity()
```
    Returns:
    
    The complexity of the term, an integer
  - setName
```
protected void setName(CharSequence newName)
```
    set the name
  - compareTo
```
public int compareTo(AbstractTerm that)
```
    Specified by:
    
    compareTo in interface Comparable<AbstractTerm>
    
    Parameters:
    
    that - The Term to be compared with the current Term
    
    Returns:
    
    The same as compareTo as defined on Strings
  - containedTemporalRelations
```
public int containedTemporalRelations()
```
  - containsTermRecursively
```
public boolean containsTermRecursively(Term target)
```
    Recursively check if a compound contains a term
    
    Parameters:
    
    target - The term to be searched
    
    Returns:
    
    Whether the two have the same content
  - countTermRecursively
```
public Map<Term,Integer> countTermRecursively(Map<Term,Integer> map)
```
    Recursively count how often the terms are contained
    
    Parameters:
    
    map - The count map that will be created to count how often each term occurs
    
    Returns:
    
    The counts of the terms
  - containsTerm
```
public boolean containsTerm(Term target)
```
    whether this contains a term in its components.
  - toString
```
public final String toString()
```
    The same as getName by default, used in display only.
    
    Overrides:
    
    toString in class Object
    
    Returns:
    
    The name of the term as a String
  - text
```
public static Term text(String t)
```
    Creates a quote-escaped term from a string. Useful for an atomic term that is meant to contain a message as its name
  - hasVar
```
public boolean hasVar()
```
    Whether this compound term contains any variable term
    
    Specified by:
    
    hasVar in interface AbstractTerm
    
    Returns:
    
    Whether the name contains a variable
  - hasVar
```
public boolean hasVar(char type)
```
  - hasVarIndep
```
public boolean hasVarIndep()
```
  - hasInterval
```
public boolean hasInterval()
```
  - hasVarDep
```
public boolean hasVarDep()
```
  - hasVarQuery
```
public boolean hasVarQuery()
```
  - toSortedSet
```
public static NavigableSet<Term> toSortedSet(Term... arg)
```
  - toSortedSetArray
```
public static Term[] toSortedSetArray(Term... arg)
```
  - valid
```
public static boolean valid(Term content)
```
    performs a thorough check of the validity of a term (by cloneDeep it) to see if it's valid
  - subjectOrPredicateIsIndependentVar
```
public boolean subjectOrPredicateIsIndependentVar()
```

Class Term

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

imagination

atoms

SELF

SEQ_SPATIAL

SEQ_TEMPORAL

name

term_indices

index_variable

EmptyTermArray

Constructor Detail

Term

Term

Method Detail

isSelf

operator

isHigherOrderStatement

isExecutable

get

get

name

nameInternal

clone

cloneDeep

equals

hashCode

isConstant

getTemporalOrder

getIsSpatial

recurseTerms

recurseSubtermsContainingVariables

recurseSubtermsContainingVariables

getComplexity

setName

compareTo

containedTemporalRelations

containsTermRecursively

countTermRecursively

containsTerm

toString

text

hasVar

hasVar

hasVarIndep

hasInterval

hasVarDep

hasVarQuery

toSortedSet

toSortedSetArray

valid

subjectOrPredicateIsIndependentVar