Structure (projog-core 0.10.0 API)

java.lang.Object
- org.projog.core.term.Structure

All Implemented Interfaces:

Term
```
public final class Structure
extends Object
implements Term
```
A Term consisting of a functor (name) and a number of other Term arguments.
Also known as a "compound term".

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`backtrack()` Reverts this term back to its original state prior to any unifications.
`Structure`	`copy(Map<Variable,Variable> sharedVariables)` Returns a copy of this term.
`static Term`	`createStructure(String functor, Term[] args)` Factory method for creating `Structure` instances.
`boolean`	`equals(Object o)`
`Term[]`	`getArgs()` Returns an array of this terms's arguments.
`Term`	`getArgument(int index)` Returns the term at the specified position in this term's arguments.
`String`	`getName()` Returns the functor of this structure.
`int`	`getNumberOfArguments()` Returns the number of arguments in this term.
`Structure`	`getTerm()` Returns the current instantiated state of this term.
`TermType`	`getType()` Returns `TermType.STRUCTURE`.
`int`	`hashCode()`
`boolean`	`isImmutable()` Returns `true` is this term is immutable.
`String`	`toString()` Returns a `String` representation of this term.
`boolean`	`unify(Term t)` Attempts to unify this term to the specified term.

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

Methods inherited from interface org.projog.core.term.Term
getBound

- Method Detail
  - createStructure
```
public static Term createStructure(String functor,
                                   Term[] args)
```
    Factory method for creating Structure instances.
    The reason that Structures have to be created via a factory method, rather than a constructor, is to enforce:
    - structures with the functor . and two arguments are created as instances of List
    - no structures can be created without any arguments
    Parameters:
    
    functor - the name of the new term
    
    args - arguments for the new term
    
    Returns:
    
    either a new Structure or a new List
  - getName
```
public String getName()
```
    Returns the functor of this structure.
    
    Specified by:
    
    getName in interface Term
    
    Returns:
    
    the functor of this structure
  - getArgs
```
public Term[] getArgs()
```
    Description copied from interface: Term
    
    Returns an array of this terms's arguments.
    Note: for performance reasons the array returned is the same array used internally be the term instance so be careful not to alter the array returned as changes will be reflected in the original term.
    
    Specified by:
    
    getArgs in interface Term
    
    Returns:
    
    array of this terms's arguments
    
    See Also:
    
    Term.getArgument(int)
  - getNumberOfArguments
```
public int getNumberOfArguments()
```
    Description copied from interface: Term
    
    Returns the number of arguments in this term.
    
    Specified by:
    
    getNumberOfArguments in interface Term
    
    Returns:
    
    number of arguments in this term
  - getArgument
```
public Term getArgument(int index)
```
    Description copied from interface: Term
    
    Returns the term at the specified position in this term's arguments.
    
    Specified by:
    
    getArgument in interface Term
    
    Parameters:
    
    index - index of the argument to return
    
    Returns:
    
    the term at the specified position in this term's arguments
  - getType
```
public TermType getType()
```
    Returns TermType.STRUCTURE.
    
    Specified by:
    
    getType in interface Term
    
    Returns:
    
    TermType.STRUCTURE
  - isImmutable
```
public boolean isImmutable()
```
    Description copied from interface: Term
    
    Returns true is this term is immutable.
    A term is considered immutable if its value will never change as a result of executing its Term.unify(Term) or Term.backtrack() methods. A term will not be considered immutable if it is a Variable or any of its arguments are not immutable.
    
    Specified by:
    
    isImmutable in interface Term
    
    Returns:
    
    true is this term is immutable
  - getTerm
```
public Structure getTerm()
```
    Description copied from interface: Term
    
    Returns the current instantiated state of this term.
    Returns a representation of this term with all instantiated Variables replaced with the terms they are instantiated with.
    
    Specified by:
    
    getTerm in interface Term
    
    Returns:
    
    a representation of this term with all instantiated Variables replaced with the terms they are instantiated with.
  - copy
```
public Structure copy(Map<Variable,Variable> sharedVariables)
```
    Description copied from interface: Term
    
    Returns a copy of this term.
    The returned copy will share any immutable terms contained in this term. The returned copy will contain new instances for any Variables contained in this term. The sharedVariables parameter keeps track of which Variables have already been copied.
    
    Specified by:
    
    copy in interface Term
    
    Parameters:
    
    sharedVariables - keeps track of which Variables have already been copied (key = original version, value = version used in copy)
    
    Returns:
    
    a copy of this term
  - unify
```
public boolean unify(Term t)
```
    Description copied from interface: Term
    Attempts to unify this term to the specified term.
    The rules for deciding if two terms are unifiable are as follows:
    - An uninstantiated Variable will unify with any term. As a result the Variable will become instantiated to the other term. The instantiaton will be undone when Term.backtrack() is next called on the Variable
    - Non-variable terms will unify with other terms that are of the same TermType and have the same value. The exact meaning of "having the same value" will vary between term types but will include that the two terms being unified have the same number of arguments and that all of their corresponding arguments unify.
    Note: can leave things in "half-state" on failure as neither List or Predicate backtrack earlier args.
    Specified by:
    
    unify in interface Term
    
    Parameters:
    
    t - the term to unify this term against
    
    Returns:
    
    true if the attempt to unify this term to the given term was successful
    
    See Also:
    
    Term.backtrack()
  - backtrack
```
public void backtrack()
```
    Description copied from interface: Term
    
    Reverts this term back to its original state prior to any unifications.
    Makes all Variables that this term consists of uninstantiated.
    
    Specified by:
    
    backtrack in interface Term
    
    See Also:
    
    Term.unify(Term)
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - toString
```
public String toString()
```
    Returns a String representation of this term.
    The value returned will consist of the structure's functor followed be a comma separated list of its arguments enclosed in brackets.
    Example: functor(arg1, arg2, arg3)
    
    Overrides:
    
    toString in class Object

Class Structure

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.projog.core.term.Term

Method Detail

createStructure

getName

getArgs

getNumberOfArguments

getArgument

getType

isImmutable

getTerm

copy

unify

backtrack

equals

hashCode

toString