src/router.hpp

   1
   2 #ifndef ROUTER_HPP
   3 #define ROUTER_HPP
   4
   5 #include <stdexcept>
   6 #include <list>
   7
   8 namespace yp2 {
   9     namespace filter {
  10         class Base;
  11     }
  12     class Package;
  13
  14     class RouterException : public std::runtime_error {
  15     public:
  16         RouterException(const std::string message)
  17             : std::runtime_error("RouterException: " + message){};
  18     };
  19
  20
  21     class Router {
  22     public:
  23         Router(){};
  24         virtual ~Router(){};
  25
  26         /// determines next Filter to use from current Filter and Package
  27         virtual const filter::Base *move(const filter::Base *filter,
  28                                    const Package *package) const {
  29             return 0;
  30         };
  31
  32         /// re-read configuration of routing tables
  33         virtual void configure(){};
  34
  35         /// add routing rule expressed as Filter to Router
  36         virtual Router & rule(const filter::Base &filter){
  37             return *this;
  38         }
  39     private:
  40         /// disabled because class is singleton
  41         Router(const Router &);
  42
  43         /// disabled because class is singleton
  44         Router& operator=(const Router &);
  45     };
  46
  47
  48     class RouterChain : public Router {
  49     public:
  50         RouterChain(){};
  51         virtual ~RouterChain(){};
  52         virtual const filter::Base *move(const filter::Base *filter,
  53                                    const Package *package) const {
  54             std::list<const filter::Base *>::const_iterator it;
  55             it = m_filter_list.begin();
  56             if (filter)
  57                 {
  58                     for (; it != m_filter_list.end(); it++)
  59                         if (*it == filter)
  60                             {
  61                                 it++;
  62                                 break;
  63                             }
  64                 }
  65             if (it == m_filter_list.end())
  66                 {
  67                     //throw RouterException("no routing rules known");
  68                     return 0;
  69                 }
  70             return *it;
  71         };
  72         virtual void configure(){};
  73         RouterChain & rule(const filter::Base &filter){
  74             m_filter_list.push_back(&filter);
  75             return *this;
  76         }
  77     protected:
  78         std::list<const filter::Base *> m_filter_list;
  79     private:
  80         /// disabled because class is singleton
  81         RouterChain(const RouterChain &);
  82
  83         /// disabled because class is singleton
  84         RouterChain& operator=(const RouterChain &);
  85     };
  86
  87
  88
  89 }
  90
  91 #endif
  92 /*
  93  * Local variables:
  94  * c-basic-offset: 4
  95  * indent-tabs-mode: nil
  96  * End:
  97  * vim: shiftwidth=4 tabstop=8 expandtab
  98  */