Iterator.h

// Copyright (C) 1999 Jean-Marc Valin and Dominic Letourneau
#ifndef _ITERATOR_H_
#define _ITERATOR_H_

#include "Network.h"
#include "Collector.h"
#include "BufferedNode.h"

namespace FD {

class InputTranslator : public BufferedNode {

protected:

   int internal_processCount;

public:
   
   InputTranslator (std::string nodeName, ParameterSet params) 
      :BufferedNode(nodeName, params) {
      //nothing to do
      ;
   }
   
   void setProcessCount(int pc) {internal_processCount = pc;}
   
   int  getProcessCount() {return internal_processCount;}
   
   
   virtual void request(int outputID, const ParameterSet &req) 
   {
      if (req.exist("LOOKAHEAD"))
      outputs[outputID].lookAhead = std::max(outputs[outputID].lookAhead,dereference_cast<int> (req.get("LOOKAHEAD")));
   if (req.exist("LOOKBACK"))
      outputs[outputID].lookBack = std::max(outputs[outputID].lookBack,dereference_cast<int> (req.get("LOOKBACK")));
   if (req.exist("INORDER"))
      inOrder = true;

     //handled by BufferedNode
   }
   
   
   virtual ObjectRef getOutput(int output_id, int count) {
     return BufferedNode::getOutput(output_id,internal_processCount);
   }//getOutput
   

   virtual void calculate(int output_id, int count, Buffer &out) {

     int outputID = inputs[output_id].outputID;
     
     //same as the collector's job!
     out[count] = (inputs[output_id].node)->getOutput(outputID,internal_processCount);
   }

   int addInput (const std::string &inputName)
   {
      BufferedNode::addInput(inputName);
      return BufferedNode::addOutput(inputName);
   }

   virtual int translateInput (std::string inputName) {
     for (unsigned int i=0; i< inputs.size(); i++) {
       if (inputs[i].name == inputName) {
         return i;
       }
     }    
     return addInput(inputName);
   }

   virtual int translateOutput (std::string outputName) {
     // Simply call translateInput because it should return
     // the same integer...
     return translateInput(outputName);
   }

   virtual bool hasOutput(int output_id) const {
     return(int(inputs.size()) > output_id);
   }
   
   
   virtual void requestForIterator(const ParameterSet &req) 
   {
      //request propagation to nodes before the iterator
      for (int i=0;i<inputs.size();i++) 
      {
         inputs[i].node->request(inputs[i].outputID,req);
      }
      

   }
   
private:
   
   InputTranslator () {
      throw new NodeException (NULL,"The default constructor should not be called from InputTranslator",__FILE__,__LINE__);
   }
};

class Iterator : public Network {

protected:

   int processCount;
 
public:
   
   Iterator (std::string nodeName, ParameterSet params);
   
   virtual ObjectRef getOutput (int output_id, int count);
   
   virtual void connectToNode(std::string in, Node *inNode, std::string out) {
      if (!inputNode) {
         throw new NodeException(this,std::string("No input node in iterator :") + name, __FILE__,__LINE__);
      }
      connectToNode(inputNode->translateInput(in), inNode, inNode->translateOutput(out));      
   }

   virtual void request(int outputID, const ParameterSet &req) 
   {
      ParameterSet r;
      Collector *col = dynamic_cast<Collector*> (sinkNode);
      if (col)
         col->requestAll(r);
      else
         throw NodeException(this, "Iterator output should be a collector", __FILE__, __LINE__);
      conditionNode->request(0,r);  
      if (translator)
         translator->requestForIterator(req);
   }

   void setConditionNode(Node* aNode) {conditionNode = aNode;}
   
   Node* getConditionNode() {return conditionNode;}

   virtual void initialize();

   virtual void reset();

   virtual void stop();

protected:
   
   virtual void connectToNode(unsigned int in, Node *inNode, unsigned int out);
   
   bool doWhile;

   bool exit_status;

   Node *conditionNode;
   
   InputTranslator *translator;
   
   std::vector<ObjectRef> output;
   
   Iterator() {
      throw new NodeException (NULL,"The default constructor should not be called from Iterator",__FILE__,__LINE__);
   }
   
};

}//namespace FD
#endif

---