this.handleFactory.increaseFactHandleRecency( handle );

            Rule rule = activation == null ? null : activation.getRule();

                                                                                               rule, (activation == null) ? null : activation.getTuple(),

                                                                                               handle, entryPoint, mask, modifiedClass, null);

           

            if ( typeConf.isTMSEnabled() ) {

                EqualityKey newKey = tms.get( object );

                EqualityKey oldKey = handle.getEqualityKey();

                if ( newKey == null ) {                   

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

                        // new target key is JUSTFIED, updates are always STATED

                        TruthMaintenanceSystemHelper.removeLogicalDependencies( oldKey.getFactHandle(), propagationContext );

                    }

                   

                    oldKey.removeFactHandle( handle );

                    // If the equality key is now empty, then remove it

                    if ( oldKey.isEmpty() ) {

                        getTruthMaintenanceSystem().remove( oldKey );

                    }                   

                   

                    newKey = new EqualityKey( handle,

                                              EqualityKey.STATED ); // updates are always stated

                    handle.setEqualityKey( newKey );

                    getTruthMaintenanceSystem().put( newKey );

                } else if ( newKey != oldKey ) {

                    oldKey.removeFactHandle( handle );

                    // If the equality key is now empty, then remove it

                    if ( oldKey.isEmpty() ) {

                        getTruthMaintenanceSystem().remove( oldKey );

                    } 

                   

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

                        // new target key is JUSTITIED, updates are always STATED

                        TruthMaintenanceSystemHelper.removeLogicalDependencies( newKey.getFactHandle(), propagationContext );

                        newKey.setStatus( EqualityKey.STATED );

                    }

                    // the caller needs the new handle

                    handle = newKey.getFactHandle();

                } else if ( !updateLogical &&  oldKey.getStatus() == EqualityKey.JUSTIFIED  ) {

                    // new target key is JUSTIFIED, updates are always STATED

                    TruthMaintenanceSystemHelper.removeLogicalDependencies( oldKey.getFactHandle(), propagationContext );                    

                }

            }

            this.entryPointNode.modifyObject( handle,

                                              propagationContext,

                                              typeConf,

                                              this.wm );

           

            this.wm.workingMemoryEventSupport.fireObjectUpdated( propagationContext,

                                                                 handle,

                                                                 originalObject,

                                                                 object,

            if ( activation != null ) {

                // release resources so that they can be GC'ed

                activation.getPropagationContext().releaseResources();

            }

                                                                                               rule, (activation == null) ? null : activation.getTuple(),

                                                                                               handle, this.entryPoint);

            this.entryPointNode.retractObject( handle,

                                               propagationContext,

                                               typeConf,

                                               this.wm );

            if ( typeConf.isTMSEnabled() ) {

                TruthMaintenanceSystem tms = getTruthMaintenanceSystem();

                // TMS.removeLogicalDependency also cleans up Handles from the EqualityKey

                // This can happen on the logical retraction of the last FH, where it's cleaned up in the TMS and also in the main network.

                // However when the user retracts the FH to a logical set of insertions, then we need to clean up the TMS here.

                                                  

                // Update the equality key, which maintains a list of stated FactHandles

                final EqualityKey key = handle.getEqualityKey();

                // Its justified so attempt to remove any logical dependencies for the handle

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

                    TruthMaintenanceSystemHelper.removeLogicalDependencies( handle, propagationContext );

                }

                key.removeFactHandle( handle );

                handle.setEqualityKey( null );

               

                // If the equality key is now empty, then remove it

                if ( key.isEmpty() ) {

                    tms.remove( key );

                }

            }

            if ( handle.isTraiting() && handle.getObject() instanceof TraitProxy ) {

                (( (TraitProxy) handle.getObject() ).getObject()).removeTrait( ( (TraitProxy) handle.getObject() ).getTypeCode() );

            }

           

            this.wm.workingMemoryEventSupport.fireObjectRetracted( propagationContext,

                                                                   handle,

                                                                   object,

        public void execute(InternalWorkingMemory workingMemory) {

            PropagationContextFactory pctxFactory = ((InternalRuleBase) workingMemory.getRuleBase()).getConfiguration().getComponentFactory().getPropagationContextFactory();

                                                                                    this.ruleOrigin, this.leftTuple, this.factHandle);

            ReteooRuleBase ruleBase = (ReteooRuleBase) workingMemory.getRuleBase();

            ruleBase.assertObject( this.factHandle,

                                   this.factHandle.getObject(),

                                   context,

                                   workingMemory );

        }

            if (this.factHandle.isValid()) {

                PropagationContextFactory pctxFactory = ((InternalRuleBase) workingMemory.getRuleBase()).getConfiguration().getComponentFactory().getPropagationContextFactory();

                // if the fact is still in the working memory (since it may have been previously retracted already

                                                                                        null, null, this.factHandle);

                ((EventFactHandle) factHandle).setExpired(true);

                this.node.retractObject(factHandle,

                                        context,

                                        workingMemory);

                // if no activations for this expired event

                if (((EventFactHandle) factHandle).getActivationsCount() == 0) {

                    // remove it from the object store and clean up resources

                    ((EventFactHandle) factHandle).getEntryPoint().retract(factHandle);

                }

            }

        }

                                                   .getObjectTypeConf(this.defaultEntryPoint.entryPoint, this.initialFactHandle.getObject());

        PropagationContextFactory ctxFact = ruleBase.getConfiguration().getComponentFactory().getPropagationContextFactory();

                                                                         null , initialFactHandle, defaultEntryPoint.getEntryPoint(),

                                                                         context );

        otc.getConcreteObjectTypeNode().assertObject(this.initialFactHandle, pctx, this );

    }

                                                                          null,

                                                                          this,

                                                                          this );

                                                                                 null, null, handle, getEntryPoint());

            BaseNode[] tnodes = evalQuery(queryName, queryObject, handle, pCtx);

                                                                          null,

                                                                          this,

                                                                          this );

                                                                                 null, null, handle, getEntryPoint());

            BaseNode[] tnodes = evalQuery(queryObject.getName(), queryObject, handle, pCtx);

            executeQueuedActions();

            startOperation();

            this.ruleBase.readLock();

            this.lock.lock();

                                                                                 null, null, factHandle, getEntryPoint());

            LeftInputAdapterNode lian = ( LeftInputAdapterNode ) factHandle.getFirstLeftTuple().getLeftTupleSink().getLeftTupleSource();

            LiaNodeMemory lmem = (LiaNodeMemory) getNodeMemory( (MemoryFactory) lian);

            SegmentMemory lsmem = lmem.getSegmentMemory();

                                                   .getObjectTypeConf(this.defaultEntryPoint.getEntryPoint(), this.initialFactHandle.getObject());

        PropagationContextFactory ctxFact = kBase.getConfiguration().getComponentFactory().getPropagationContextFactory();

                                                                         null , initialFactHandle, defaultEntryPoint.getEntryPoint(),

                                                                         context );

        otc.getConcreteObjectTypeNode().assertObject(this.initialFactHandle, pctx, this );

    }

                                                                          null,

                                                                          this,

                                                                          this );

                                                                                 null, null, handle, getEntryPoint());

            BaseNode[] tnodes = evalQuery(queryName, queryObject, handle, pCtx);