Network.h

// Copyright (C) 1999 Jean-Marc Valin and Dominic Letourneau

#ifndef _NETWORK_H_
#define _NETWORK_H_

#include "Node.h"
#include <map>
#include <string>
#include "NodeFactory.h"
//#include "NodeHeaders.h"
#include "Exception.h"

namespace FD {

//@author Dominic Letourneau & Jean-Marc Valin
//@version 1.0

class Network : public Node {

public:


   Network (std::string nodeName, ParameterSet params);

   ~Network ();
   
   Node* getNodeNamed (const std::string &name);
   
   void addNode (const std::string &factoryName,const std::string &nodeName, const ParameterSet &parameters);
  
   void addNode (Node &node);

   virtual void connect (const std::string &currentNodeName,const std::string &inputName, 
                 const std::string &inputNodeName, const std::string &outputName);
 
   Node* removeNode (const std::string &nodeName);
   
   std::string getName() {return name;}

   void setName(const std::string &my_name) {name = my_name;}

   Node* getSinkNode () {return sinkNode;}

   virtual void setSinkNode (Node* node) {sinkNode = node;} 
 
   Node* getInputNode () {return inputNode;}

   virtual void setInputNode (Node* node) {inputNode = node;}

   virtual std::vector<NodeInput>& getInputs () {
      if (!inputNode) throw new NodeException(this,std::string("No inputNode in :") + getName(),__FILE__,__LINE__);
      return inputNode->getInputs();
   }

   virtual void reset();

   virtual void stop();
   
   virtual void cleanupNotify();
   
   virtual void request(int outputID, const ParameterSet &req) {sinkNode->request(outputID,req);}

   virtual void initialize();

   virtual ObjectRef getOutput (int output_id, int count);

   virtual bool hasOutput (int output_id) const;

   virtual void connectToNode(std::string in, Node *inNode, std::string out);
   
   virtual void verifyConnect();

protected: 

   
   virtual int translateInput (std::string inputName);

   virtual int translateOutput (std::string outputName);
  
   virtual void connectToNode(unsigned int in, Node *inNode, unsigned int out);

   int numNodes;

   std::map<std::string,Node*> nodeDictionary;
   Node *sinkNode;
   Node *inputNode;
 

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

}//namespace FD
#endif

---