src/design.h

   1
   2 #ifndef DESIGN_H
   3 #define DESIGN_H
   4
   5 #include <stdexcept>
   6 #include <list>
   7
   8 namespace yp2 {
   9
  10     class Package;
  11
  12     class Filter {
  13     public:
  14         virtual ~Filter(){};
  15         virtual  Package & process(Package & package) const {
  16             return package;
  17         };
  18         virtual  void configure(){};
  19
  20         // set/get the C++ way .. just as showoff
  21
  22         // get function - returns copy and keeps object const,
  23         // thus is right val in assignment
  24         std::string name() const {
  25             return m_name;
  26         }
  27         // set function - returns reference and changes object,
  28         // thus is left val in assignment
  29         std::string & name() {
  30             return m_name;
  31         }
  32         // more traditional set function, taking const reference
  33         // or copy (here const ref for demo), returning ref to object
  34         // can be chained with other similar functions!
  35         Filter & name(const std::string & name){
  36             m_name = name;
  37             return *this;
  38         }
  39
  40     private:
  41         std::string m_name;
  42     };
  43
  44
  45     class Filter_Exception : public std::runtime_error {
  46     public:
  47         Filter_Exception(const std::string message)
  48             : std::runtime_error("Filter_Exception: " + message){
  49         };
  50     };
  51
  52
  53   class Router {
  54   public:
  55       Router(){};
  56       virtual ~Router(){};
  57       virtual const Filter *
  58           move(const Filter *filter, const Package *package) const {
  59           std::list<const Filter *>::const_iterator it;
  60           it = m_filter_list.begin();
  61           if (filter)
  62           {
  63               for (; it != m_filter_list.end(); it++)
  64                   if (*it == filter)
  65                   {
  66                       it++;
  67                       break;
  68                   }
  69           }
  70           if (it == m_filter_list.end())
  71           {
  72               //throw Router_Exception("no routing rules known");
  73               return 0;
  74           }
  75           return *it;
  76       };
  77       virtual void configure(){};
  78       Router & rule(const Filter &filter){
  79           m_filter_list.push_back(&filter);
  80       return *this;
  81       }
  82   private:
  83       Router(const Router &);
  84       Router& operator=(const Router &);
  85       std::list<const Filter *> m_filter_list;
  86   };
  87
  88
  89   class Router_Exception : public std::runtime_error {
  90   public:
  91       Router_Exception(const std::string message)
  92           : std::runtime_error("Router_Exception: " + message){};
  93   };
  94
  95
  96   class Package {
  97   public:
  98
  99       // send package to it's next filter defined in chain
 100       Package & move() {
 101           m_filter = m_router->move(m_filter, this);
 102           if (m_filter)
 103               return m_filter->process(*this);
 104           else
 105               return *this;
 106           }
 107
 108       // get function - returns copy and keeps object const,
 109       // thus is right val in assignment
 110       unsigned int data() const {
 111           return m_data;
 112       }
 113       // set function - returns reference and changes object,
 114       // thus is left val in assignment
 115       unsigned int & data() {
 116           return m_data;
 117       }
 118
 119       // more traditional set function, taking const reference
 120       // or copy (here const ref for demo), returning ref to object
 121       // can be chained with other similar functions!
 122       Package & data(const unsigned int & data){
 123           m_data = data;
 124           return *this;
 125       }
 126
 127       // get function - returns copy and keeps object const,
 128       // thus is right val in assignment
 129       //Router router() const {
 130       //  return m_router;
 131       //}
 132       // set function - returns reference and changes object,
 133       // thus is left val in assignment
 134       //Router & router() {
 135       //  return m_router;
 136       //}
 137       // more traditional set function, taking const reference
 138       // or copy (here const ref for demo), returning ref to object
 139       // can be chained with other similar functions!
 140       Package & router(const Router &router){
 141           m_filter = 0;
 142           m_router = &router;
 143           return *this;
 144       }
 145       Package() {
 146           m_filter = 0;
 147           m_router = 0;
 148           m_data = 0;
 149       }
 150
 151   private:
 152       unsigned int m_data;
 153       const Filter *m_filter;
 154       const Router *m_router;
 155   };
 156
 157
 158   class Package_Exception : public std::runtime_error {
 159   public:
 160       Package_Exception(const std::string message)
 161           : std::runtime_error("Package_Exception: " + message){
 162       };
 163   };
 164
 165 }
 166
 167 #endif
 168 /*
 169  * Local variables:
 170  * c-basic-offset: 4
 171  * indent-tabs-mode: nil
 172  * End:
 173  * vim: shiftwidth=4 tabstop=8 expandtab
 174  */