manes/manec.h

   1 /* Quarn OS / Manes
   2  *
   3  * Managed Execution Controller
   4  *
   5  * Copyright (C) 2008-2009 Pawel Dziepak
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  */
  22
  23 #ifndef _MANEC_H_
  24 #define _MANEC_H_
  25
  26 #include "cds/component.h"
  27 #include "cds/type.h"
  28 #include "libs/pointer.h"
  29 #include "arch/low/irq.h"
  30 #include "arch/low/general.h"
  31
  32 namespace resources {
  33         class did;
  34 }
  35
  36 namespace services {
  37         class kernel_state;
  38 }
  39
  40 namespace manes {
  41         class error;
  42         namespace cds {
  43                 class root;
  44                 class factory;
  45         }
  46
  47         /* Managed Execution Controller */
  48         class manec : public cds::component {
  49         private:
  50                 p<cds::root> main;
  51                 p<cds::factory> types;
  52
  53                 p<services::kernel_state> kstate;
  54
  55                 arch::irq_op irqs;
  56 public:
  57                 bool usermode;
  58                 static p<cds::component> comp;
  59                 static p<manec> instance;
  60                 manec();
  61         public:
  62
  63                 virtual p<cds::component> get_component(const cds::component_name &name);
  64                 virtual p<cds::component> get_component(const string cname);
  65
  66                 /**
  67                  * @brief Get component specified by path.
  68                  *
  69                  * @details This method parses given path and then uses multiple invocations
  70                  * of get_component method to get specified component. This is the syntax
  71                  * of component path:
  72                  * @code
  73                  * /type,id/type,id/type,id
  74                  * @endcode
  75                  * @param path Path to the requested component.
  76                  * @return Requested component.
  77                  */
  78                 virtual p<cds::component> get_by_path(const string &path);
  79
  80                 /**
  81                  * @brief Get certain interface of the specific component.
  82                  *
  83                  * @details This is a part of simplified interface of Manes manager.
  84                  * It gets specified component using method get_by_path, then narrows
  85                  * it to the needed interface T.
  86                  * @param path Path to the requested component.
  87                  * @return Requested interface of the component.
  88                  */
  89                 template<typename T>
  90                 p<T> get(const string &path);
  91
  92                 virtual void register_type(const string&, const string&, delegate<p<cds::component> >);
  93                 virtual void register_driver(const string&, const string&, delegate<p<cds::component> >, delegate<bool, p<resources::did> >);
  94
  95                 /**
  96                  * @brief Register new type in Manes.
  97                  *
  98                  * @details When given a pointer to a completely initialized type this function
  99                  * inserts that type into internal Manes database, so that it is available
 100                  * for all clients and operations on components of that type are possible.
 101                  * @param newtype Pointer to newly created type.
 102                  */
 103                 virtual void register_type(p<cds::type> newtype);
 104
 105                 /**
 106                  * @brief Get type from Manes.
 107                  *
 108                  * @details This method looks for requested type in internal Manes database.
 109                  * An error will occur if type wasn't previously registered.
 110                  * @param name Name of the requested type.
 111                  * @return Requested type.
 112                  */
 113                 virtual p<cds::type> get_type(const cds::component_name &name);
 114
 115                 virtual p<cds::type> get_driver(p<resources::did>);
 116
 117                 virtual arch::irq_op *get_low();
 118
 119
 120                 virtual void connect_manes(p<cds::root> root_mgr);
 121                 static void connect_manes();
 122
 123                 static p<manec> get();
 124
 125                 virtual p<cds::root> get_root();
 126                 virtual p<cds::factory> get_factory();
 127
 128                 virtual p<services::kernel_state> state();
 129
 130                 virtual p<error> err_msg(const string &x);
 131
 132                 inline bool far_calls() {
 133                         return !in_kernel();
 134                 }
 135
 136                 template<typename T>
 137                 void register_type(const string&, const string&);
 138
 139                 template<typename T>
 140                 void register_driver(const string&, const string&, delegate<bool, p<resources::did> >);
 141
 142                 virtual void register_abstract(const string&, const string&);
 143         };
 144
 145         template<typename T, typename U>
 146         p<T> create_object() {
 147                 return (T*)new U();
 148         }
 149
 150 template<typename T>
 151 void manec::register_type(const string &me, const string &parent) {
 152         register_type(me, parent, delegate<p<cds::component> >::function(create_object<cds::component, T>));
 153 }
 154
 155 template<typename T>
 156 void manec::register_driver(const string &me, const string &parent, delegate<bool, p<resources::did> > check) {
 157         register_driver(me, parent, delegate<p<cds::component> >::function(create_object<cds::component, T>), check);
 158 }
 159
 160 template<typename T>
 161 p<T> manec::get(const string &path) {
 162         return get_by_path(path).cast<T>();
 163 }
 164
 165 }
 166
 167 #include "error.h"
 168
 169 #endif