org.jactr.core.module.declarative

Interface IDeclarativeModule

All Superinterfaces:

IAdaptable, IInitializable, IInstallable, IModule

All Known Subinterfaces:

IDeclarativeModule4, IDeclarativeModule5, IRemovableDeclarativeModule, IVersionedDeclarativeModule

All Known Implementing Classes:

AbstractDeclarativeModule, DefaultDeclarativeModule, DefaultDeclarativeModule6, DefaultVersionedDeclarativeModule, DelegatedDeclarativeModule

public interface IDeclarativeModule
extends IModule

one of two specialized modules, this one handles all declarative memory operations for the model, in particular adding and retrieving of chunks, chunktypes all operation return values are wrapped in Future<> to better support backend concurrencies.
Clients can implement this interface, but should consider extending AbstractDeclarativeModule or DefaultDeclarativeModule. In either case, when the module makes calls to its front facing methods, it should not assume that it is in the installed declarative memory module. Rather it should use IModule.getModel() and IModel.getDeclarativeModule(). This permits the local decM to be wrapped by a delegating one (say to access external database stores).

Author:

developer

See Also:

Future

Method Summary

Modifier and Type	Method and Description
java.util.concurrent.CompletableFuture<IChunk>	addChunk(IChunk chunk) add this chunk to the model and optionally check for duplicates so that it can be merged if necessary
java.util.concurrent.CompletableFuture<IChunkType>	addChunkType(IChunkType chunkType) add the chunktype to the model.
void	addListener(IDeclarativeModuleListener listener, java.util.concurrent.Executor executor)
java.util.concurrent.CompletableFuture<IChunk>	copyChunk(IChunk sourceChunk) return a copy of source chunk
java.util.concurrent.CompletableFuture<IChunk>	copyChunk(IChunk sourceChunk, boolean copySubsymbolics)
java.util.concurrent.CompletableFuture<IChunk>	createChunk(IChunkType parent, java.lang.String name) create a chunk to later be inserted.
java.util.concurrent.CompletableFuture<IChunkType>	createChunkType(java.util.Collection<IChunkType> parents, java.lang.String name) create a new chunktype to be added after its symbolic contents have been set.
java.util.concurrent.CompletableFuture<IChunkType>	createChunkType(IChunkType parent, java.lang.String name)
void	dispose(IChunk chunk) request that this chunk be disposed.
java.util.concurrent.CompletableFuture<java.util.Collection<IChunk>>	findExactMatches(ChunkTypeRequest request, java.util.Comparator<IChunk> sorter, IChunkFilter filter) search DM for all the chunks that match pattern, sorting using sorter, that are above activationThreshold
java.util.concurrent.CompletableFuture<java.util.Collection<IChunk>>	findPartialMatches(ChunkTypeRequest request, java.util.Comparator<IChunk> sorter, IChunkFilter filter) search DM for all the chunks that partially match
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) return the named chunk, case insensitive but preserving
java.util.concurrent.CompletableFuture<java.util.Collection<IChunk>>	getChunks() return all chunks.
java.util.concurrent.CompletableFuture<IChunkType>	getChunkType(java.lang.String name) return the named chunktype.
java.util.concurrent.CompletableFuture<java.util.Collection<IChunkType>>	getChunkTypes() return all the chunk types in this model
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.
long	getNumberOfChunks() return the number of chunks in the model.
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.
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.
void	removeListener(IDeclarativeModuleListener listener)
void	setAssociativeLinkageSystem(IAssociativeLinkageSystem linkageSystem) the code responsible for linking memories.
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 interface org.jactr.core.module.IModule

dispose, getModel, getName, initialize, install, reset

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

uninstall

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

getAdapter

Method Detail

createChunkType

java.util.concurrent.CompletableFuture<IChunkType> createChunkType(java.util.Collection<IChunkType> parents,
                                                                   java.lang.String name)

create a new chunktype to be added after its symbolic contents have been set. typically this will just delegate to the factory methods, but is provided here so that declarative modules can insert custom creators

Parameters:

parent - maybe null

name -

Returns:

createChunkType

java.util.concurrent.CompletableFuture<IChunkType> createChunkType(IChunkType parent,
                                                                   java.lang.String name)

addChunkType

java.util.concurrent.CompletableFuture<IChunkType> addChunkType(IChunkType chunkType)

add the chunktype to the model. this chunktype should have been created by createChunkType(). It will call the IChunkType.encode() method, add this chunktype to the parent's list of children (if there is a parent) and then add it to the internal data stores

Parameters:

chunkType -

Returns:

getChunkType

java.util.concurrent.CompletableFuture<IChunkType> getChunkType(java.lang.String name)

return the named chunktype. Case insensitive, but preserving

Parameters:

name -

Returns:

getChunkTypes

java.util.concurrent.CompletableFuture<java.util.Collection<IChunkType>> getChunkTypes()

return all the chunk types in this model

Returns:

createChunk

java.util.concurrent.CompletableFuture<IChunk> createChunk(IChunkType parent,
                                                           java.lang.String name)

create a chunk to later be inserted.

Parameters:

parent - must not be null (duh)

name -

Returns:

dispose

void dispose(IChunk chunk)

request that this chunk be disposed.

Parameters:

chunk -

getAssociativeLinkageSystem

IAssociativeLinkageSystem getAssociativeLinkageSystem()

code responsible for the setting up and maintaining of associative links, may be null.

Returns:

setAssociativeLinkageSystem

void setAssociativeLinkageSystem(IAssociativeLinkageSystem linkageSystem)

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

Parameters:

linkageSystem -

copyChunk

java.util.concurrent.CompletableFuture<IChunk> copyChunk(IChunk sourceChunk)

return a copy of source chunk

Parameters:

sourceChunk -

Returns:

copyChunk

java.util.concurrent.CompletableFuture<IChunk> copyChunk(IChunk sourceChunk,
                                                         boolean copySubsymbolics)

addChunk

java.util.concurrent.CompletableFuture<IChunk> addChunk(IChunk chunk)

add this chunk to the model and optionally check for duplicates so that it can be merged if necessary

Parameters:

chunk -

checkForDuplicates -

Returns:

a future wrapper of the actual chunk reference that was installed. if the chunk was actually merged, the original chunk is returned

willEncode

boolean willEncode(IChunk chunk)

because encoding might be async, we need a method to determine if a given chunk is scheduled for encoding

Parameters:

chunk -

Returns:

getChunk

java.util.concurrent.CompletableFuture<IChunk> getChunk(java.lang.String name)

return the named chunk, case insensitive but preserving

Parameters:

name -

Returns:

getChunks

java.util.concurrent.CompletableFuture<java.util.Collection<IChunk>> getChunks()

return all chunks. This can be a very expensive operation

Returns:

getNumberOfChunks

long getNumberOfChunks()

return the number of chunks in the model. this might be an estimate

Returns:

findExactMatches

java.util.concurrent.CompletableFuture<java.util.Collection<IChunk>> findExactMatches(ChunkTypeRequest request,
                                                                                      java.util.Comparator<IChunk> sorter,
                                                                                      IChunkFilter filter)

search DM for all the chunks that match pattern, sorting using sorter, that are above activationThreshold

Parameters:

request -

sorter - sort order, may be null

filter - filter function, may be null

Returns:

findPartialMatches

java.util.concurrent.CompletableFuture<java.util.Collection<IChunk>> findPartialMatches(ChunkTypeRequest request,
                                                                                        java.util.Comparator<IChunk> sorter,
                                                                                        IChunkFilter filter)

search DM for all the chunks that partially match

Parameters:

request -

sorter - may be null

filter - TODO

Returns:

getBusyChunk

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.

Returns:

getEmptyChunk

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.

Returns:

getErrorChunk

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.

Returns:

getFreeChunk

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.

Returns:

getFullChunk

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.

Returns:

getNewChunk

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.

Returns:

getRequestedChunk

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.

Returns:

getUnrequestedChunk

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.

Returns:

flush

void flush()

force all pending deferred operations to execute (dispose, encode, etc)

addListener

void addListener(IDeclarativeModuleListener listener,
                 java.util.concurrent.Executor executor)

removeListener

void removeListener(IDeclarativeModuleListener listener)