* 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>.

*/

    implements

    InternalWorkingMemoryActions,

    EventSupport,

    ProcessEventManager,

    CorrelationAwareProcessRuntime, ReteooWorkingMemoryInterface, StatefulSession, Externalizable {

    private static final long serialVersionUID = 510l;

    public    byte[] bytes;

    protected int    id;

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

    private NodeMemories nodeMemories;

    protected NamedEntryPoint defaultEntryPoint;

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

    protected GlobalResolver globalResolver;

    protected Calendars   calendars;

    protected DateFormats dateFormats;

    /** The eventSupport */

    protected WorkingMemoryEventSupport workingMemoryEventSupport;

    protected RuleEventListenerSupport ruleEventListenerSupport;

    protected AgendaEventSupport agendaEventSupport;

    protected List __ruleBaseEventListeners;

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

    protected transient InternalRuleBase ruleBase;

    protected FactHandleFactory handleFactory;

    /** Rule-firing agenda. */

    protected InternalAgenda agenda;

    private Queue<WorkingMemoryAction> actionQueue;

    protected AtomicBoolean evaluatingActionQueue;

    protected ReentrantLock lock;

    /**

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

     * EntryPoints

     */

    protected AtomicLong propagationIdCounter;

    private boolean sequential;

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

    protected volatile AtomicBoolean firing;

    private WorkItemManager workItemManager;

    private TimerService timerService;

    protected Map<String, WorkingMemoryEntryPoint> entryPoints;

    protected volatile InternalFactHandle initialFactHandle;

    protected PropagationContextFactory pctxFactory;

    protected SessionConfiguration config;

    private InternalKnowledgeRuntime kruntime;

    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;

    private InternalProcessRuntime processRuntime;

    private transient ObjectMarshallingStrategyStore marshallingStore;

    private transient List                           ruleBaseListeners;

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

    // Constructors

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

    public AbstractWorkingMemory() {

    }

    public AbstractWorkingMemory(final int id,

                                 final InternalRuleBase ruleBase) {

        this(id,

             ruleBase,

             true,

             SessionConfiguration.getDefaultInstance(),

             EnvironmentFactory.newEnvironment());

    }

    /**

     * Construct.

     *

     * @param ruleBase

     *            The backing rule-base.

     */

    public AbstractWorkingMemory(final int id,

                                 final InternalRuleBase ruleBase,

                                 boolean initInitFactHandle,

                                 final SessionConfiguration config,

                                 final Environment environment) {

        this(id,

             ruleBase,

             ruleBase.newFactHandleFactory(),

             initInitFactHandle,

             1,

             config,

             environment,

             new WorkingMemoryEventSupport(),

             new AgendaEventSupport(),

             new RuleEventListenerSupport(),

             null );

    }

    public AbstractWorkingMemory(final int id,

                                 final InternalRuleBase ruleBase,

                                 final FactHandleFactory handleFactory,

                                 final InternalFactHandle initialFactHandle,

                                 final long propagationContext,

                                 final SessionConfiguration config,

                                 final InternalAgenda agenda,

                                 final Environment environment) {

        this(id,

             ruleBase,

             handleFactory,

             false,

             propagationContext,

             config,

             environment,

             new WorkingMemoryEventSupport(),

             new AgendaEventSupport(),

             new RuleEventListenerSupport(),

             agenda);

    }

    public AbstractWorkingMemory(final int id,

                                 final InternalRuleBase ruleBase,

                                 final FactHandleFactory handleFactory,

                                 final boolean initInitFactHandle,

                                 final long propagationContext,

                                 final SessionConfiguration config,

                                 final Environment environment,

                                 final WorkingMemoryEventSupport workingMemoryEventSupport,

                                 final AgendaEventSupport agendaEventSupport,

                                 final RuleEventListenerSupport ruleEventListenerSupport,

                                 final InternalAgenda agenda) {

        this.id = id;

        this.config = config;

        this.ruleBase = ruleBase;

        this.handleFactory = handleFactory;

        this.pctxFactory = ruleBase.getConfiguration().getComponentFactory().getPropagationContextFactory();

        this.environment = environment;

        nodeMemories = new ConcurrentNodeMemories(this.ruleBase);

        actionQueue = new ConcurrentLinkedQueue<WorkingMemoryAction>();

        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.sequential = conf.isSequential();

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

//                                                                  null,

//                                                                  this,

//                                                                  this );

//        } else {

//            this.initialFactHandle = initialFactHandle;

//        }

        this.evaluatingActionQueue = new AtomicBoolean( false );

        this.workingMemoryEventSupport = workingMemoryEventSupport;

        this.agendaEventSupport = agendaEventSupport;

        this.ruleEventListenerSupport = ruleEventListenerSupport;

        this.__ruleBaseEventListeners = new LinkedList();

        this.lock = new ReentrantLock();

        timerService = TimerServiceFactory.getTimerService( this.config );    

        ((AcceptsTimerJobFactoryManager) timerService).setTimerJobFactoryManager( config.getTimerJobFactoryManager() );

        this.propagationIdCounter = new AtomicLong( propagationContext );

        this.firing = new AtomicBoolean( false );

        initTransient();

        this.opCounter = new AtomicLong( 0 );

        this.lastIdleTimestamp = new AtomicLong( -1 );

        if ( agenda == null ) {

            this.agenda = ruleBase.getConfiguration().getComponentFactory().getAgendaFactory().createAgenda(ruleBase);

        }  else {

            this.agenda = agenda;

        }

        this.agenda.setWorkingMemory(this);

        initManagementBeans();

        if ( initInitFactHandle ) {

            initInitialFact(ruleBase, null);

        }

    }

    public void initInitialFact(InternalRuleBase ruleBase, MarshallerReaderContext context) {

        this.initialFactHandle = new DefaultFactHandle(0, InitialFactImpl.getInstance(), 0,  defaultEntryPoint );

        ObjectTypeConf otc = this.defaultEntryPoint.getObjectTypeConfigurationRegistry()

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

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

        final PropagationContext pctx = ctxFact.createPropagationContext(0, PropagationContext.INSERTION, null,

                                                                         null , initialFactHandle, defaultEntryPoint.getEntryPoint(),

                                                                         context );

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

    }

    private void initManagementBeans() {

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

            DroolsManagementAgent.getInstance().registerKnowledgeSession( this );

        }

    }

    private InternalProcessRuntime createProcessRuntime() {

        try {

            return ProcessRuntimeFactory.newProcessRuntime( this );

        } catch ( IllegalArgumentException e ) {

            return null;

        }

    }

    public String getEntryPointId() {

        return EntryPointId.DEFAULT.getEntryPointId();

    }

    public QueryResults getQueryResults(final String queryName,

                                        final Object[] arguments) {

        try {

            startOperation();

            this.lock.lock();

            this.ruleBase.readLock();

            this.ruleBase.executeQueuedActions();

            executeQueuedActions();

            DroolsQuery queryObject = new DroolsQuery( queryName,

                                                       arguments,

                                                       getQueryListenerInstance(),

                                                       false ,

                                                       null,

                                                       null,

                                                       null,

                                                       null,

                                                       null );

            InternalFactHandle handle = this.handleFactory.newFactHandle( queryObject,

                                                                          null,

                                                                          this,

                                                                          this );

            final PropagationContext pCtx = pctxFactory.createPropagationContext(getNextPropagationIdCounter(), PropagationContext.INSERTION,

                                                                                 null, null, handle, getEntryPoint());

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

            List<Map<String, Declaration>> decls = new ArrayList<Map<String, Declaration>>();

            if ( tnodes != null ) {

                for ( BaseNode node : tnodes ) {

                    decls.add( ((QueryTerminalNode) node).getSubRule().getOuterDeclarations() );

                }

            }

            executeQueuedActions();

            this.handleFactory.destroyFactHandle( handle );

            return new QueryResults( (List<QueryRowWithSubruleIndex>) queryObject.getQueryResultCollector().getResults(),

                                     decls.toArray( new Map[decls.size()] ),

                                     this,

                                     ( queryObject.getQuery() != null ) ? queryObject.getQuery().getParameters()  : new Declaration[0] );

        } finally {

            this.ruleBase.readUnlock();

            this.lock.unlock();

            endOperation();

        }

    }

    private InternalViewChangedEventListener getQueryListenerInstance() {

        switch ( this.config.getQueryListenerOption() ) {

            case STANDARD :

                return new StandardQueryViewChangedEventListener();

            case LIGHTWEIGHT :

                return new NonCloningQueryViewListener();

        }

        return null;

    }

    public LiveQuery openLiveQuery(final String query,

                                   final Object[] arguments,

                                   final ViewChangedEventListener listener) {

        try {

            startOperation();

            this.ruleBase.readLock();

            this.lock.lock();

            this.ruleBase.executeQueuedActions();

            executeQueuedActions();

            DroolsQuery queryObject = new DroolsQuery( query,

                                                       arguments,

                                                       new OpenQueryViewChangedEventListenerAdapter( listener ),

                                                       true,

                                                       null,

                                                       null,

                                                       null,

                                                       null,

                                                       null );

            InternalFactHandle handle = this.handleFactory.newFactHandle( queryObject,

                                                                          null,

                                                                          this,

                                                                          this );

            final PropagationContext pCtx = pctxFactory.createPropagationContext(getNextPropagationIdCounter(), PropagationContext.INSERTION,

                                                                                 null, null, handle, getEntryPoint());

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

            executeQueuedActions();

            return new LiveQueryImpl( this,

                                      handle );

        } finally {

            this.lock.unlock();

            this.ruleBase.readUnlock();

            endOperation();

        }

    }

    private BaseNode[] evalQuery(String queryName, DroolsQuery queryObject, InternalFactHandle handle, PropagationContext pCtx) {

        BaseNode[] tnodes = ( BaseNode[] ) ruleBase.getReteooBuilder().getTerminalNodes(queryName);

        if ( tnodes == null ) {

            throw new RuntimeException( "Query '" + queryName + "' does not exist");

        }

        QueryTerminalNode tnode = ( QueryTerminalNode )  tnodes[0];

        LeftTupleSource lts = tnode.getLeftTupleSource();

        while ( lts.getType() != NodeTypeEnums.LeftInputAdapterNode ) {

            lts = lts.getLeftTupleSource();

        }

        LeftInputAdapterNode lian = ( LeftInputAdapterNode ) lts;

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

        SegmentMemory lsmem = lmem.getSegmentMemory();

        if ( lsmem == null ) {

            lsmem = SegmentUtilities.createSegmentMemory(lts, this);

        }

        // TODO this is OTT, it shouldn't need to do this for ALL rules, just those rules that event stream inputs (mdp)

        if( this.ruleBase.getConfiguration().getEventProcessingMode().equals(EventProcessingOption.STREAM) ) {

            lmem.linkNode(this);

            List<PathMemory> pmems =  lmem.getSegmentMemory().getPathMemories();

            PathMemory pmm = pmems!=null && !pmems.isEmpty() ? pmems.get(0) : null;

            if( pmm != null && pmm.getRuleAgendaItem() != null ) {

                RuleAgendaItem item = pmm.getRuleAgendaItem();

                item.getRuleExecutor().reEvaluateNetwork( this, new org.drools.core.util.LinkedList<StackEntry>(), false);

            }

        }

       

        LeftInputAdapterNode.doInsertObject( handle, pCtx, lian, this, lmem, false, queryObject.isOpen() );

       

        List<PathMemory> pmems =  lmem.getSegmentMemory().getPathMemories();

        for ( int i = 0, length = pmems.size(); i < length; i++ ) {

            PathMemory rm = pmems.get( i );

            RuleAgendaItem evaluator = agenda.createRuleAgendaItem(Integer.MAX_VALUE, rm, (TerminalNode) rm.getNetworkNode());

            evaluator.getRuleExecutor().setDirty(true);

            evaluator.getRuleExecutor().evaluateNetworkAndFire(this, null, 0, -1);

        }

        return tnodes;

    }

    public void closeLiveQuery(final InternalFactHandle factHandle) {

        try {

            startOperation();

            this.ruleBase.readLock();

            this.lock.lock();

            final PropagationContext pCtx = pctxFactory.createPropagationContext(getNextPropagationIdCounter(), PropagationContext.INSERTION,

                                                                                 null, null, factHandle, getEntryPoint());

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

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

            SegmentMemory lsmem = lmem.getSegmentMemory();

            LeftTuple childLeftTuple = factHandle.getFirstLeftTuple(); // there is only one, all other LTs are peers

            LeftInputAdapterNode.doDeleteObject( childLeftTuple, childLeftTuple.getPropagationContext(),  lsmem, this, lian, false, lmem );

            List<PathMemory> pmems =  lmem.getSegmentMemory().getPathMemories();

            for ( int i = 0, length = pmems.size(); i < length; i++ ) {

                PathMemory rm = pmems.get( i );

                RuleAgendaItem evaluator = agenda.createRuleAgendaItem(Integer.MAX_VALUE, rm, (TerminalNode) rm.getNetworkNode());

                evaluator.getRuleExecutor().setDirty(true);

                evaluator.getRuleExecutor().evaluateNetworkAndFire(this, null, 0, -1);

            }

            getFactHandleFactory().destroyFactHandle( factHandle );

        } finally {

            this.lock.unlock();

            this.ruleBase.readUnlock();

            endOperation();

        }

    }

    public EntryPointId getEntryPoint() {

        return this.defaultEntryPoint.getEntryPoint();

    }

    public InternalWorkingMemory getInternalWorkingMemory() {

        return this;

    }

    public <T extends org.kie.api.runtime.rule.FactHandle> Collection<T> getFactHandles() {

        List list = new ArrayList();

        for ( Iterator it = iterateFactHandles(); it.hasNext(); ) {

            FactHandle fh = ( FactHandle) it.next();

            list.add(  fh );

        }

        return list;

    }

    public <T extends org.kie.api.runtime.rule.FactHandle> Collection<T> getFactHandles(ObjectFilter filter) {

        throw new UnsupportedOperationException( "this is implementedby StatefulKnowledgeImpl" );

    }

    public Collection<? extends Object> getObjects() {

        throw new UnsupportedOperationException( "this is implementedby StatefulKnowledgeImpl" );

    }

    public Collection<? extends Object> getObjects(ObjectFilter filter) {

        throw new UnsupportedOperationException( "this is implementedby StatefulKnowledgeImpl" );

    }

    public void writeExternal(ObjectOutput out) throws IOException {

        // all we do is create marshall to a byte[] and write to the stream

        StatefulKnowledgeSession ksession = (StatefulKnowledgeSession) getKnowledgeRuntime();

        Marshaller marshaller = MarshallerFactory.newMarshaller(ksession.getKieBase(), new ObjectMarshallingStrategy[]{MarshallerFactory.newSerializeMarshallingStrategy()});

        ByteArrayOutputStream stream = new ByteArrayOutputStream();

        marshaller.marshall( stream, (StatefulKnowledgeSession) getKnowledgeRuntime() );

        stream.close();

        byte[] bytes = stream.toByteArray();

        out.writeInt( bytes.length );

        out.write( bytes );

    }

    public void readExternal(ObjectInput in) throws IOException,

                                            ClassNotFoundException {

        bytes = new byte[ in.readInt() ];

        in.readFully( bytes );

    }

    public List getRuleBaseUpdateListeners() {

        if ( this.ruleBaseListeners == null || this.ruleBaseListeners == Collections.EMPTY_LIST ) {

            String listenerName = this.ruleBase.getConfiguration().getRuleBaseUpdateHandler();

            if ( listenerName != null && listenerName.length() > 0 ) {

                RuleBaseUpdateListener listener = RuleBaseUpdateListenerFactory.createListener(listenerName,

                                                                                               this);

                this.ruleBaseListeners = Collections.singletonList( listener );

            } else {

                this.ruleBaseListeners = Collections.EMPTY_LIST;

            }

        }

        return this.ruleBaseListeners;

    }

    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 updateEntryPointsCache() {

        if (ruleBase.getAddedEntryNodeCache() != null) {

            for (EntryPointNode addedNode : ruleBase.getAddedEntryNodeCache()) {

                EntryPointId id = addedNode.getEntryPoint();

                if (EntryPointId.DEFAULT.equals(id)) continue;

                WorkingMemoryEntryPoint wmEntryPoint = new NamedEntryPoint(id, addedNode, this);

                entryPoints.put(id.getEntryPointId(), wmEntryPoint);

            }

        }

        if (ruleBase.getRemovedEntryNodeCache() != null) {

            for (EntryPointNode removedNode : ruleBase.getRemovedEntryNodeCache()) {

                entryPoints.remove(removedNode.getEntryPoint().getEntryPointId());

            }

        }

    }

    private void initTransient() {

        EntryPointNode epn = this.ruleBase.getRete().getEntryPointNode( EntryPointId.DEFAULT );

        this.defaultEntryPoint = new NamedEntryPoint( EntryPointId.DEFAULT,

                                                      epn,

                                                      this );

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

        this.entryPoints.put( "DEFAULT",

                              this.defaultEntryPoint );

        updateEntryPointsCache();

    }

    public SessionConfiguration getSessionConfiguration() {

        return this.config;

    }

    public void reset() {

        throw new UnsupportedOperationException( "This should not be called" );

    }

    public void reset(int handleId,

                      long handleCounter,

                      long propagationCounter) {

        if (nodeMemories != null) nodeMemories.clear();

        this.agenda.clear();

        for ( WorkingMemoryEntryPoint ep : this.entryPoints.values() ) {

            // clear the state for each entry point

            InternalWorkingMemoryEntryPoint iep = (InternalWorkingMemoryEntryPoint) ep;

            iep.reset();

        }

        this.handleFactory.clear( handleId,

                                  handleCounter );

        if (actionQueue != null) 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 boolean isSequential() {

        return this.sequential;

    }

    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(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 void addEventListener(ProcessEventListener listener) {

        ((ProcessEventManager) this.processRuntime).addEventListener( listener );

    }

    public Collection<ProcessEventListener> getProcessEventListeners() {

        return ((ProcessEventManager) this.processRuntime).getProcessEventListeners();

    }

    public void removeEventListener(ProcessEventListener listener) {

        ((ProcessEventManager) this.processRuntime).removeEventListener( listener );

    }

    ///RuleEventListenerSupport

    public void addEventListener(final RuleEventListener listener) {

        this.ruleEventListenerSupport.addEventListener( listener );

    }

    public void removeEventListener(final RuleEventListener listener) {

        this.ruleEventListenerSupport.removeEventListener( listener );

    }

    public List getRuleEventListeners() {

        return this.ruleEventListenerSupport.getEventListeners();

    }

    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();

            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.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) {

        return this.globalResolver.resolveGlobal( identifier );

    }

    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 {

                startOperation();

                ruleBase.readLock();

                // do we need to call this in advance?

                executeQueuedActions();

                int fireCount = 0;

                fireCount = this.agenda.fireAllRules( agendaFilter,

                                                      fireLimit );

                return fireCount;

            } finally {

                ruleBase.readUnlock();

                endOperation();

                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 org.drools.core.WorkingMemory

     *

     * @param handle

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

     *            <code>Object</code> lookup

     */

    public Object getObject(org.kie.api.runtime.rule.FactHandle handle) {

        // the handle might have been disconnected, so reconnect if it has

        if ( ((InternalFactHandle)handle).isDisconnected() ) {

            handle = this.defaultEntryPoint.getObjectStore().reconnect( handle );

        }       

        return this.defaultEntryPoint.getObject( handle );

    }

    public ObjectStore getObjectStore() {

        return ((InternalWorkingMemoryEntryPoint) this.defaultEntryPoint).getObjectStore();

    }

    /**

     * @see org.drools.core.WorkingMemory

     */

    public FactHandle getFactHandle(final Object object) {

        return this.defaultEntryPoint.getFactHandle( object );

    }

    /**

     * @see org.drools.core.WorkingMemory

     */

    public FactHandle getFactHandleByIdentity(final Object object) {

        return getObjectStore().getHandleForObjectIdentity( object );

    }

    /**

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

     * iteration may give unexpected results

     */

    public Iterator iterateObjects() {

        return getObjectStore().iterateObjects();

    }

    /**

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

     * iteration may give unexpected results

     */

    public Iterator iterateObjects(org.kie.api.runtime.ObjectFilter filter) {

        return getObjectStore().iterateObjects( filter );

    }

    /**

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

     * iteration may give unexpected results

     */

    public Iterator iterateFactHandles() {

        return getObjectStore().iterateFactHandles();

    }

    /**

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

     * iteration may give unexpected results

     */

    public Iterator iterateFactHandles(org.kie.api.runtime.ObjectFilter filter) {

        return getObjectStore().iterateFactHandles( filter );

    }

    public QueryResults getQueryResults(final String query) {

        return getQueryResults( query,

                                null );

    }

    public void setFocus(final String focus) {

        this.agenda.setFocus( focus );

    }

    /**

     * @see WorkingMemory

     */

    public FactHandle insert(final Object object) throws FactException {

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

                       null,

                       false,

                       false,

                       null,

                       null );

    }

    /**

     * @see org.drools.core.WorkingMemory

     */

    public FactHandle insertLogical(final Object object) throws FactException {

        return insert( object, // Not-Dynamic

                       null,

                       false,

                       true,

                       null,

                       null );

    }

    public FactHandle insert(final Object object,

                             final boolean dynamic) throws FactException {

        return insert( object,

                       null,

                       dynamic,

                       false,

                       null,

                       null );

    }

    public FactHandle insertLogical(final Object object,

                                    final boolean dynamic) throws FactException {

        return insert( object,

                       null,

                       dynamic,

                       true,

                       null,

                       null );

    }

    public FactHandle insertLogical(final Object object,

                                    final Object value) throws FactException {

        return insert( object,

                       value,

                       false,

                       true,

                       null,

                       null );

    }

    public FactHandle insert(final Object object,

                             final Object tmsValue,

                             final boolean dynamic,

                             boolean logical,

                             final Rule rule,

                             final Activation activation) throws FactException {

        return this.defaultEntryPoint.insert( object,

                                              tmsValue,

                                              dynamic,

                                              logical,

                                              rule,

                                              activation );

    }

    public void insert(final InternalFactHandle handle,

                       final Object object,

                       final Rule rule,

                       final Activation activation,

                       ObjectTypeConf typeConf) {

        this.defaultEntryPoint.insert( handle,