SimpleHashableStateFactory

java.lang.Object
- burlap.oomdp.statehashing.SimpleHashableStateFactory

All Implemented Interfaces:

HashableStateFactory

Direct Known Subclasses:

DiscretizingHashableStateFactory, ImmutableStateHashableStateFactory, MaskedHashableStateFactory
```
public class SimpleHashableStateFactory
extends java.lang.Object
implements HashableStateFactory
```
A straightforward factory for creating HashableState objects from State instances. By default, this factory will be object identifier independent (the names of objects don't affect the state definition). However, you can make it object identifier dependent with the either of the constructors SimpleHashableStateFactory(boolean) or SimpleHashableStateFactory(boolean, boolean).

This factory is capable of hashing states with any kind of values. However, if you wish to hash states that have relational attributes, you must set the factory to be object identifier dependent.

Optionally, this factory can be set to produce HashableState instances that cache the hash code so that it does not need to be recomputed on multiple calls of the hashCode method. To enable hash code caching, use the SimpleHashableStateFactory(boolean, boolean) constructor. Using caching will use slightly more memory by having to associate an int with each HashableState.

This class has multiple aspects of the state equality methods implemented so that it can be easily sub classed by other forms of equality checking and have each method override only what it needs to override.

Author:

James MacGlashan.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected static class`	`SimpleHashableStateFactory.AttClass` Classes of `Attribute.AttributeType` that affect how hashing will be performed
`protected class`	`SimpleHashableStateFactory.SimpleCachedHashableState`
`protected class`	`SimpleHashableStateFactory.SimpleHashableState`
`static interface`	`SimpleHashableStateFactory.SimpleHashableStateInterface` An interface for `HashableState` instances that are created by the `SimpleHashableStateFactory`.

Field Summary

Fields
Modifier and Type	Field and Description
`protected boolean`	`identifierIndependent` Whether state evaluations are object identifier independent (the names of objects don't matter).
`protected boolean`	`useCached` Whether to cache the hash code for each produced `HashableState`.

Constructor Summary

Constructors
Constructor and Description
`SimpleHashableStateFactory()` Default constructor: object identifier independent and no hash code caching.
`SimpleHashableStateFactory(boolean identifierIndependent)` Initializes with no hash code caching.
`SimpleHashableStateFactory(boolean identifierIndependent, boolean useCached)` Initializes.

Method Summary

Methods
Modifier and Type	Method and Description
`protected void`	`appendHashcodeForValue(org.apache.commons.lang3.builder.HashCodeBuilder hashCodeBuilder, Value v)` Appends the hash code for the given `Value` to the `HashCodeBuilder`
`protected int`	`computeHashCode(ObjectInstance o)` Computes the hash code for an individual `ObjectInstance`.
`protected int`	`computeHashCode(State s)` Computes the hash code for the input state.
`protected SimpleHashableStateFactory.AttClass`	`getAttClass(Attribute att)`
`HashableState`	`hashState(State s)` Turns `State` s into a `HashableState`
`protected boolean`	`identifierDependentEquals(State s1, State s2)` Evaluates whether two states are equal when equality depends on object identifiers/names being equal.
`protected boolean`	`identifierIndependentEquals(State s1, State s2)` Evaluates whether two states are equal when equality is independent of object identifiers/names being equal
`boolean`	`objectIdentifierIndependent()` Returns true if the `HashableState` objects returned are object identifier independent; false if they are dependent.
`protected boolean`	`objectValuesEqual(ObjectInstance o1, ObjectInstance o2)` Evaluates whether the values of two `ObjectInstance`s are equal.
`protected boolean`	`statesEqual(State s1, State s2)` Returns true if the two input states are equal.
`protected boolean`	`valuesEqual(Value v1, Value v2)` Returns whether two values are equal.

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

- Field Detail
  - identifierIndependent
```
protected boolean identifierIndependent
```
    Whether state evaluations are object identifier independent (the names of objects don't matter). By default it is independent.
  - useCached
```
protected boolean useCached
```
    Whether to cache the hash code for each produced HashableState. Default is non-cached.
- Constructor Detail
  - SimpleHashableStateFactory
```
public SimpleHashableStateFactory()
```
    Default constructor: object identifier independent and no hash code caching.
  - SimpleHashableStateFactory
```
public SimpleHashableStateFactory(boolean identifierIndependent)
```
    Initializes with no hash code caching.
    
    Parameters:
    identifierIndependent - if true then state evaluations are object identifier independent; if false then dependent.
  - SimpleHashableStateFactory
```
public SimpleHashableStateFactory(boolean identifierIndependent,
                          boolean useCached)
```
    Initializes.
    
    Parameters:
    identifierIndependent - if true then state evaluations are object identifier independent; if false then dependent.
    useCached - if true then the hash code for each produced HashableState will be cached; if false then they will not be cached.
- Method Detail
  - hashState
```
public HashableState hashState(State s)
```
    Description copied from interface: HashableStateFactory
    
    Turns State s into a HashableState
    
    Specified by:
    
    hashState in interface HashableStateFactory
    
    Parameters:
    s - the input State to transform.
    
    Returns:
    a HashableState.
  - objectIdentifierIndependent
```
public boolean objectIdentifierIndependent()
```
    Description copied from interface: HashableStateFactory
    
    Returns true if the HashableState objects returned are object identifier independent; false if they are dependent.
    
    Specified by:
    
    objectIdentifierIndependent in interface HashableStateFactory
    
    Returns:
    true if the HashableState objects returned are object identifier independent; false if they are dependent.
  - computeHashCode
```
protected int computeHashCode(State s)
```
    Computes the hash code for the input state.
    
    Parameters:
    s - the input state for which a hash code is to be computed
    
    Returns:
    the hash code
  - computeHashCode
```
protected int computeHashCode(ObjectInstance o)
```
    Computes the hash code for an individual ObjectInstance.
    
    Parameters:
    o - the ObjectInstance whose hash code will be computed.
    
    Returns:
    the hash code for the ObjectInstance.
  - appendHashcodeForValue
```
protected void appendHashcodeForValue(org.apache.commons.lang3.builder.HashCodeBuilder hashCodeBuilder,
                          Value v)
```
    Appends the hash code for the given Value to the HashCodeBuilder
    
    Parameters:
    hashCodeBuilder - the HashCodeBuilder to which the value's hash code will be appended
    v - the Value whose hash code should be appended.
  - getAttClass
```
protected SimpleHashableStateFactory.AttClass getAttClass(Attribute att)
```
  - statesEqual
```
protected boolean statesEqual(State s1,
                  State s2)
```
    Returns true if the two input states are equal. Equality respect this hashing factory's identifier independence setting.
    
    Parameters:
    s1 - a State
    s2 - another State with which to compare
    
    Returns:
    true if s1 equals s2, false otherwise.
  - identifierIndependentEquals
```
protected boolean identifierIndependentEquals(State s1,
                                  State s2)
```
    Evaluates whether two states are equal when equality is independent of object identifiers/names being equal
    
    Parameters:
    s1 - the first State to compare
    s2 - the second State to compare
    
    Returns:
    true if s1 = s2; false otherwise
  - identifierDependentEquals
```
protected boolean identifierDependentEquals(State s1,
                                State s2)
```
    Evaluates whether two states are equal when equality depends on object identifiers/names being equal.
    
    Parameters:
    s1 - the first State to compare
    s2 - the second State to compare
    
    Returns:
    true if s1 = s2; false otherwise
  - objectValuesEqual
```
protected boolean objectValuesEqual(ObjectInstance o1,
                        ObjectInstance o2)
```
    Evaluates whether the values of two ObjectInstances are equal.
    
    Parameters:
    o1 - the first ObjectInstance to compare
    o2 - the second ObjectInstance to compare
    
    Returns:
    true if the values of o1 = o2; false otherwise.
  - valuesEqual
```
protected boolean valuesEqual(Value v1,
                  Value v2)
```
    Returns whether two values are equal.
    
    Parameters:
    v1 - the first value to compare
    v2 - the second value to compare
    
    Returns:
    true if v1 = v2; false otherwise

Class SimpleHashableStateFactory

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

identifierIndependent

useCached

Constructor Detail

SimpleHashableStateFactory

SimpleHashableStateFactory

SimpleHashableStateFactory

Method Detail

hashState

objectIdentifierIndependent

computeHashCode

computeHashCode

appendHashcodeForValue

getAttClass

statesEqual

identifierIndependentEquals

identifierDependentEquals

objectValuesEqual

valuesEqual