* Copyright 2005 JBoss Inc

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

*      http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

* Implementation of <code>WorkingMemory</code>.

*

* @author <a href="mailto:bob@werken.com">bob mcwhirter </a>

* @author <a href="mailto:mark.proctor@jboss.com">Mark Proctor</a>

* @author <a href="mailto:simon@redhillconsulting.com.au">Simon Harris </a>

*/

    implements

    InternalWorkingMemoryActions,

    EventSupport,

    PropertyChangeListener {

    // ------------------------------------------------------------

    // Constants

    // ------------------------------------------------------------

    protected static final Class[]                               ADD_REMOVE_PROPERTY_CHANGE_LISTENER_ARG_TYPES = new Class[]{PropertyChangeListener.class};

    private static final int                                     NODE_MEMORIES_ARRAY_GROWTH                    = 32;

    // ------------------------------------------------------------

    // Instance members

    // ------------------------------------------------------------

    protected int                                                id;

    /** The arguments used when adding/removing a property change listener. */

    protected Object[]                                           addRemovePropertyChangeListenerArgs;

    /** The actual memory for the <code>JoinNode</code>s. */

    protected NodeMemories                                       nodeMemories;

    protected ObjectStore                                        objectStore;

    /** Global values which are associated with this memory. */

    protected GlobalResolver                                     globalResolver;

    protected Calendars                                          calendars;

    protected DateFormats                                        dateFormats;

    /** The eventSupport */

    protected WorkingMemoryEventSupport                          workingMemoryEventSupport;

    protected AgendaEventSupport                                 agendaEventSupport;

    protected RuleFlowEventSupport                               workflowEventSupport;

    protected List                                               __ruleBaseEventListeners;

    /** The <code>RuleBase</code> with which this memory is associated. */

    protected transient InternalRuleBase                         ruleBase;

    protected FactHandleFactory                                  handleFactory;

    protected TruthMaintenanceSystem                             tms;

    /** Rule-firing agenda. */

    protected InternalAgenda                                     agenda;

    protected Queue<WorkingMemoryAction>                         actionQueue;

    protected AtomicBoolean                                      evaluatingActionQueue;

    protected ReentrantLock                                      lock;

    protected boolean                                            discardOnLogicalOverride;

    /**

     * This must be thread safe as it is incremented and read via different

     * EntryPoints

     */

    protected AtomicLong                                         propagationIdCounter;

    private boolean                                              maintainTms;

    private boolean                                              sequential;

    private List                                                 liaPropagations;

    /** Flag to determine if a rule is currently being fired. */

    protected volatile AtomicBoolean                             firing;

    private ProcessInstanceManager                               processInstanceManager;

    private WorkItemManager                                      workItemManager;

    private TimerManager                                         timerManager;

    private SignalManager                                        signalManager;

    private TimeMachine                                          timeMachine;

    protected transient ObjectTypeConfigurationRegistry          typeConfReg;

    protected EntryPoint                                         entryPoint;

    protected transient EntryPointNode                           entryPointNode;

    protected Map<String, WorkingMemoryEntryPoint>               entryPoints;

    protected InternalFactHandle                                 initialFactHandle;

    protected SessionConfiguration                               config;

    protected PartitionManager                                   partitionManager;

    protected transient AtomicReference<ExternalExecutorService> threadPool                                    = new AtomicReference<ExternalExecutorService>();

    private Map<InternalFactHandle, PropagationContext>          modifyContexts;

    private KnowledgeRuntime                                     kruntime;

    private Map<String, ExitPoint>                               exitPoints;

    private Map<String, Channel>                                 channels;

    private Environment                                          environment;

    private ExecutionResults                                     batchExecutionResult;

    // this is a counter of concurrent operations happening. When this counter is zero,

    // the engine is idle.

    private AtomicLong                                           opCounter;

    // this is the timestamp of the end of the last operation, based on the session clock,

    // or -1 if there are operation being executed at this moment

    private AtomicLong                                           lastIdleTimestamp;

    // ------------------------------------------------------------

    // Constructors

    // ------------------------------------------------------------

    public AbstractWorkingMemory() {

    }

    /**

     * Construct.

     *

     * @param ruleBase

     *            The backing rule-base.

     */

    public AbstractWorkingMemory(final int id,

                                 final InternalRuleBase ruleBase,

                                 final FactHandleFactory handleFactory,

                                 final SessionConfiguration config,

                                 final Environment environment) {

        this( id,

              ruleBase,

              handleFactory,

              null,

              0,

              config,

              environment );

    }

    public AbstractWorkingMemory(final int id,

                                 final InternalRuleBase ruleBase,

                                 final FactHandleFactory handleFactory,

                                 final SessionConfiguration config,

                                 final Environment environment,

                                 final WorkingMemoryEventSupport workingMemoryEventSupport,

                                 final AgendaEventSupport agendaEventSupport,

                                 final RuleFlowEventSupport ruleFlowEventSupport) {

        this( id,

              ruleBase,

              handleFactory,

              null,

              0,

              config,

              environment,

              workingMemoryEventSupport,

              agendaEventSupport,

              ruleFlowEventSupport );

    }

    public AbstractWorkingMemory(final int id,

                                 final InternalRuleBase ruleBase,

                                 final FactHandleFactory handleFactory,

                                 final InternalFactHandle initialFactHandle,

                                 final long propagationContext,

                                 final SessionConfiguration config,

                                 final Environment environment) {

        this( id,

              ruleBase,

              handleFactory,

              initialFactHandle,

              propagationContext,

              config,

              environment,

              new WorkingMemoryEventSupport(),

              new AgendaEventSupport(),

              new RuleFlowEventSupport() );

    }

    public AbstractWorkingMemory(final int id,

                                 final InternalRuleBase ruleBase,

                                 final FactHandleFactory handleFactory,

                                 final InternalFactHandle initialFactHandle,

                                 final long propagationContext,

                                 final SessionConfiguration config,

                                 final Environment environment,

                                 final WorkingMemoryEventSupport workingMemoryEventSupport,

                                 final AgendaEventSupport agendaEventSupport,

                                 final RuleFlowEventSupport ruleFlowEventSupport) {

        this.id = id;

        this.config = config;

        this.ruleBase = ruleBase;

        this.handleFactory = handleFactory;

        this.environment = environment;

        Globals globals = (Globals) this.environment.get( EnvironmentName.GLOBALS );

        if ( globals != null ) {

            if ( !(globals instanceof GlobalResolver) ) {

                this.globalResolver = new GlobalsAdapter( globals );

            } else {

                this.globalResolver = (GlobalResolver) globals;

            }

        } else {

            this.globalResolver = new MapGlobalResolver();

        }

        this.calendars = new CalendarsImpl();

        this.dateFormats = (DateFormats) this.environment.get( EnvironmentName.DATE_FORMATS );

        if ( this.dateFormats == null ) {

            this.dateFormats = new DateFormatsImpl();

            this.environment.set( EnvironmentName.DATE_FORMATS,

                                  this.dateFormats );

        }

        final RuleBaseConfiguration conf = this.ruleBase.getConfiguration();

        this.maintainTms = conf.isMaintainTms();

        this.sequential = conf.isSequential();

        if ( initialFactHandle == null ) {

            this.initialFactHandle = handleFactory.newFactHandle( InitialFactImpl.getInstance(),

                                                                  null,

                                                                  this,

                                                                  this);

        } else {

            this.initialFactHandle = initialFactHandle;

        }

        this.actionQueue = new ConcurrentLinkedQueue<WorkingMemoryAction>();

        this.evaluatingActionQueue = new AtomicBoolean( false );

        this.addRemovePropertyChangeListenerArgs = new Object[]{this};

        this.workingMemoryEventSupport = workingMemoryEventSupport;

        this.agendaEventSupport = agendaEventSupport;

        this.workflowEventSupport = ruleFlowEventSupport;

        this.__ruleBaseEventListeners = new LinkedList();

        this.lock = new ReentrantLock();

        this.liaPropagations = Collections.EMPTY_LIST;

        this.processInstanceManager = config.getProcessInstanceManagerFactory().createProcessInstanceManager( this );

        this.timeMachine = new TimeMachine();

        TimerService timerService = TimerServiceFactory.getTimerService( this.config.getClockType() );

        this.timerManager = new TimerManager( this,

                                              timerService );

        this.signalManager = config.getSignalManagerFactory().createSignalManager( this );

        this.nodeMemories = new ConcurrentNodeMemories( this.ruleBase );

        if ( this.maintainTms ) {

            this.tms = new TruthMaintenanceSystem( this );

        } else {

            this.tms = null;

        }

        this.propagationIdCounter = new AtomicLong( propagationContext );

        this.objectStore = new SingleThreadedObjectStore( conf,

                                                          this.lock );

        // Only takes effect if are using idententity behaviour for assert

        if ( LogicalOverride.DISCARD.equals( conf.getLogicalOverride() ) ) {

            this.discardOnLogicalOverride = true;

        } else {

            this.discardOnLogicalOverride = false;

        }

        initEntryPointsMap();

        this.firing = new AtomicBoolean( false );

        this.modifyContexts = new HashMap<InternalFactHandle, PropagationContext>();

        this.exitPoints = new ConcurrentHashMap<String, ExitPoint>();

        this.channels = new ConcurrentHashMap<String, Channel>();

        initProcessEventListeners();

        initPartitionManagers();

        initTransient();

        this.opCounter = new AtomicLong( 0 );

        this.lastIdleTimestamp = new AtomicLong( -1 );

        initManagementBeans();

        initProcessActivationListener();

    }

    private void initManagementBeans() {

        if ( this.ruleBase.getConfiguration().isMBeansEnabled() ) {

            DroolsManagementAgent.getInstance().registerKnowledgeSession( this );

        }

    }

    public String getEntryPointId() {

        return EntryPoint.DEFAULT.getEntryPointId();

    }

    public static class GlobalsAdapter

        implements

        GlobalResolver {

        private Globals globals;

        public GlobalsAdapter(Globals globals) {

            this.globals = globals;

        }

        public Object resolveGlobal(String identifier) {

            return this.globals.get( identifier );

        }

        public void setGlobal(String identifier,

                              Object value) {

            this.globals.set( identifier,

                              value );

        }

    }

    // ------------------------------------------------------------

    // Instance methods

    // ------------------------------------------------------------

    public void setRuleBase(final InternalRuleBase ruleBase) {

        this.ruleBase = ruleBase;

        this.nodeMemories.setRuleBaseReference( this.ruleBase );

        initTransient();

    }

    private void initEntryPointsMap() {

        this.entryPoints = new ConcurrentHashMap<String, WorkingMemoryEntryPoint>();

        this.entryPoints.put( "DEFAULT",

                              this );

        this.entryPoint = EntryPoint.DEFAULT;

        updateEntryPointsCache();

    }

    public void updateEntryPointsCache() {

        Map<EntryPoint, EntryPointNode> reteEPs = this.ruleBase.getRete().getEntryPointNodes();

        // first create a temporary cache to find which entry points were removed from the network

        Map<String, WorkingMemoryEntryPoint> cache = new HashMap<String, WorkingMemoryEntryPoint>( this.entryPoints );

        // now, add any entry point that was added to the knowledge base

        for ( EntryPointNode entryPointNode : reteEPs.values() ) {

            EntryPoint id = entryPointNode.getEntryPoint();

            cache.remove( id.getEntryPointId() );

            if ( !EntryPoint.DEFAULT.equals( id ) && !this.entryPoints.containsKey( id ) ) {

                WorkingMemoryEntryPoint wmEntryPoint = new NamedEntryPoint( id,

                                                                            entryPointNode,

                                                                            this );

                this.entryPoints.put( entryPointNode.getEntryPoint().getEntryPointId(),

                                      wmEntryPoint );

            }

        }

        // now, if there is any element left in the cache, remove them as they were removed from the network

        this.entryPoints.keySet().removeAll( cache.keySet() );

    }

    /**

     * Creates the actual partition managers and their tasks for multi-thread

     * processing

     */

    private void initPartitionManagers() {

        if ( this.ruleBase.getConfiguration().isMultithreadEvaluation() ) {

            this.partitionManager = new PartitionManager( this );

            for ( RuleBasePartitionId partitionId : this.ruleBase.getPartitionIds() ) {

                this.partitionManager.manage( partitionId );

            }

        }

    }

    /**

     * This method is called to start the multiple partition threads when

     * running in multi-thread mode

     */

    public void startPartitionManagers() {

        startOperation();

        try {

            if ( this.ruleBase.getConfiguration().isMultithreadEvaluation() ) {

                int maxThreads = (this.ruleBase.getConfiguration().getMaxThreads() > 0) ? this.ruleBase.getConfiguration().getMaxThreads() : this.ruleBase.getPartitionIds().size();

                if ( this.threadPool.compareAndSet( null,

                                                    createExecutorService( maxThreads ) ) ) {

                    this.partitionManager.setPool( this.threadPool.get() );

                }

            }

        } finally {

            endOperation();

        }

    }

    private ExternalExecutorService createExecutorService(final int maxThreads) {

        return new ExternalExecutorService( Executors.newFixedThreadPool( maxThreads ) );

    }

    public void stopPartitionManagers() {

        startOperation();

        try {

            if ( this.ruleBase.getConfiguration().isMultithreadEvaluation() ) {

                ExternalExecutorService service = this.threadPool.get();

                if ( this.threadPool.compareAndSet( service,

                                                    null ) ) {

                    service.shutdown();

                    partitionManager.shutdown();

                }

            }

        } finally {

            endOperation();

        }

    }

    public boolean isPartitionManagersActive() {

        return this.threadPool.get() != null;

    }

    private void initTransient() {

        this.entryPointNode = this.ruleBase.getRete().getEntryPointNode( this.entryPoint );

        this.typeConfReg = new ObjectTypeConfigurationRegistry( this.ruleBase );

    }

    public SessionConfiguration getSessionConfiguration() {

        return this.config;

    }

    public void reset(int handleId,

                      long handleCounter,

                      long propagationCounter) {

        this.nodeMemories.clear();

        this.agenda.clear();

        this.objectStore.clear();

        this.handleFactory.clear( handleId,

                                  handleCounter );

        this.tms.clear();

        this.liaPropagations.clear();

        this.actionQueue.clear();

        this.propagationIdCounter = new AtomicLong( propagationCounter );

        this.opCounter.set( 0 );

        this.lastIdleTimestamp.set( -1 );

        // TODO should these be cleared?

        // we probably neeed to do CEP and Flow timers too

        // this.processInstanceManager.clear()

        // this.workItemManager.clear();

    }

    public void setWorkingMemoryEventSupport(WorkingMemoryEventSupport workingMemoryEventSupport) {

        this.workingMemoryEventSupport = workingMemoryEventSupport;

    }

    public void setAgendaEventSupport(AgendaEventSupport agendaEventSupport) {

        this.agendaEventSupport = agendaEventSupport;

    }

    public void setRuleFlowEventSupport(RuleFlowEventSupport ruleFlowEventSupport) {

        this.workflowEventSupport = ruleFlowEventSupport;

    }

    public boolean isSequential() {

        return this.sequential;

    }

    public void addLIANodePropagation(LIANodePropagation liaNodePropagation) {

        if ( this.liaPropagations == Collections.EMPTY_LIST ) {

            this.liaPropagations = new ArrayList();

        }

        this.liaPropagations.add( liaNodePropagation );

    }

    public void addEventListener(final WorkingMemoryEventListener listener) {

        this.workingMemoryEventSupport.addEventListener( listener );

    }

    public void removeEventListener(final WorkingMemoryEventListener listener) {

        this.workingMemoryEventSupport.removeEventListener( listener );

    }

    public List getWorkingMemoryEventListeners() {

        return this.workingMemoryEventSupport.getEventListeners();

    }

    public void addEventListener(final AgendaEventListener listener) {

        this.agendaEventSupport.addEventListener( listener );

    }

    public void removeEventListener(final AgendaEventListener listener) {

        this.agendaEventSupport.removeEventListener( listener );

    }

    public List getAgendaEventListeners() {

        return this.agendaEventSupport.getEventListeners();

    }

    public void addEventListener(final RuleFlowEventListener listener) {

        this.workflowEventSupport.addEventListener( listener );

    }

    public void removeEventListener(final RuleFlowEventListener listener) {

        this.workflowEventSupport.removeEventListener( listener );

    }

    public List getRuleFlowEventListeners() {

        return this.workflowEventSupport.getEventListeners();

    }

    public void addEventListener(RuleBaseEventListener listener) {

        this.ruleBase.addEventListener( listener );

        this.__ruleBaseEventListeners.add( listener );

    }

    public List getRuleBaseEventListeners() {

        return Collections.unmodifiableList( this.__ruleBaseEventListeners );

    }

    public void removeEventListener(RuleBaseEventListener listener) {

        this.ruleBase.removeEventListener( listener );

        this.__ruleBaseEventListeners.remove( listener );

    }

    public FactHandleFactory getFactHandleFactory() {

        return this.handleFactory;

    }

    public void setGlobal(final String identifier,

                          final Object value) {

        // Cannot set null values

        if ( value == null ) {

            return;

        }

        try {

            this.ruleBase.readLock();

            this.lock.lock();

            startOperation();

            // Make sure the global has been declared in the RuleBase

            final Map globalDefintions = this.ruleBase.getGlobals();

            final Class type = (Class) globalDefintions.get( identifier );

            if ( (type == null) ) {

                throw new RuntimeException( "Unexpected global [" + identifier + "]" );

            } else if ( !type.isInstance( value ) ) {

                throw new RuntimeException( "Illegal class for global. " + "Expected [" + type.getName() + "], " + "found [" + value.getClass().getName() + "]." );

            } else {

                this.globalResolver.setGlobal( identifier,

                                               value );

            }

        } finally {

            endOperation();

            this.lock.unlock();

            this.ruleBase.readUnlock();

        }

    }

    public void setGlobalResolver(final GlobalResolver globalResolver) {

        try {

            this.lock.lock();

            this.globalResolver = globalResolver;

        } finally {

            this.lock.unlock();

        }

    }

    public GlobalResolver getGlobalResolver() {

        return this.globalResolver;

    }

    public Calendars getCalendars() {

        return this.calendars;

    }

    public DateFormats getDateFormats() {

        return this.dateFormats;

    }

    public int getId() {

        return this.id;

    }

    public void setId(int id) {

        this.id = id;

    }

    public Object getGlobal(final String identifier) {

        try {

            this.lock.lock();

            return this.globalResolver.resolveGlobal( identifier );

        } finally {

            this.lock.unlock();

        }

    }

    public Environment getEnvironment() {

        return this.environment;

    }

    public Agenda getAgenda() {

        return this.agenda;

    }

    public void clearAgenda() {

        this.agenda.clearAndCancel();

    }

    public void clearAgendaGroup(final String group) {

        this.agenda.clearAndCancelAgendaGroup( group );

    }

    public void clearActivationGroup(final String group) {

        this.agenda.clearAndCancelActivationGroup( group );

    }

    public void clearRuleFlowGroup(final String group) {

        this.agenda.clearAndCancelRuleFlowGroup( group );

    }

    public RuleBase getRuleBase() {

        return this.ruleBase;

    }

    public void halt() {

        this.agenda.halt();

    }

    public int fireAllRules() throws FactException {

        return fireAllRules( null,

                             -1 );

    }

    public int fireAllRules(int fireLimit) throws FactException {

        return fireAllRules( null,

                             fireLimit );

    }

    public int fireAllRules(final AgendaFilter agendaFilter) throws FactException {

        return fireAllRules( agendaFilter,

                             -1 );

    }

    public int fireAllRules(final AgendaFilter agendaFilter,

                            int fireLimit) throws FactException {

        if ( this.firing.compareAndSet( false,

                                        true ) ) {

            try {

                synchronized ( this ) {

                    // If we're already firing a rule, then it'll pick up

                    // the firing for any other assertObject(..) that get

                    // nested inside, avoiding concurrent-modification

                    // exceptions, depending on code paths of the actions.

                    if ( isSequential() ) {

                        for ( Iterator it = this.liaPropagations.iterator(); it.hasNext(); ) {

                            ((LIANodePropagation) it.next()).doPropagation( this );

                        }

                    }

                    // do we need to call this in advance?

                    executeQueuedActions();

                    int fireCount = 0;

                    fireCount = this.agenda.fireAllRules( agendaFilter,

                                                          fireLimit );

                    return fireCount;

                }

            } finally {

                this.firing.set( false );

            }

        }

        return 0;

    }

    /**

     * Keeps firing activations until a halt is called. If in a given moment,

     * there is no activation to fire, it will wait for an activation to be

     * added to an active agenda group or rule flow group.

     *

     * @throws IllegalStateException

     *             if this method is called when running in sequential mode

     */

    public void fireUntilHalt() {

        fireUntilHalt( null );

    }

    /**

     * Keeps firing activations until a halt is called. If in a given moment,

     * there is no activation to fire, it will wait for an activation to be

     * added to an active agenda group or rule flow group.

     *

     * @param agendaFilter

     *            filters the activations that may fire

     *

     * @throws IllegalStateException

     *             if this method is called when running in sequential mode

     */

    public void fireUntilHalt(final AgendaFilter agendaFilter) {

        if ( isSequential() ) {

            throw new IllegalStateException( "fireUntilHalt() can not be called in sequential mode." );

        }

        if ( this.firing.compareAndSet( false,

                                        true ) ) {

            try {

                synchronized ( this ) {

                    executeQueuedActions();

                    this.agenda.fireUntilHalt( agendaFilter );

                }

            } finally {

                this.firing.set( false );

            }

        }

    }

    /**

     * Returns the fact Object for the given <code>FactHandle</code>. It

     * actually attempts to return the value from the handle, before retrieving

     * it from objects map.

     *

     * @see WorkingMemory

     *

     * @param handle

     *            The <code>FactHandle</code> reference for the

     *            <code>Object</code> lookup

     *

     */

    public Object getObject(final org.drools.runtime.rule.FactHandle handle) {

        return this.objectStore.getObjectForHandle( (InternalFactHandle) handle );

    }

    public ObjectStore getObjectStore() {

        return this.objectStore;

    }

    /**

     * @see WorkingMemory

     */

    public FactHandle getFactHandle(final Object object) {

        return this.objectStore.getHandleForObject( object );

    }

    /**

     * @see WorkingMemory

     */

    public FactHandle getFactHandleByIdentity(final Object object) {

        return this.objectStore.getHandleForObjectIdentity( object );

    }

    /**

     * This class is not thread safe, changes to the working memory during

     * iteration may give unexpected results

     */

    public Iterator iterateObjects() {

        return this.objectStore.iterateObjects();

    }

    /**

     * This class is not thread safe, changes to the working memory during

     * iteration may give unexpected results

     */

    public Iterator iterateObjects(org.drools.runtime.ObjectFilter filter) {

        return this.objectStore.iterateObjects( filter );

    }

    /**

     * This class is not thread safe, changes to the working memory during

     * iteration may give unexpected results

     */

    public Iterator iterateFactHandles() {

        return this.objectStore.iterateFactHandles();

    }

    /**

     * This class is not thread safe, changes to the working memory during

     * iteration may give unexpected results

     */

    public Iterator iterateFactHandles(org.drools.runtime.ObjectFilter filter) {

        return this.objectStore.iterateFactHandles( filter );

    }

    public abstract QueryResults getQueryResults(String query);

    public void setFocus(final String focus) {

        this.agenda.setFocus( focus );

    }

    public TruthMaintenanceSystem getTruthMaintenanceSystem() {

        return this.tms;

    }

    /**

     * @see WorkingMemory

     */

    public FactHandle insert(final Object object) throws FactException {

        return insert( object, /* Not-Dynamic */

                       false,

                       false,

                       null,

                       null );

    }

    /**

     * @see WorkingMemory

     */

    public FactHandle insertLogical(final Object object) throws FactException {

        return insert( object, // Not-Dynamic

                       false,

                       true,

                       null,

                       null );

    }

    public FactHandle insert(final Object object,

                             final boolean dynamic) throws FactException {

        return insert( object,

                       dynamic,

                       false,

                       null,

                       null );

    }

    public FactHandle insertLogical(final Object object,

                                    final boolean dynamic) throws FactException {

        return insert( object,

                       dynamic,

                       true,

                       null,

                       null );

    }

    // protected FactHandle insert(final EntryPoint entryPoint,

    // final Object object,

    // final boolean dynamic,

    // boolean logical,

    // final Rule rule,

    // final Activation activation) throws FactException {

    // return this.insert( entryPoint,

    // object,

    // 0,

    // dynamic,

    // logical,

    // rule,

    // activation );

    // }

    public FactHandle insert(final Object object,

                             final boolean dynamic,

                             boolean logical,

                             final Rule rule,

                             final Activation activation) throws FactException {

        if ( object == null ) {

            // you cannot assert a null object

            return null;

        }

        try {

            startOperation();

            ObjectTypeConf typeConf = this.typeConfReg.getObjectTypeConf( this.entryPoint,

                                                                          object );

            InternalFactHandle handle = null;

            if ( isSequential() ) {

                handle = createHandle( object,

                                       typeConf );

                insert( handle,

                        object,

                        rule,

                        activation,

                        typeConf );

                return handle;

            }

            try {

                this.ruleBase.readLock();

                this.lock.lock();

                // check if the object already exists in the WM

                handle = (InternalFactHandle) this.objectStore.getHandleForObject( object );

                if ( this.maintainTms ) {

                    EqualityKey key = null;

                    if ( handle == null ) {

                        // lets see if the object is already logical asserted

                        key = this.tms.get( object );

                    } else {

                        // Object is already asserted, so check and possibly correct its

                        // status and then return the handle

                        key = handle.getEqualityKey();

                        if ( key.getStatus() == EqualityKey.STATED ) {

                            // return null as you cannot justify a stated object.

                            return handle;

                        }

                        if ( !logical ) {

                            // this object was previously justified, so we have to override it to stated

                            key.setStatus( EqualityKey.STATED );

                            this.tms.removeLogicalDependencies( handle );

                        } else {

                            // this was object is already justified, so just add new logical dependency

                            this.tms.addLogicalDependency( handle,

                                                           activation,

                                                           activation.getPropagationContext(),

                                                           rule );

                        }

                        return handle;

                    }

                    // At this point we know the handle is null

                    if ( key == null ) {

                        handle = createHandle( object,

                                               typeConf );

                        key = new EqualityKey( handle );

                        handle.setEqualityKey( key );

                        this.tms.put( key );

                        if ( !logical ) {

                            key.setStatus( EqualityKey.STATED );

                        } else {

                            key.setStatus( EqualityKey.JUSTIFIED );

                            this.tms.addLogicalDependency( handle,

                                                           activation,

                                                           activation.getPropagationContext(),

                                                           rule );

                        }

                    } else if ( !logical ) {

                        if ( key.getStatus() == EqualityKey.JUSTIFIED ) {

                            // Its previous justified, so switch to stated and remove logical dependencies

                            final InternalFactHandle justifiedHandle = key.getFactHandle();

                            this.tms.removeLogicalDependencies( justifiedHandle );

                            if ( this.discardOnLogicalOverride ) {

                                // override, setting to new instance, and return

                                // existing handle

                                key.setStatus( EqualityKey.STATED );

                                handle = key.getFactHandle();

                                if ( AssertBehaviour.IDENTITY.equals( this.ruleBase.getConfiguration().getAssertBehaviour() ) ) {

                                    // as assertMap may be using an "identity"

                                    // equality comparator,

                                    // we need to remove the handle from the map,

                                    // before replacing the object

                                    // and then re-add the handle. Otherwise we may

                                    // end up with a leak.

                                    this.objectStore.updateHandle( handle,

                                                                   object );

                                } else {

                                    Object oldObject = handle.getObject();

                                }

                                return handle;

                            } else {

                                // override, then instantiate new handle for

                                // assertion

                                key.setStatus( EqualityKey.STATED );

                                handle = createHandle( object,

                                                       typeConf );

                                handle.setEqualityKey( key );

                                key.addFactHandle( handle );

                            }

                        } else {

                            handle = createHandle( object,

                                                   typeConf );

                            key.addFactHandle( handle );

                            handle.setEqualityKey( key );

                        }

                    } else {

                        if ( key.getStatus() == EqualityKey.JUSTIFIED ) {

                            // only add as logical dependency if this wasn't previously stated

                            this.tms.addLogicalDependency( key.getFactHandle(),

                                                           activation,

                                                           activation.getPropagationContext(),

                                                           rule );

                            return key.getFactHandle();