AbstractDeclarativeModule

java.lang.Object
- org.jactr.core.utils.DefaultAdaptable
- - org.jactr.core.module.AbstractModule
  - - org.jactr.core.module.declarative.basic.AbstractDeclarativeModule

All Implemented Interfaces:

IDeclarativeModule, IModule, IAdaptable, IInitializable, IInstallable

Direct Known Subclasses:

DefaultDeclarativeModule
```
public abstract class AbstractDeclarativeModule
extends AbstractModule
implements IDeclarativeModule
```
Abstract declarative module that provides most of the functionality required of the IDeclarativeModule including creation, merging and disposal of chunks and types. However, the actual adding to the containers or searching is left to subclasses.
The factories used by this class are not set by default.

Author:

harrison

See Also:

http://jactr.org/node/120

Field Summary

Fields
Modifier and Type Field and Description

protected ChunkActivationComparator _activationSorter

static java.lang.String SUSPEND_DISPOSAL_KEY

Fields
Modifier and Type	Field and Description
`protected ChunkActivationComparator`	`_activationSorter`
`static java.lang.String`	`SUSPEND_DISPOSAL_KEY`

Constructor Summary

Constructors
Constructor and Description

AbstractDeclarativeModule(java.lang.String name)

Constructors
Constructor and Description
`AbstractDeclarativeModule(java.lang.String name)`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`java.util.concurrent.CompletableFuture<IChunk>`	`addChunk(IChunk chunk)` add chunk to DM.
`protected abstract IChunk`	`addChunkInternal(IChunk chunkToAdd, java.util.Collection<IChunk> possibleMatches)` add the chunk to DM on the module's executor.
`java.util.concurrent.CompletableFuture<IChunkType>`	`addChunkType(IChunkType chunkType)` add chunktype to DM, delegated to `addChunkTypeInternal(IChunkType)` on `AbstractModule.getExecutor()`
`protected abstract IChunkType`	`addChunkTypeInternal(IChunkType chunkType)` add the chunktype DM on the module's executor.
`void`	`addListener(IDeclarativeModuleListener listener, java.util.concurrent.Executor executor)`
`protected void`	`configure(IChunk newChunk)` calls the pluggable IChunkConfigurator
`protected void`	`configure(IChunkType newChunkType)` calls `IChunkTypeConfigurator`
`java.util.concurrent.CompletableFuture<IChunk>`	`copyChunk(IChunk sourceChunk)` copy the specified chunk, by default this will also copy subsymbolics
`java.util.concurrent.CompletableFuture<IChunk>`	`copyChunk(IChunk sourceChunk, boolean copySubsymbolics)`
`protected void`	`copyChunkInternal(IChunk sourceChunk, IChunk destination, boolean copySubsymbolics)` copy source to copy
`java.util.concurrent.CompletableFuture<IChunk>`	`createChunk(IChunkType parent, java.lang.String name)` create a chunk by delegating to `createChunkInternal(IChunkType, String)` on `AbstractModule.getExecutor()`
`protected IChunk`	`createChunkInternal(IChunkType parent, java.lang.String name)` create the chunk
`java.util.concurrent.CompletableFuture<IChunkType>`	`createChunkType(java.util.Collection<IChunkType> parents, java.lang.String name)` create chunktype, delegates to `#createChunkTypeInternal(IChunkType, String)` on `AbstractModule.getExecutor()`
`java.util.concurrent.CompletableFuture<IChunkType>`	`createChunkType(IChunkType parent, java.lang.String name)`
`protected IChunkType`	`createChunkTypeInternal(java.util.Collection<IChunkType> parents, java.lang.String name)`
`protected void`	`deferredEncode(java.util.Collection<IChunk> chunks)`
`protected void`	`deferredEncode(IChunk chunk)` encode this chunk at some later time (top/bottom of the cycle).
`protected void`	`dispatch(DeclarativeModuleEvent event)`
`void`	`dispose(IChunk chunk)` schedule this chunk to be disposed, at the module's earliest convenience
`protected void`	`disposeInternal(IChunk chunk)` actually perform the disposal
`protected void`	`fireChunkAdded(IChunk chunk)`
`protected void`	`fireChunkCreated(IChunk chunk)`
`protected void`	`fireChunkDisposed(IChunk chunk)`
`protected void`	`fireChunkRemoved(IChunk chunk)`
`protected void`	`fireChunksMerged(IChunk original, IChunk duplicateChunk)`
`protected void`	`fireChunkTypeAdded(IChunkType chunkType)`
`protected void`	`fireChunkTypeCreated(IChunkType chunkType)`
`protected void`	`fireChunkTypeDisposed(IChunkType chunkType)`
`protected void`	`fireChunkTypesMerged(IChunkType original, IChunkType duplicate)`
`void`	`flush()` force all pending deferred operations to execute (dispose, encode, etc)
`IAssociativeLinkageSystem`	`getAssociativeLinkageSystem()` code responsible for the setting up and maintaining of associative links, may be null.
`IChunk`	`getBusyChunk()` snag the busy chunk. Note : this should not be called by the declarative memory module if the retrieval will access the future methods as it might result in deadlock.
`java.util.concurrent.CompletableFuture<IChunk>`	`getChunk(java.lang.String name)` delegated
`IChunkConfigurator`	`getChunkConfigurator()`
`IChunkFactory`	`getChunkFactory()`
`protected abstract IChunk`	`getChunkInternal(java.lang.String chunkName)`
`IChunkNamer`	`getChunkNamer()`
`java.util.concurrent.CompletableFuture<java.util.Collection<IChunk>>`	`getChunks()` return all chunks.
`protected abstract java.util.Collection<IChunk>`	`getChunksInternal()`
`java.util.concurrent.CompletableFuture<IChunkType>`	`getChunkType(java.lang.String name)` delegated
`IChunkTypeConfigurator`	`getChunkTypeConfigurator()`
`IChunkTypeFactory`	`getChunkTypeFactory()`
`protected abstract IChunkType`	`getChunkTypeInternal(java.lang.String name)`
`IChunkTypeNamer`	`getChunkTypeNamer()`
`java.util.concurrent.CompletableFuture<java.util.Collection<IChunkType>>`	`getChunkTypes()` delegated
`protected abstract java.util.Collection<IChunkType>`	`getChunkTypesInternal()`
`IChunk`	`getEmptyChunk()` snag the busy chunk. Note : this should not be called by the declarative memory module if the retrieval will access the future methods as it might result in deadlock.
`IChunk`	`getErrorChunk()` snag the busy chunk. Note : this should not be called by the declarative memory module if the retrieval will access the future methods as it might result in deadlock.
`IChunk`	`getFreeChunk()` snag the busy chunk. Note : this should not be called by the declarative memory module if the retrieval will access the future methods as it might result in deadlock.
`IChunk`	`getFullChunk()` snag the busy chunk. Note : this should not be called by the declarative memory module if the retrieval will access the future methods as it might result in deadlock.
`IChunk`	`getNewChunk()` snag the busy chunk. Note : this should not be called by the declarative memory module if the retrieval will access the future methods as it might result in deadlock.
`IChunk`	`getRequestedChunk()` snag the busy chunk. Note : this should not be called by the declarative memory module if the retrieval will access the future methods as it might result in deadlock.
`ISubsymbolicChunkFactory`	`getSubsymbolicChunkFactory()`
`ISubsymbolicChunkTypeFactory`	`getSubsymbolicChunkTypeFactory()`
`ISymbolicChunkFactory`	`getSymbolicChunkFactory()`
`ISymbolicChunkTypeFactory`	`getSymbolicChunkTypeFactory()`
`IChunk`	`getUnrequestedChunk()` snag the busy chunk. Note : this should not be called by the declarative memory module if the retrieval will access the future methods as it might result in deadlock.
`protected boolean`	`hasListeners()`
`void`	`initialize()` this will be called after all the modules have been installed permitting the module to attach listeners to other modules.
`void`	`install(IModel model)` called from the model during IModel.install(IModule).
`static boolean`	`isDisposalSuspended(IChunk chunk)`
`protected IChunk`	`merge(IChunk originalChunk, IChunk newChunk)` entry point for merging chunks.
`protected void`	`mergeChunksInternal(IChunk originalChunk, IChunk newChunk)` actually do the work or merging newChunk into originalChunk.
`protected void`	`processPendingDisposals(javolution.util.FastList<IChunk> chunkContainer, javolution.util.FastList<IActivationBuffer> bufferContainer)` called internally at the top & bottom of the cycle and at the end of a run.
`protected void`	`processPendingEncodingAndDisposals()`
`protected void`	`processPendingEncodings(javolution.util.FastList<IChunk> chunkContainer, javolution.util.FastList<IActivationBuffer> bufferContainer)`
`void`	`removeListener(IDeclarativeModuleListener listener)`
`void`	`setAssociativeLinkageSystem(IAssociativeLinkageSystem linkageSystem)` the code responsible for linking memories.
`void`	`setChunkConfigurator(IChunkConfigurator configurator)`
`void`	`setChunkFactory(IChunkFactory chunkFactory)`
`void`	`setChunkNamer(IChunkNamer namer)`
`void`	`setChunkTypeConfigurator(IChunkTypeConfigurator configurator)`
`void`	`setChunkTypeFactory(IChunkTypeFactory chunkTypeFactory)`
`void`	`setChunkTypeNamer(IChunkTypeNamer namer)`
`static void`	`setDisposalSuspended(IChunk chunk, boolean suspend)` there is a grey area between the creation of a chunk and it's use in a buffer or encoding.
`void`	`setSubsymbolicChunkFactory(ISubsymbolicChunkFactory factory)`
`void`	`setSubsymbolicChunkTypeFactory(ISubsymbolicChunkTypeFactory factory)`
`void`	`setSymbolicChunkFactory(ISymbolicChunkFactory factory)`
`void`	`setSymbolicChunkTypeFactory(ISymbolicChunkTypeFactory factory)`
`void`	`uninstall(IModel model)` remove the element from this model.
`boolean`	`willEncode(IChunk chunk)` because encoding might be async, we need a method to determine if a given chunk is scheduled for encoding

Methods inherited from class org.jactr.core.module.AbstractModule
createBuffers, delayedFuture, delayedFuture, dispose, getExecutor, getModel, getName, getSafeName, immediateFuture, immediateReturn, setExecutor

Methods inherited from class org.jactr.core.utils.DefaultAdaptable
addAdapterFactory, getAdapter, removeAdapterFactory

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

Methods inherited from interface org.jactr.core.module.declarative.IDeclarativeModule
findExactMatches, findPartialMatches, getNumberOfChunks

Methods inherited from interface org.jactr.core.module.IModule
dispose, getModel, getName, reset

Methods inherited from interface org.jactr.core.utils.IAdaptable
getAdapter

- Field Detail
  - SUSPEND_DISPOSAL_KEY
```
public static final java.lang.String SUSPEND_DISPOSAL_KEY
```
  - _activationSorter
```
protected ChunkActivationComparator _activationSorter
```
- Constructor Detail
  - AbstractDeclarativeModule
```
public AbstractDeclarativeModule(java.lang.String name)
```
- Method Detail
  - setDisposalSuspended
```
public static void setDisposalSuspended(IChunk chunk,
                                        boolean suspend)
```
    there is a grey area between the creation of a chunk and it's use in a buffer or encoding. Most never encounter it, but it can occur in the time between a perceptual search (i.e. visual-location) and encoding, where the system may want to dispose of the chunk (i.e. the underlying percept has changed too much) in order to create a new one. However, if the encoding process has already started, it is possible that the system will try to add the disposed chunk to a buffer.
    This mechanism is a recommendation only, that the declarative module can use to temporarily suspend disposal.
    
    Parameters:
    
    chunk -
  - isDisposalSuspended
```
public static boolean isDisposalSuspended(IChunk chunk)
```
  - flush
```
public void flush()
```
    Description copied from interface: IDeclarativeModule
    
    force all pending deferred operations to execute (dispose, encode, etc)
    
    Specified by:
    
    flush in interface IDeclarativeModule
  - install
```
public void install(IModel model)
```
    Description copied from interface: IModule
    
    called from the model during IModel.install(IModule). The module should handle any nondependent initialization here. Since no chunks will have been installed yet, the module should make not attempt to make reference to any until just before the model runs. Likewise, you should not install listeners into modules that this one is dependent upon until initialize() is called.
    
    Specified by:
    
    install in interface IModule
    
    Specified by:
    
    install in interface IInstallable
    
    Overrides:
    
    install in class AbstractModule
    
    See Also:
    
    IInstallable.install(org.jactr.core.model.IModel)
  - uninstall
```
public void uninstall(IModel model)
```
    Description copied from interface: IInstallable
    
    remove the element from this model. this is called after the model terminates
    
    Specified by:
    
    uninstall in interface IInstallable
    
    Overrides:
    
    uninstall in class AbstractModule
  - initialize
```
public void initialize()
```
    Description copied from interface: IModule
    
    this will be called after all the modules have been installed permitting the module to attach listeners to other modules. if you want to get access to chunks,types, or productions before the model runs, attach a model listener and do that during the modelStarted call
    
    Specified by:
    
    initialize in interface IModule
    
    Specified by:
    
    initialize in interface IInitializable
    
    Specified by:
    
    initialize in class AbstractModule
  - addListener
```
public void addListener(IDeclarativeModuleListener listener,
                        java.util.concurrent.Executor executor)
```
    Specified by:
    
    addListener in interface IDeclarativeModule
  - removeListener
```
public void removeListener(IDeclarativeModuleListener listener)
```
    Specified by:
    
    removeListener in interface IDeclarativeModule
  - fireChunkCreated
```
protected void fireChunkCreated(IChunk chunk)
```
  - fireChunkTypeCreated
```
protected void fireChunkTypeCreated(IChunkType chunkType)
```
  - fireChunkAdded
```
protected void fireChunkAdded(IChunk chunk)
```
  - fireChunkRemoved
```
protected void fireChunkRemoved(IChunk chunk)
```
  - fireChunkDisposed
```
protected void fireChunkDisposed(IChunk chunk)
```
  - fireChunkTypeAdded
```
protected void fireChunkTypeAdded(IChunkType chunkType)
```
  - fireChunksMerged
```
protected void fireChunksMerged(IChunk original,
                                IChunk duplicateChunk)
```
  - fireChunkTypeDisposed
```
protected void fireChunkTypeDisposed(IChunkType chunkType)
```
  - fireChunkTypesMerged
```
protected void fireChunkTypesMerged(IChunkType original,
                                    IChunkType duplicate)
```
  - hasListeners
```
protected boolean hasListeners()
```
  - dispatch
```
protected void dispatch(DeclarativeModuleEvent event)
```
  - getBusyChunk
```
public IChunk getBusyChunk()
```
    Description copied from interface: IDeclarativeModule
    
    snag the busy chunk.
    
    Note : this should not be called by the declarative memory module if the retrieval will access the future methods as it might result in deadlock.
    
    Specified by:
    
    getBusyChunk in interface IDeclarativeModule
    
    Returns:
  - getEmptyChunk
```
public IChunk getEmptyChunk()
```
    Description copied from interface: IDeclarativeModule
    
    snag the busy chunk.
    
    Note : this should not be called by the declarative memory module if the retrieval will access the future methods as it might result in deadlock.
    
    Specified by:
    
    getEmptyChunk in interface IDeclarativeModule
    
    Returns:
  - getErrorChunk
```
public IChunk getErrorChunk()
```
    Description copied from interface: IDeclarativeModule
    
    snag the busy chunk.
    
    Note : this should not be called by the declarative memory module if the retrieval will access the future methods as it might result in deadlock.
    
    Specified by:
    
    getErrorChunk in interface IDeclarativeModule
    
    Returns:
  - getFreeChunk
```
public IChunk getFreeChunk()
```
    Description copied from interface: IDeclarativeModule
    
    snag the busy chunk.
    
    Note : this should not be called by the declarative memory module if the retrieval will access the future methods as it might result in deadlock.
    
    Specified by:
    
    getFreeChunk in interface IDeclarativeModule
    
    Returns:
  - getFullChunk
```
public IChunk getFullChunk()
```
    Description copied from interface: IDeclarativeModule
    
    snag the busy chunk.
    
    Note : this should not be called by the declarative memory module if the retrieval will access the future methods as it might result in deadlock.
    
    Specified by:
    
    getFullChunk in interface IDeclarativeModule
    
    Returns:
  - getNewChunk
```
public IChunk getNewChunk()
```
    Description copied from interface: IDeclarativeModule
    
    snag the busy chunk.
    
    Note : this should not be called by the declarative memory module if the retrieval will access the future methods as it might result in deadlock.
    
    Specified by:
    
    getNewChunk in interface IDeclarativeModule
    
    Returns:
  - getRequestedChunk
```
public IChunk getRequestedChunk()
```
    Description copied from interface: IDeclarativeModule
    
    snag the busy chunk.
    
    Note : this should not be called by the declarative memory module if the retrieval will access the future methods as it might result in deadlock.
    
    Specified by:
    
    getRequestedChunk in interface IDeclarativeModule
    
    Returns:
  - getUnrequestedChunk
```
public IChunk getUnrequestedChunk()
```
    Description copied from interface: IDeclarativeModule
    
    snag the busy chunk.
    
    Note : this should not be called by the declarative memory module if the retrieval will access the future methods as it might result in deadlock.
    
    Specified by:
    
    getUnrequestedChunk in interface IDeclarativeModule
    
    Returns:
  - setChunkFactory
```
public void setChunkFactory(IChunkFactory chunkFactory)
```
  - getChunkFactory
```
public IChunkFactory getChunkFactory()
```
  - setSymbolicChunkFactory
```
public void setSymbolicChunkFactory(ISymbolicChunkFactory factory)
```
  - getSymbolicChunkFactory
```
public ISymbolicChunkFactory getSymbolicChunkFactory()
```
  - setSubsymbolicChunkFactory
```
public void setSubsymbolicChunkFactory(ISubsymbolicChunkFactory factory)
```
  - getSubsymbolicChunkFactory
```
public ISubsymbolicChunkFactory getSubsymbolicChunkFactory()
```
  - setChunkConfigurator
```
public void setChunkConfigurator(IChunkConfigurator configurator)
```
  - getChunkConfigurator
```
public IChunkConfigurator getChunkConfigurator()
```
  - setChunkNamer
```
public void setChunkNamer(IChunkNamer namer)
```
  - getChunkNamer
```
public IChunkNamer getChunkNamer()
```
  - setChunkTypeFactory
```
public void setChunkTypeFactory(IChunkTypeFactory chunkTypeFactory)
```
  - getChunkTypeFactory
```
public IChunkTypeFactory getChunkTypeFactory()
```
  - setSymbolicChunkTypeFactory
```
public void setSymbolicChunkTypeFactory(ISymbolicChunkTypeFactory factory)
```
  - getSymbolicChunkTypeFactory
```
public ISymbolicChunkTypeFactory getSymbolicChunkTypeFactory()
```
  - setSubsymbolicChunkTypeFactory
```
public void setSubsymbolicChunkTypeFactory(ISubsymbolicChunkTypeFactory factory)
```
  - getSubsymbolicChunkTypeFactory
```
public ISubsymbolicChunkTypeFactory getSubsymbolicChunkTypeFactory()
```
  - setChunkTypeConfigurator
```
public void setChunkTypeConfigurator(IChunkTypeConfigurator configurator)
```
  - getChunkTypeConfigurator
```
public IChunkTypeConfigurator getChunkTypeConfigurator()
```
  - setChunkTypeNamer
```
public void setChunkTypeNamer(IChunkTypeNamer namer)
```
  - getChunkTypeNamer
```
public IChunkTypeNamer getChunkTypeNamer()
```
  - createChunk
```
public java.util.concurrent.CompletableFuture<IChunk> createChunk(IChunkType parent,
                                                                  java.lang.String name)
```
    create a chunk by delegating to createChunkInternal(IChunkType, String) on AbstractModule.getExecutor()
    
    Specified by:
    
    createChunk in interface IDeclarativeModule
    
    Parameters:
    
    parent -
    
    name -
    
    Returns:
    
    See Also:
    
    IDeclarativeModule.createChunk(org.jactr.core.chunktype.IChunkType, java.lang.String)
  - createChunkInternal
```
protected IChunk createChunkInternal(IChunkType parent,
                                     java.lang.String name)
```
    create the chunk
    
    Parameters:
    
    parent -
    
    name -
    
    Returns:
  - configure
```
protected void configure(IChunk newChunk)
```
    calls the pluggable IChunkConfigurator
    
    Parameters:
    
    newChunk -
  - addChunk
```
public java.util.concurrent.CompletableFuture<IChunk> addChunk(IChunk chunk)
```
    add chunk to DM. performs a search for any matches, then merely delegates to addChunkInternal(IChunk, Collection) on AbstractModule.getExecutor()
    
    Specified by:
    
    addChunk in interface IDeclarativeModule
    
    Parameters:
    
    chunk -
    
    Returns:
    
    See Also:
    
    IDeclarativeModule.addChunk(org.jactr.core.chunk.IChunk)
  - addChunkInternal
```
protected abstract IChunk addChunkInternal(IChunk chunkToAdd,
                                           java.util.Collection<IChunk> possibleMatches)
```
    add the chunk to DM on the module's executor. If the executor is INLINE or multiply threaded, thread safety is a must.
    
    Parameters:
    
    chunkToAdd -
    
    possibleMatches - TODO
    
    -
    
    Returns:
  - copyChunk
```
public java.util.concurrent.CompletableFuture<IChunk> copyChunk(IChunk sourceChunk)
```
    copy the specified chunk, by default this will also copy subsymbolics
    
    Specified by:
    
    copyChunk in interface IDeclarativeModule
    
    Returns:
  - copyChunk
```
public java.util.concurrent.CompletableFuture<IChunk> copyChunk(IChunk sourceChunk,
                                                                boolean copySubsymbolics)
```
    Specified by:
    
    copyChunk in interface IDeclarativeModule
  - copyChunkInternal
```
protected void copyChunkInternal(IChunk sourceChunk,
                                 IChunk destination,
                                 boolean copySubsymbolics)
```
    copy source to copy
    
    Parameters:
    
    sourceChunk -
    
    copy -
  - getChunk
```
public java.util.concurrent.CompletableFuture<IChunk> getChunk(java.lang.String name)
```
    delegated
    
    Specified by:
    
    getChunk in interface IDeclarativeModule
    
    Parameters:
    
    name -
    
    Returns:
    
    See Also:
    
    IDeclarativeModule.getChunk(java.lang.String)
  - getChunkInternal
```
protected abstract IChunk getChunkInternal(java.lang.String chunkName)
```
  - getChunks
```
public java.util.concurrent.CompletableFuture<java.util.Collection<IChunk>> getChunks()
```
    Description copied from interface: IDeclarativeModule
    
    return all chunks. This can be a very expensive operation
    
    Specified by:
    
    getChunks in interface IDeclarativeModule
    
    Returns:
    
    See Also:
    
    IDeclarativeModule.getChunks()
  - getChunksInternal
```
protected abstract java.util.Collection<IChunk> getChunksInternal()
```
  - createChunkType
```
public java.util.concurrent.CompletableFuture<IChunkType> createChunkType(java.util.Collection<IChunkType> parents,
                                                                          java.lang.String name)
```
    create chunktype, delegates to #createChunkTypeInternal(IChunkType, String) on AbstractModule.getExecutor()
    
    Specified by:
    
    createChunkType in interface IDeclarativeModule
    
    Parameters:
    
    parent -
    
    name -
    
    Returns:
    
    See Also:
    
    IDeclarativeModule.createChunkType(org.jactr.core.chunktype.IChunkType, java.lang.String)
  - createChunkType
```
public java.util.concurrent.CompletableFuture<IChunkType> createChunkType(IChunkType parent,
                                                                          java.lang.String name)
```
    Specified by:
    
    createChunkType in interface IDeclarativeModule
  - createChunkTypeInternal
```
protected IChunkType createChunkTypeInternal(java.util.Collection<IChunkType> parents,
                                             java.lang.String name)
```
  - configure
```
protected void configure(IChunkType newChunkType)
```
    calls IChunkTypeConfigurator
    
    Parameters:
    
    newChunkType -
  - addChunkType
```
public java.util.concurrent.CompletableFuture<IChunkType> addChunkType(IChunkType chunkType)
```
    add chunktype to DM, delegated to addChunkTypeInternal(IChunkType) on AbstractModule.getExecutor()
    
    Specified by:
    
    addChunkType in interface IDeclarativeModule
    
    Parameters:
    
    chunkType -
    
    Returns:
    
    See Also:
    
    IDeclarativeModule.addChunkType(org.jactr.core.chunktype.IChunkType)
  - addChunkTypeInternal
```
protected abstract IChunkType addChunkTypeInternal(IChunkType chunkType)
```
    add the chunktype DM on the module's executor. If the executor is INLINE or multithreaded, thread safety is a must.
    
    Parameters:
    
    chunkType -
    
    Returns:
  - getChunkType
```
public java.util.concurrent.CompletableFuture<IChunkType> getChunkType(java.lang.String name)
```
    delegated
    
    Specified by:
    
    getChunkType in interface IDeclarativeModule
    
    Parameters:
    
    name -
    
    Returns:
    
    See Also:
    
    IDeclarativeModule.getChunkType(java.lang.String)
  - getChunkTypeInternal
```
protected abstract IChunkType getChunkTypeInternal(java.lang.String name)
```
  - getChunkTypes
```
public java.util.concurrent.CompletableFuture<java.util.Collection<IChunkType>> getChunkTypes()
```
    delegated
    
    Specified by:
    
    getChunkTypes in interface IDeclarativeModule
    
    Returns:
    
    See Also:
    
    IDeclarativeModule.getChunkTypes()
  - getChunkTypesInternal
```
protected abstract java.util.Collection<IChunkType> getChunkTypesInternal()
```
  - setAssociativeLinkageSystem
```
public void setAssociativeLinkageSystem(IAssociativeLinkageSystem linkageSystem)
```
    Description copied from interface: IDeclarativeModule
    
    the code responsible for linking memories. Can be null if this is unsupported. Typically this will be called by a declarative learning module to install custom version
    
    Specified by:
    
    setAssociativeLinkageSystem in interface IDeclarativeModule
  - getAssociativeLinkageSystem
```
public IAssociativeLinkageSystem getAssociativeLinkageSystem()
```
    Description copied from interface: IDeclarativeModule
    
    code responsible for the setting up and maintaining of associative links, may be null.
    
    Specified by:
    
    getAssociativeLinkageSystem in interface IDeclarativeModule
    
    Returns:
  - disposeInternal
```
protected void disposeInternal(IChunk chunk)
```
    actually perform the disposal
    
    Parameters:
    
    chunk -
  - merge
```
protected IChunk merge(IChunk originalChunk,
                       IChunk newChunk)
```
    entry point for merging chunks. This assumes that originalChunk is encoded, newChunk was going to be encoded, but was determined to be merged into originalChunk instead. newChunk may or maynot have been encoded.
    This method handles the event dispatching, logging and ultimately calls mergeChunksInternal(IChunk, IChunk) to do the real work.
    
    Parameters:
    
    originalChunk -
    
    newChunk -
    
    Returns:
  - mergeChunksInternal
```
protected void mergeChunksInternal(IChunk originalChunk,
                                   IChunk newChunk)
```
    actually do the work or merging newChunk into originalChunk.
    
    Parameters:
    
    originalChunk -
    
    newChunk -
  - dispose
```
public void dispose(IChunk chunk)
```
    schedule this chunk to be disposed, at the module's earliest convenience
    
    Specified by:
    
    dispose in interface IDeclarativeModule
  - deferredEncode
```
protected void deferredEncode(IChunk chunk)
```
    encode this chunk at some later time (top/bottom of the cycle).
    
    Parameters:
    
    chunk -
  - deferredEncode
```
protected void deferredEncode(java.util.Collection<IChunk> chunks)
```
  - willEncode
```
public boolean willEncode(IChunk chunk)
```
    Description copied from interface: IDeclarativeModule
    
    because encoding might be async, we need a method to determine if a given chunk is scheduled for encoding
    
    Specified by:
    
    willEncode in interface IDeclarativeModule
    
    Returns:
  - processPendingEncodingAndDisposals
```
protected void processPendingEncodingAndDisposals()
```
  - processPendingEncodings
```
protected void processPendingEncodings(javolution.util.FastList<IChunk> chunkContainer,
                                       javolution.util.FastList<IActivationBuffer> bufferContainer)
```
  - processPendingDisposals
```
protected void processPendingDisposals(javolution.util.FastList<IChunk> chunkContainer,
                                       javolution.util.FastList<IActivationBuffer> bufferContainer)
```
    called internally at the top & bottom of the cycle and at the end of a run.

Class AbstractDeclarativeModule

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.jactr.core.module.AbstractModule

Methods inherited from class org.jactr.core.utils.DefaultAdaptable

Methods inherited from class java.lang.Object

Methods inherited from interface org.jactr.core.module.declarative.IDeclarativeModule

Methods inherited from interface org.jactr.core.module.IModule

Methods inherited from interface org.jactr.core.utils.IAdaptable

Field Detail

SUSPEND_DISPOSAL_KEY

_activationSorter

Constructor Detail

AbstractDeclarativeModule

Method Detail

setDisposalSuspended

isDisposalSuspended

flush

install

uninstall

initialize

addListener

removeListener

fireChunkCreated

fireChunkTypeCreated

fireChunkAdded

fireChunkRemoved

fireChunkDisposed

fireChunkTypeAdded

fireChunksMerged

fireChunkTypeDisposed

fireChunkTypesMerged

hasListeners

dispatch

getBusyChunk

getEmptyChunk

getErrorChunk

getFreeChunk

getFullChunk

getNewChunk

getRequestedChunk

getUnrequestedChunk

setChunkFactory

getChunkFactory

setSymbolicChunkFactory

getSymbolicChunkFactory

setSubsymbolicChunkFactory

getSubsymbolicChunkFactory

setChunkConfigurator

getChunkConfigurator

setChunkNamer

getChunkNamer

setChunkTypeFactory

getChunkTypeFactory

setSymbolicChunkTypeFactory

getSymbolicChunkTypeFactory

setSubsymbolicChunkTypeFactory

getSubsymbolicChunkTypeFactory

setChunkTypeConfigurator

getChunkTypeConfigurator

setChunkTypeNamer

getChunkTypeNamer

createChunk

createChunkInternal

configure

addChunk

addChunkInternal

copyChunk

copyChunk

copyChunkInternal

getChunk

getChunkInternal

getChunks

getChunksInternal

createChunkType

createChunkType

createChunkTypeInternal

configure

addChunkType