Node.h

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

#ifndef _NODE_H_
#define _NODE_H_

#include "Object.h"
#include <string>
#include <map>
#include <vector>
#include "ObjectRef.h"
#include "BaseException.h"
#include <typeinfo>
#include "ParameterSet.h"
#include "NodeFactory.h"

namespace FD {

typedef std::map<std::string, Node*>::value_type nodeEntry;
typedef std::map<std::string, _NodeFactory*>::value_type factoryEntry; 


//must be defined
class Node;

class NodeInput {
public:
   int outputID;
   Node *node;
   std::string name;
   NodeInput(Node *n, int t, const std::string &inputName) :outputID(t),node(n),name(inputName) {}
   NodeInput (const NodeInput &in) {
      node = in.node; 
      outputID = in.outputID;
      name = in.name;
   }
   NodeInput& operator= (const NodeInput &in) {
      if (&in != this)
      {
         node = in.node; 
         outputID = in.outputID; 
         name = in.name;
      }
      return *this;
   }
   NodeInput() : outputID(-1), node(NULL) {} //-1 means unused

   NodeInput(const std::string &inputName) : outputID(-1), node(NULL), name(inputName) {}

private:   
};

class UINode;

class Node : public Object {

   friend class Network;
   friend class Iterator;

protected:
   
   std::string name;

   std::vector<NodeInput> inputs;

   std::vector<std::string> outputNames;

   ParameterSet parameters;

   UINode *uinode;

   virtual void connectToNode(unsigned int in, Node *inputNode, unsigned int out);

   virtual int addOutput (const std::string &outputName);
 
   virtual int addInput (const std::string &inputName);
   

   virtual std::vector<NodeInput>& getInputs () {return inputs;}

public:

   Node(std::string nodeName, const ParameterSet &params);
   

   virtual ~Node() {}

   virtual ObjectRef getOutput(int output_id, int count) = 0; 

   virtual ObjectRef getOutputNamed (const std::string &outputName, int count) {
      return this->getOutput (this->translateOutput(outputName),count);
   }

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

   virtual void initialize ();

   virtual bool hasOutput(int output_id) const;

   ObjectRef getInput(int inputID, int count)
   {
      NodeInput &input = inputs[inputID];
      return input.node->getOutput(input.outputID, count);
   }

   virtual void stop() {}

   virtual void cleanupNotify() {}

   virtual void reset();

   std::string getName() {return name;}
 
   virtual void request(int outputID, const ParameterSet &req)
   {
      for (unsigned int i=0;i<inputs.size();i++)
         inputs[i].node->request(inputs[i].outputID,req);      
   }

   virtual void verifyConnect();

   void printOn(std::ostream &out=std::cout) const;

   void setUINode(UINode *_uinode) {uinode = _uinode;}
   
   static int addFactory (const std::string &factoryName, _NodeFactory* const factory);

   static int addXPM (const std::string &nodeName, char **XPMData);

   static char**  getXPM (const std::string &nodeName);
   
   static _NodeFactory* getFactoryNamed (const std::string &name);

protected:

   Node() {throw new GeneralException("Node Constructor should not be called",__FILE__,__LINE__);}

   virtual int translateInput(std::string inputName);

   virtual int translateOutput(std::string inputName);

   virtual void rt_assert(bool cond, std::string message="", char *_file="unknown", int _line=0);

   virtual void construct_assert(bool cond, std::string message="", char *_file="unknown", int _line=0);

   virtual void throw_error(bool send_ptr, std::string message, char *_file, int _line);

public:
   static std::map<std::string,_NodeFactory*> &factoryDictionary();

   static std::vector<std::string> &nodeInfo();

   static std::map<std::string,char**> &XPMDictionary();

   static int addNodeInfo (const std::string &info);
};





/***************************************************************************/
/*
  NotInitializedException
  Dominic Letourneau
 */
/***************************************************************************/
class NotInitializedException : public BaseException {

public:
   NotInitializedException (std::map<std::string,Node * > aMap) {
      nodeMap = aMap;
   }
   virtual void print(std::ostream &out = std::cerr) {
      out<<"NotInitializedException occured"<<std::endl;
      
      std::map<std::string,Node*>::iterator iter;
      
      for (iter = nodeMap.begin(); iter != nodeMap.end(); iter++) {
         out<<"This node is not initialized: "<<(*iter).first<<std::endl;
      }
   }   

   std::map<std::string,Node*> nodeMap;
};

class NodeException : public BaseException {

public:

   NodeException( Node *_node, std::string _message, char *_file, int _line) 
      : message(_message)
      , node(_node)
      , file(_file)
      , line(_line)
      , frozen(false)
   {}   
   virtual void print(std::ostream &out = std::cerr);

   virtual void freeze();

protected:
   std::string message;

   Node *node;

   std::string file;

   int line;

   bool frozen;

};



#define DECLARE_NODE_XPM(NodeTypeName, XPMFilePtr) int dummy_initializer_for ## NodeTypeName = \
               Node::addFactory (# NodeTypeName, new NodeFactory<NodeTypeName>(# NodeTypeName)) + \
               Node::addXPM (# NodeTypeName, XPMFilePtr);


#define DECLARE_NODE(NodeTypeName) DECLARE_NODE_XPM(NodeTypeName,NULL)


}//namespace FD
#endif

---