Package org.drools.core.impl

Interface RuleBase

All Known Implementing Classes:

KnowledgeBaseImpl

public interface RuleBase

Method Summary

Modifier and Type	Method	Description
void	addGlobal(String identifier, Type type)
Future<org.kie.api.definition.KiePackage>	addPackage(org.kie.api.definition.KiePackage pkg)
void	addPackages(Collection<? extends org.kie.api.definition.KiePackage> newPkgs)
void	addProcess(org.kie.api.definition.process.Process process)
void	addReceiveNode(AsyncReceiveNode node)
void	addRules(Collection<RuleImpl> rules)
default void	afterIncrementalUpdate(KieBaseUpdate kieBaseUpdate)
default void	beforeIncrementalUpdate(KieBaseUpdate kieBaseUpdate)
RuleBasePartitionId	createNewPartitionId()
SegmentMemory	createSegmentFromPrototype(ReteEvaluator reteEvaluatorm, LeftTupleSource tupleSource)
void	executeQueuedActions()
Set<EntryPointNode>	getAddedEntryNodeCache()
ClassFieldAccessorCache	getClassFieldAccessorCache()
RuleBaseConfiguration	getConfiguration()
String	getContainerId()
Set<String>	getEntryPointIds()
TypeDeclaration	getExactTypeDeclaration(Class<?> clazz)
org.kie.api.definition.type.FactType	getFactType(String packageName, String typeName)
Map<String,Type>	getGlobals()
String	getId()
org.kie.api.definition.KiePackage	getKiePackage(String packageName)
Collection<org.kie.api.definition.KiePackage>	getKiePackages()
int	getMemoryCount()
int	getNodeCount()
TypeDeclaration	getOrCreateExactTypeDeclaration(Class<?> clazz)
InternalKnowledgePackage	getPackage(String name)
InternalKnowledgePackage[]	getPackages()
Map<String,InternalKnowledgePackage>	getPackagesMap()
org.kie.api.definition.process.Process	getProcess(String processId)
Collection<org.kie.api.definition.process.Process>	getProcesses()
org.kie.api.definition.rule.Query	getQuery(String packageName, String queryName)
List<AsyncReceiveNode>	getReceiveNodes()
Set<EntryPointNode>	getRemovedEntryNodeCache()
org.kie.api.builder.ReleaseId	getResolvedReleaseId()
Rete	getRete()
ReteooBuilder	getReteooBuilder()
ClassLoader	getRootClassLoader()
org.kie.api.definition.rule.Rule	getRule(String packageName, String ruleName)
RuleUnitDescriptionRegistry	getRuleUnitDescriptionRegistry()
SegmentMemory.Prototype	getSegmentPrototype(SegmentMemory segment)
SessionConfiguration	getSessionConfiguration()
TypeDeclaration	getTypeDeclaration(Class<?> clazz)
Collection<TypeDeclaration>	getTypeDeclarations()
default int	getWorkingMemoryCounter()
boolean	hasMultipleAgendaGroups()
boolean	hasSegmentPrototypes()
boolean	hasUnits()
void	invalidateSegmentPrototype(LeftTupleNode rootNode)
FactHandleFactory	newFactHandleFactory()
FactHandleFactory	newFactHandleFactory(long id, long counter)
void	processAllTypesDeclaration(Collection<InternalKnowledgePackage> pkgs)
void	readLock()
void	readUnlock()
void	registerAddedEntryNodeCache(EntryPointNode node)
Class<?>	registerAndLoadTypeDefinition(String className, byte[] def)
void	registeRremovedEntryNodeCache(EntryPointNode node)
void	registerSegmentPrototype(LeftTupleSource tupleSource, SegmentMemory smem)
void	registerTypeDeclaration(TypeDeclaration newDecl, InternalKnowledgePackage newPkg)
void	removeFunction(String packageName, String functionName)
void	removeGlobal(String identifier)
void	removeKiePackage(String packageName)
boolean	removeObjectsGeneratedFromResource(org.kie.api.io.Resource resource, Collection<InternalWorkingMemory> workingMemories)
void	removeProcess(String processId)
void	removeQuery(String packageName, String queryName)
void	removeRule(String packageName, String ruleName)
void	removeRules(Collection<RuleImpl> rules)
void	setContainerId(String containerId)
void	setResolvedReleaseId(org.kie.api.builder.ReleaseId currentReleaseId)

Method Detail

getKiePackages

Collection<org.kie.api.definition.KiePackage> getKiePackages()

getKiePackage

org.kie.api.definition.KiePackage getKiePackage(String packageName)

removeKiePackage

void removeKiePackage(String packageName)

getRule

org.kie.api.definition.rule.Rule getRule(String packageName,
                                         String ruleName)

removeRule

void removeRule(String packageName,
                String ruleName)

getQuery

org.kie.api.definition.rule.Query getQuery(String packageName,
                                           String queryName)

removeQuery

void removeQuery(String packageName,
                 String queryName)

removeFunction

void removeFunction(String packageName,
                    String functionName)

getFactType

org.kie.api.definition.type.FactType getFactType(String packageName,
                                                 String typeName)

getProcess

org.kie.api.definition.process.Process getProcess(String processId)

getProcesses

Collection<org.kie.api.definition.process.Process> getProcesses()

addProcess

void addProcess(org.kie.api.definition.process.Process process)

removeProcess

void removeProcess(String processId)

getEntryPointIds

Set<String> getEntryPointIds()

getId

String getId()

createNewPartitionId

RuleBasePartitionId createNewPartitionId()

getConfiguration

RuleBaseConfiguration getConfiguration()

readLock

void readLock()

readUnlock

void readUnlock()

newFactHandleFactory

FactHandleFactory newFactHandleFactory()

newFactHandleFactory

FactHandleFactory newFactHandleFactory(long id,
                                       long counter)
                                throws IOException

Throws:

IOException

getGlobals

Map<String,Type> getGlobals()

getNodeCount

int getNodeCount()

getMemoryCount

int getMemoryCount()

executeQueuedActions

void executeQueuedActions()

getReteooBuilder

ReteooBuilder getReteooBuilder()

registerAddedEntryNodeCache

void registerAddedEntryNodeCache(EntryPointNode node)

getAddedEntryNodeCache

Set<EntryPointNode> getAddedEntryNodeCache()

registeRremovedEntryNodeCache

void registeRremovedEntryNodeCache(EntryPointNode node)

getRemovedEntryNodeCache

Set<EntryPointNode> getRemovedEntryNodeCache()

getRete

Rete getRete()

getRootClassLoader

ClassLoader getRootClassLoader()

registerAndLoadTypeDefinition

Class<?> registerAndLoadTypeDefinition(String className,
                                       byte[] def)
                                throws ClassNotFoundException

Throws:

ClassNotFoundException

getPackages

InternalKnowledgePackage[] getPackages()

getPackage

InternalKnowledgePackage getPackage(String name)

addPackage

Future<org.kie.api.definition.KiePackage> addPackage(org.kie.api.definition.KiePackage pkg)

addPackages

void addPackages(Collection<? extends org.kie.api.definition.KiePackage> newPkgs)

getPackagesMap

Map<String,InternalKnowledgePackage> getPackagesMap()

getClassFieldAccessorCache

ClassFieldAccessorCache getClassFieldAccessorCache()

hasSegmentPrototypes

boolean hasSegmentPrototypes()

invalidateSegmentPrototype

void invalidateSegmentPrototype(LeftTupleNode rootNode)

createSegmentFromPrototype

SegmentMemory createSegmentFromPrototype(ReteEvaluator reteEvaluatorm,
                                         LeftTupleSource tupleSource)

getSegmentPrototype

SegmentMemory.Prototype getSegmentPrototype(SegmentMemory segment)

processAllTypesDeclaration

void processAllTypesDeclaration(Collection<InternalKnowledgePackage> pkgs)

addRules

void addRules(Collection<RuleImpl> rules)
       throws InvalidPatternException

Throws:

InvalidPatternException

removeRules

void removeRules(Collection<RuleImpl> rules)
          throws InvalidPatternException

Throws:

InvalidPatternException

beforeIncrementalUpdate

default void beforeIncrementalUpdate(KieBaseUpdate kieBaseUpdate)

afterIncrementalUpdate

default void afterIncrementalUpdate(KieBaseUpdate kieBaseUpdate)

addGlobal

void addGlobal(String identifier,
               Type type)

removeGlobal

void removeGlobal(String identifier)

removeObjectsGeneratedFromResource

boolean removeObjectsGeneratedFromResource(org.kie.api.io.Resource resource,
                                           Collection<InternalWorkingMemory> workingMemories)

getTypeDeclaration

TypeDeclaration getTypeDeclaration(Class<?> clazz)

getExactTypeDeclaration

TypeDeclaration getExactTypeDeclaration(Class<?> clazz)

getOrCreateExactTypeDeclaration

TypeDeclaration getOrCreateExactTypeDeclaration(Class<?> clazz)

getTypeDeclarations

Collection<TypeDeclaration> getTypeDeclarations()

registerTypeDeclaration

void registerTypeDeclaration(TypeDeclaration newDecl,
                             InternalKnowledgePackage newPkg)

getResolvedReleaseId

org.kie.api.builder.ReleaseId getResolvedReleaseId()

setResolvedReleaseId

void setResolvedReleaseId(org.kie.api.builder.ReleaseId currentReleaseId)

getContainerId

String getContainerId()

setContainerId

void setContainerId(String containerId)

getRuleUnitDescriptionRegistry

RuleUnitDescriptionRegistry getRuleUnitDescriptionRegistry()

hasUnits

boolean hasUnits()

getSessionConfiguration

SessionConfiguration getSessionConfiguration()

getReceiveNodes

List<AsyncReceiveNode> getReceiveNodes()

addReceiveNode

void addReceiveNode(AsyncReceiveNode node)

hasMultipleAgendaGroups

boolean hasMultipleAgendaGroups()

getWorkingMemoryCounter

default int getWorkingMemoryCounter()

registerSegmentPrototype

void registerSegmentPrototype(LeftTupleSource tupleSource,
                              SegmentMemory smem)