How to use

getFirst

method

in

org.drools.core.util.LinkedList

@Test
public void testGetFirst() {
  assertNull( "Empty list should return null on getFirst()",
            this.list.getFirst() );
  this.list.add( this.node1 );
  assertSame( "List should return node1 on getFirst()",
            this.list.getFirst(),
            this.node1 );
  this.list.add( this.node2 );
  assertSame( "List should return node1 on getFirst()",
            this.list.getFirst(),
            this.node1 );
  this.list.add( this.node3 );
  assertSame( "List should return node1 on getFirst()",
            this.list.getFirst(),
            this.node1 );
}

  protected BetaNodeFieldConstraint[] convertToConstraints(LinkedList list) {
    final BetaNodeFieldConstraint[] array = new BetaNodeFieldConstraint[list.size()];
    int i = 0;
    for ( LinkedListEntry entry = (LinkedListEntry) list.getFirst(); entry != null; entry = (LinkedListEntry) entry.getNext() ) {
      array[i++] = (BetaNodeFieldConstraint) entry.getObject();
    }
    return array;
  }
}

@Test
public void testRemoveFirst() {
  this.list.add( this.node1 );
  this.list.add( this.node2 );
  this.list.add( this.node3 );
  assertSame( "List should return node1 on getFirst()",
            this.list.getFirst(),
            this.node1 );
  this.list.removeFirst();
  assertSame( "List should return node2 on getFirst()",
            this.list.getFirst(),
            this.node2 );
  this.list.removeFirst();
  assertSame( "List should return node3 on getFirst()",
            this.list.getFirst(),
            this.node3 );
  this.list.removeFirst();
  assertNull( "Empty list should return null on getFirst()",
            this.list.getFirst() );
}

public JavaUtilIterator(final LinkedList list,
            final boolean immutable) {
  this.list = list;
  this.nextNode = this.list.getFirst();
  this.immutable = immutable;
}

private FieldIndex findFieldIndex(final int index) {
  for ( FieldIndex node = this.hashedFieldIndexes.getFirst(); node != null; node = node.getNext() ) {
    if ( node.getIndex() == index ) {
      return node;
    }
  }
  return null;
}

public Activation[] getScheduledActivations() {
  Activation[] scheduledActivations = new Activation[this.scheduledActivations.size()];
  int i = 0;
  for ( ScheduledAgendaItem node = this.scheduledActivations.getFirst(); node != null; node = node.getNext() ) {
    scheduledActivations[i++] = node;
  }
  return scheduledActivations;
}

          this.node1.getNext() );
assertSame( "First node should be node1",
          this.list.getFirst(),
          this.node1 );
assertSame( "Last node should be node1",
          this.node1 );
assertSame( "First node should be node1",
          this.list.getFirst(),
          this.node1 );
assertSame( "Last node should be node2",
           3 );
assertSame( "First node should be node1",
          this.list.getFirst(),
          this.node1 );
assertSame( "Last node should be node3",

LeftTuple deleteFirst = memory.getSegmentMemory().getStagedLeftTuples().getDeleteFirst();
if ( segmentMemory.getRootNode() instanceof JoinNode ) {
  BetaMemory bm = (BetaMemory) segmentMemory.getNodeMemories().getFirst();
  assertEquals( 0, bm.getLeftTupleMemory().size() );

/**
 * An Activation is no longer true so it no longer justifies  any  of the logical facts
 * it logically  asserted. It iterates  over the Activation's LinkedList of DependencyNodes
 * it retrieves the justitication  set for each  DependencyNode's FactHandle and  removes
 * itself. If the Set is empty it retracts the FactHandle from the WorkingMemory.
 *
 * @param activation
 * @param context
 * @param rule
 * @throws FactException
 */
public void removeLogicalDependencies(final Activation activation,
                   final PropagationContext context,
                   final Rule rule) throws FactException {
  final LinkedList<LogicalDependency> list = activation.getLogicalDependencies();
  if ( list == null || list.isEmpty() ) {
    return;
  }
  for ( LogicalDependency node = list.getFirst(); node != null; node = node.getNext() ) {
    removeLogicalDependency( activation, node, context );
  }
}

public void removeAllBlockersAndBlocked(DefaultAgenda agenda){
  if ( this.blockers != null ) {
    // Iterate and remove this node's logical dependency list from each of it's blockers
    for ( LinkedListEntry<LogicalDependency> node = blockers.getFirst(); node != null; node = node.getNext() ) {
      LogicalDependency dep = node.getObject();
      dep.getJustifier().getBlocked().remove( dep );                
    }
  }  
  this.blockers = null;
  
  if ( this.blocked != null ) {
    // Iterate and remove this node's logical dependency list from each of it's blocked
    for ( LogicalDependency dep = blocked.getFirst(); dep != null; ) {
      LogicalDependency tmp = dep.getNext();
      removeBlocked( dep );
      AgendaItem justified = ( AgendaItem ) dep.getJustified();
      if ( justified.getBlockers().isEmpty() && justified.isActivated() ) {
        // the match is no longer blocked, so stage it
        agenda.getStageActivationsGroup().addActivation( justified );
      }                
      dep = tmp;
    }
  }
  this.blocked = null;
}

public void cancelRemainingPreviousLogicalDependencies() {
  if ( this.previousJustified != null ) {
    for ( LogicalDependency dep = (LogicalDependency) this.previousJustified.getFirst(); dep != null; dep = (LogicalDependency) dep.getNext() ) {
      this.workingMemory.getTruthMaintenanceSystem().removeLogicalDependency( activation, dep, activation.getPropagationContext() );
    }
  }
  if ( this.previousBlocked != null ) {
    for ( LogicalDependency dep = this.previousBlocked.getFirst(); dep != null; ) {
      LogicalDependency tmp = dep.getNext();
      this.previousBlocked.remove( dep );
      AgendaItem justified = ( AgendaItem ) dep.getJustified();
      justified.getBlockers().remove( dep.getJustifierEntry() );
      if (justified.getBlockers().isEmpty() ) {
        // the match is no longer blocked, so stage it
        ((DefaultAgenda)workingMemory.getAgenda()).getStageActivationsGroup().addActivation( justified );
      }
      dep = tmp;
    }
  }
}

public void evaluate(KnowledgeHelper knowledgeHelper,
           WorkingMemory workingMemory) {
  LinkedList< LogicalDependency<M>> list = ((DefaultKnowledgeHelper)knowledgeHelper).getpreviousJustified();
  if ( list != null ) {
    for ( SimpleLogicalDependency dep = ( SimpleLogicalDependency ) list.getFirst(); dep != null; dep =  ( SimpleLogicalDependency ) dep.getNext() ){
      knowledgeHelper.insertLogical( dep.getObject(), dep.getMode() );
    }
  }
}

public void evaluate(KnowledgeHelper knowledgeHelper,
           WorkingMemory workingMemory) {
  LinkedList< LogicalDependency<M>> list = ((DefaultKnowledgeHelper)knowledgeHelper).getpreviousJustified();
  if ( list != null ) {
    for ( SimpleLogicalDependency dep = ( SimpleLogicalDependency ) list.getFirst(); dep != null; dep =  ( SimpleLogicalDependency ) dep.getNext() ){
      knowledgeHelper.insertLogical( dep.getObject(), dep.getMode() );
    }
  }
}

public void evaluate(KnowledgeHelper knowledgeHelper,
           WorkingMemory workingMemory) {
  LinkedList< LogicalDependency<M>> list = ((DefaultKnowledgeHelper)knowledgeHelper).getpreviousJustified();
  if ( list != null ) {
    for ( SimpleLogicalDependency dep = ( SimpleLogicalDependency ) list.getFirst(); dep != null; dep =  ( SimpleLogicalDependency ) dep.getNext() ){
      knowledgeHelper.insertLogical( dep.getObject(), dep.getMode()  );
    }
  }
}

public void evaluate(KnowledgeHelper knowledgeHelper,
           WorkingMemory workingMemory) {
  LinkedList< LogicalDependency<M>> list = ((DefaultKnowledgeHelper)knowledgeHelper).getpreviousJustified();
  if ( list != null ) {
    for ( SimpleLogicalDependency dep = ( SimpleLogicalDependency ) list.getFirst(); dep != null; dep =  ( SimpleLogicalDependency ) dep.getNext() ){
      knowledgeHelper.insertLogical( dep.getObject(), dep.getMode() );
    }
  }
}

public void evaluate(KnowledgeHelper knowledgeHelper,
           WorkingMemory workingMemory) {
  LinkedList<LogicalDependency<M>> list = ((DefaultKnowledgeHelper) knowledgeHelper).getpreviousJustified();
  if (list != null) {
    for (SimpleLogicalDependency dep = (SimpleLogicalDependency ) list.getFirst(); dep != null; dep =  ( SimpleLogicalDependency ) dep.getNext() ){
      knowledgeHelper.insertLogical( dep.getObject(), dep.getMode() );
    }
  }
}

public void evaluate(KnowledgeHelper knowledgeHelper,
           WorkingMemory workingMemory) {
  LinkedList< LogicalDependency<M>> list = ((DefaultKnowledgeHelper)knowledgeHelper).getpreviousJustified();
  if ( list != null ) {
    for ( SimpleLogicalDependency dep = ( SimpleLogicalDependency ) list.getFirst(); dep != null; dep =  ( SimpleLogicalDependency ) dep.getNext() ){
      knowledgeHelper.insertLogical( dep.getObject(), dep.getMode() );
    }
  }
}

public void evaluate(KnowledgeHelper knowledgeHelper,
           WorkingMemory workingMemory) {
  LinkedList< LogicalDependency<M>> list = ((DefaultKnowledgeHelper)knowledgeHelper).getpreviousJustified();
  if ( list != null ) {
    for ( SimpleLogicalDependency dep = ( SimpleLogicalDependency ) list.getFirst(); dep != null; dep =  ( SimpleLogicalDependency ) dep.getNext() ){
      knowledgeHelper.insertLogical( dep.getObject(), dep.getMode() );
    }
  }
}

public void unblockAllActivations(org.drools.runtime.rule.Activation act) {
  AgendaItem targetMatch = ( AgendaItem ) act;
  boolean wasBlocked = (targetMatch.getBlockers() != null && !targetMatch.getBlockers().isEmpty() );
  for ( LinkedListEntry entry = ( LinkedListEntry ) targetMatch.getBlockers().getFirst(); entry != null;  ) {
    LinkedListEntry tmp = ( LinkedListEntry ) entry.getNext();
    LogicalDependency dep = ( LogicalDependency ) entry.getObject();
    ((AgendaItem)dep.getJustifier()).removeBlocked( dep );
    entry = tmp;
  }
  if ( wasBlocked ) {
    // the match is no longer blocked, so stage it
    ((DefaultAgenda)workingMemory.getAgenda()).getStageActivationsGroup().addActivation( targetMatch );
  }
}

public void addBlocked(final LogicalDependency dep) {
  // Adds the blocked to the blockers list
  if ( this.blocked == null ) {
    this.blocked = new LinkedList<LogicalDependency>();
  }
  this.blocked.add( dep );
  // now ad the blocker to the blocked's list - we need to check that references are null first
  AgendaItem blocked = (AgendaItem)dep.getJustified();
  if ( blocked.blockers == null ) {
    blocked.blockers = new LinkedList<LinkedListEntry<LogicalDependency>>();
    blocked.blockers.add( dep.getJustifierEntry() );
  } else if ( dep.getJustifierEntry().getNext() == null && dep.getJustifierEntry().getPrevious() == null && blocked.getBlockers().getFirst() != dep.getJustifierEntry() ) {
    blocked.blockers.add( dep.getJustifierEntry() );
  }
}