package org.drools.reteoo;
/*
* 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.
*/
import org.drools.RuleBaseConfiguration;
import org.drools.common.BaseNode;
import org.drools.common.InternalFactHandle;
import org.drools.common.InternalWorkingMemory;
import org.drools.common.NodeMemory;
import org.drools.common.PropagationContextImpl;
import org.drools.reteoo.builder.BuildContext;
import org.drools.spi.PropagationContext;
import org.drools.util.FactEntry;
import org.drools.util.FactHashTable;
import org.drools.util.Iterator;
/**
* All asserting Facts must propagated into the right <code>ObjectSink</code> side of a BetaNode, if this is the first Pattern
* then there are no BetaNodes to propagate to. <code>LeftInputAdapter</code> is used to adapt an ObjectSink propagation into a
* <code>TupleSource</code> which propagates a <code>ReteTuple</code> suitable fot the right <code>ReteTuple</code> side
* of a <code>BetaNode</code>.
*
* @author <a href="mailto:mark.proctor@jboss.com">Mark Proctor</a>
* @author <a href="mailto:bob@werken.com">Bob McWhirter</a>
*
*/
public class LeftInputAdapterNode extends TupleSource
implements
ObjectSinkNode,
NodeMemory {
/**
*
*/
private static final long serialVersionUID = 400L;
private final ObjectSource objectSource;
private ObjectSinkNode previousObjectSinkNode;
private ObjectSinkNode nextObjectSinkNode;
private boolean objectMemoryEnabled;
/**
* Constructus a LeftInputAdapterNode with a unique id that receives <code>FactHandle</code> from a
* parent <code>ObjectSource</code> and adds it to a given pattern in the resulting Tuples.
*
* @param id
* The unique id of this node in the current Rete network
* @param source
* The parent node, where Facts are propagated from
* @param binder
* An optional binder to filter out propagations. This binder will exist when
* a predicate is used in the first pattern, for instance
*/
public LeftInputAdapterNode(final int id,
final ObjectSource source,
final BuildContext context) {
super( id );
this.objectSource = source;
//this.constraints = constraints;
setObjectMemoryEnabled( false );
}
/* (non-Javadoc)
* @see org.drools.reteoo.BaseNode#attach()
*/
public void attach() {
this.objectSource.addObjectSink( this );
}
public void attach(final InternalWorkingMemory[] workingMemories) {
attach();
for ( int i = 0, length = workingMemories.length; i < length; i++ ) {
final InternalWorkingMemory workingMemory = workingMemories[i];
final PropagationContext propagationContext = new PropagationContextImpl( workingMemory.getNextPropagationIdCounter(),
PropagationContext.RULE_ADDITION,
null,
null );
this.objectSource.updateSink( this,
propagationContext,
workingMemory );
}
}
/**
* Takes the asserted <code>FactHandleImpl</code> received from the <code>ObjectSource</code> and puts it
* in a new <code>ReteTuple</code> before propagating to the <code>TupleSinks</code>
*
* @param handle
* The asserted <code>FactHandle/code>.
* @param context
* The <code>PropagationContext</code> of the <code>WorkingMemory<code> action.
* @param workingMemory
* the <code>WorkingMemory</code> session.
*/
public void assertObject(final InternalFactHandle handle,
final PropagationContext context,
final InternalWorkingMemory workingMemory) {
if ( !workingMemory.isSequential() ) {
this.sink.createAndPropagateAssertTuple( handle,
context,
workingMemory );
if ( this.objectMemoryEnabled ) {
final FactHashTable memory = (FactHashTable) workingMemory.getNodeMemory( this );
memory.add( handle,
false );
}
} else {
workingMemory.addLIANodePropagation( new LIANodePropagation(this, handle, context) );
}
}
/**
* Retract an existing <code>FactHandleImpl</code> by placing it in a new <code>ReteTuple</code> before
* proagating to the <code>TupleSinks</code>
*
* @param handle
* The <code>FactHandle/code> to retract.
* @param context
* The <code>PropagationContext</code> of the <code>WorkingMemory<code> action.
* @param workingMemory
* the <code>WorkingMemory</code> session.
*/
public void retractObject(final InternalFactHandle handle,
final PropagationContext context,
final InternalWorkingMemory workingMemory) {
boolean propagate = true;
if ( this.objectMemoryEnabled ) {
final FactHashTable memory = (FactHashTable) workingMemory.getNodeMemory( this );
propagate = memory.remove( handle );
}
if ( propagate ) {
this.sink.createAndPropagateRetractTuple( handle,
context,
workingMemory );
}
}
public void updateSink(final TupleSink sink,
final PropagationContext context,
final InternalWorkingMemory workingMemory) {
if ( this.objectMemoryEnabled ) {
// We have memory so iterate over all entries
final FactHashTable memory = (FactHashTable) workingMemory.getNodeMemory( this );
final Iterator it = memory.iterator();
for ( FactEntry entry = (FactEntry) it.next(); entry != null; entry = (FactEntry) it.next() ) {
final InternalFactHandle handle = entry.getFactHandle();
sink.assertTuple( new ReteTuple( handle ),
context,
workingMemory );
}
} else {
final ObjectSinkAdapter adapter = new ObjectSinkAdapter( sink );
this.objectSource.updateSink( adapter,
context,
workingMemory );
}
}
public void remove(final BaseNode node,
final InternalWorkingMemory[] workingMemories) {
if ( !node.isInUse() ) {
removeTupleSink( (TupleSink) node );
}
removeShare();
if ( !this.isInUse() ) {
for ( int i = 0, length = workingMemories.length; i < length; i++ ) {
workingMemories[i].clearNodeMemory( this );
}
}
this.objectSource.remove( this,
workingMemories );
}
public boolean isObjectMemoryEnabled() {
return this.objectMemoryEnabled;
}
public void setObjectMemoryEnabled(boolean objectMemoryEnabled) {
this.objectMemoryEnabled = objectMemoryEnabled;
}
/**
* Returns the next node
* @return
* The next ObjectSinkNode
*/
public ObjectSinkNode getNextObjectSinkNode() {
return this.nextObjectSinkNode;
}
/**
* Sets the next node
* @param next
* The next ObjectSinkNode
*/
public void setNextObjectSinkNode(final ObjectSinkNode next) {
this.nextObjectSinkNode = next;
}
/**
* Returns the previous node
* @return
* The previous ObjectSinkNode
*/
public ObjectSinkNode getPreviousObjectSinkNode() {
return this.previousObjectSinkNode;
}
/**
* Sets the previous node
* @param previous
* The previous ObjectSinkNode
*/
public void setPreviousObjectSinkNode(final ObjectSinkNode previous) {
this.previousObjectSinkNode = previous;
}
public int hashCode() {
return this.objectSource.hashCode();
}
public boolean equals(final Object object) {
if ( object == this ) {
return true;
}
if ( object == null || !(object instanceof LeftInputAdapterNode) ) {
return false;
}
final LeftInputAdapterNode other = (LeftInputAdapterNode) object;
return this.objectSource.equals( other.objectSource );
}
public Object createMemory(final RuleBaseConfiguration config) {
return new FactHashTable();
}
/**
* Used with the updateSink method, so that the parent ObjectSource
* can update the TupleSink
* @author mproctor
*
*/
private static class ObjectSinkAdapter
implements
ObjectSink {
private TupleSink sink;
public ObjectSinkAdapter(final TupleSink sink) {
this.sink = sink;
}
public void assertObject(final InternalFactHandle handle,
final PropagationContext context,
final InternalWorkingMemory workingMemory) {
final ReteTuple tuple = new ReteTuple( handle );
this.sink.assertTuple( tuple,
context,
workingMemory );
}
public void modifyObject(final InternalFactHandle handle,
final PropagationContext context,
final InternalWorkingMemory workingMemory) {
throw new UnsupportedOperationException( "ObjectSinkAdapter onlys supports assertObject method calls" );
}
public void retractObject(final InternalFactHandle handle,
final PropagationContext context,
final InternalWorkingMemory workingMemory) {
throw new UnsupportedOperationException( "ObjectSinkAdapter onlys supports assertObject method calls" );
}
public boolean isObjectMemoryEnabled() {
throw new UnsupportedOperationException("ObjectSinkAdapters have no Object memory");
}
public void setObjectMemoryEnabled(boolean objectMemoryEnabled) {
throw new UnsupportedOperationException("ObjectSinkAdapters have no Object memory");
}
}
}