NodeList.h

Go to the documentation of this file.

#ifndef NODELIST_H
#define NODELIST_H

#include <vector>
#include <iostream>
#include <iomanip>
#include <string>
#include <time.h>
#include <stdexcept>
#include <fstream>
#include <algorithm>
#include <functional>
#include "Node.h"
#include "lib/StringUtils.h"

void ipause();

class NodeItem {
        public:
                //default constructor
                NodeItem();
                //copy constructor
                NodeItem(const NodeItem &);
                //destructor
                ~NodeItem();
                NodeItem & operator = (const NodeItem &);
                void setName(string n);
                void setNode(const Node &);
                void setNode(const InputNode &);
                void setNode(const OutputNode &);
                void setNode(const BooleanNode &);
                void setNode(const DelayNode &);
                void setNode(const SustainNode &);
                bool removeNode();
                string getName() const {return name;};
                Node & getNode();
                bool hasNode() const;
        protected:
                string name;
        private:
                Node *node;
};


class NodeList {
        public:
                NodeList();
                friend istream &operator >>(istream &in, NodeList &nl);
                void visPrint(ostream &out, NodeList &nl);
                void bitsPrint(NodeList &nl);
                int find(string n);
                int add(NodeItem &i);
                void reset(void);
                void clear(void);
                Node &getNode(int i) {return nodes[i].getNode();};
                NodeItem &getNodeItem(int i) { return nodes[i];}
                Node &getInputNode(int i) {return inputs[i].getNode();};
                string getName(int i) {return nodes[i].getName();};
                NodeList &setRunTime(int r) {runTime = r+1; return *this;};
                int getRunTime() {return runTime;};
                string getRunName() {return runName;};
                NodeList &setTransient(int r) {transient = r; return *this;};
                int getTransient() {return transient;};
                NodeList &setWindow( int w) { window = w; return *this;};
                NodeList &setScalar( int s) { scalar = s; return *this;};
                int getWindow(void) {return window;};
                int getScalar(void) {return scalar;};
                int getNextAnalPt( void );
                void sortAnalPts( void );
                NodeList &printNames(ostream &out);
                void printNodes(ostream &out);
                void printInputs(ostream &out);
                vector<NodeItem> outputs;
                vector<NodeItem> outCalc;
                int inOutCalc( int );
                void inOutInit(void);
                vector<int> inOutIndex;
                int getNodeIndex( string );
                vector <float> avg; // Gong added in 11/11/05 to compute the average value for each Boolean node
                vector < vector<bool> > bits;
                int outCalcSize() {return static_cast<int>(outCalc.size());}
                int getNumOfInputs() {return inputs.size();}
                int outputSize() {return static_cast<int>(outputs.size());};
                int ptsSize() { return analPts.size(); };//rename this more appropriately
                void printAnalPts( void );
                void setMutants( void );
                void setRunName( const string & str ) { runName = str; };
                void setRunDir( const string & str ) { RUNDIR = str;};
                string getRunDir( void ){return RUNDIR;};
                bool readParams(istream &, InputNode &, bool , NodeList & nl );
                void calcAvg( void );
                void printAvg( ostream &);
                void calcCurrAvg( void );
                void printAvgSep( const string & );
                void printDosages( ostream &  );
                void printBits( ostream & );
                void printInputBits( ostream & );
                void initBits( bool);
                void initInputBits( );
                void setNoisyInputs(void) { noisyInputs = true; };
                bool isNoisyInputs(void) { return noisyInputs; };
                void addAnalPt( const int & );
                vector<int> dosageRec;
                vector<int> analPts;
                vector<int> banalPts;
                int avgPeriod;
                int nodeSize() {return static_cast<int>(nodes.size());};
                int getNodeAvg(string, int);
                void setOutputAll(bool b){outputAll=b;};
                string getInputNames(int);
                string getOutNames(int);
                void setInputs(string , int);
                int  getOutLevels(int);
                bool isBool(string);
                void readBools(string);
                void setSimnum(int i){simNumber = i;};
                int getSimnum(void){return simNumber;};
        protected:      
                vector < vector<bool> > inputBits;
                void addOutput(NodeItem &i);
                void addInput(NodeItem &i);
                void addOutCalc(NodeItem &i);// Gong added to compute the average
                void addNode(NodeItem &i);
                void addMutant( Mutant & );
                vector<Mutant> mutants;//tracks mutant nodes
                vector<NodeItem> nodes;//tracks all nodes
                vector<NodeItem> inputs;//tracks input nodes
                int runTime;
                string RUNDIR;
                string runName;
                int transient;
                int window;
                int scalar;
                bool noisyInputs;
                bool outputAll;
                int simNumber;

};
#endif

---