Main Page | Namespace List | Class Hierarchy | Class List | File List | Class Members | File Members

rpc_QOSOptimizer.h

Go to the documentation of this file.
00001 /*****
00002  *
00003  * ../optimizer/nhopt/rpc_QOSOptimizer.h
00004  *
00005  * Include this file to gain access to the following classes:
00006  *
00007  *   - Remote<QOSOptimizer>
00008  *
00009  * This file is automatically generated by nmstl-rpcgen.
00010  * Do not modify it!
00011  *
00012  *****/
00013 
00014 #ifndef ___OPTIMIZER_NHOPT_RPC_QOSOPTIMIZER_H
00015 #define ___OPTIMIZER_NHOPT_RPC_QOSOPTIMIZER_H
00016 
00017 #include <NMSTL/rpc>
00018 #include "Stats.h"
00019 
00020 namespace Borealis { class QOSOptimizer; };
00021 
00022 
00023 NMSTL_NAMESPACE_BEGIN;
00024 
00025 #ifdef DOXYGEN_SKIP
00026 
00027 
00028 
00029 
00030 /*****
00031  *
00032  * Following are the public interfaces to RPC objects.
00033  *
00034  *****/
00035 
00036 template<typename T> class Remote;
00037 class Remote<Borealis::QOSOptimizer> {
00038   public:
00041     void do_something(const Callback<void, RPC< void > >& completion,
00042                       double life, double tp);
00043 
00045     RPC< void > do_something(double life, double tp);
00046 
00049     void call_me(const Callback<void, RPC< int > >& completion);
00050 
00052     RPC< int > call_me();
00053 
00056     void get_stat(const Callback<void, RPC< vector<Stats> > >& completion);
00057 
00059     RPC< vector<Stats> > get_stat();
00060 
00061 };
00062 
00063 
00064 /*****
00065  *
00066  * You can safely ignore everything after here.
00067  *
00068  *****/
00069 
00070 
00071 
00072 
00073 
00074 #else // !defined(DOXYGEN_SKIP)
00075 
00076 namespace __nmstl_tmp_rpc_defs {
00077 template<typename X> struct RPCDefs;
00078 template<typename X> struct Remote;
00079 using namespace Borealis;
00080 template<>
00081 struct RPCDefs<Borealis::QOSOptimizer> {
00082     static const int do_something_METHOD_ID = 20000;
00083     struct do_something_IN : public rpc_request_1< void > {
00084         double life; double tp; 
00085         do_something_IN() {}
00086         do_something_IN(double life, double tp) : life(life), tp(tp) {}
00087         rpc_message *clone() const { return new do_something_IN(*this); }
00088         string as_string() const {
00089             string out;
00090             out << "do_something_IN{" << "life=" << life << ", tp=" << tp << "}";
00091             return out;
00092         }
00093         NMSTL_SIMPLY_SERIALIZABLE(do_something_IN, << Serial::tag("param") << life << tp );
00094         NMSTL_SERIAL_TAG(do_something_IN, "params");
00095     };
00096     class do_something_OUT {
00097         RPCStatus m_stat;
00098       public:
00099         operator const void * () const { return m_stat; }
00100         const RPCStatus& stat() const { return m_stat; }
00101         bool get() const { return true; }
00102     };
00103     static const int call_me_METHOD_ID = 20001;
00104     struct call_me_IN : public rpc_request_1< int > {
00105         
00106         call_me_IN() {}
00107         rpc_message *clone() const { return new call_me_IN(*this); }
00108         string as_string() const {
00109             string out;
00110             out << "call_me_IN{" << "}";
00111             return out;
00112         }
00113         NMSTL_SIMPLY_SERIALIZABLE(call_me_IN, << Serial::tag("param") );
00114         NMSTL_SERIAL_TAG(call_me_IN, "params");
00115     };
00116     class call_me_OUT {
00117         RPCStatus m_stat;
00118         int m_val;
00119       public:
00120         operator const void * () const { return m_stat; }
00121         const RPCStatus& stat() const { return m_stat; }
00122         int get() const { return m_val; }
00123     };
00124     static const int get_stat_METHOD_ID = 20002;
00125     struct get_stat_IN : public rpc_request_1< vector<Stats> > {
00126         
00127         get_stat_IN() {}
00128         rpc_message *clone() const { return new get_stat_IN(*this); }
00129         string as_string() const {
00130             string out;
00131             out << "get_stat_IN{" << "}";
00132             return out;
00133         }
00134         NMSTL_SIMPLY_SERIALIZABLE(get_stat_IN, << Serial::tag("param") );
00135         NMSTL_SERIAL_TAG(get_stat_IN, "params");
00136     };
00137     class get_stat_OUT {
00138         RPCStatus m_stat;
00139         vector<Stats> m_val;
00140       public:
00141         operator const void * () const { return m_stat; }
00142         const RPCStatus& stat() const { return m_stat; }
00143         vector<Stats> get() const { return m_val; }
00144     };
00145     static const vector<pair<string, int> >& method_list() {
00146         static const pair<string, int> methods[] = {
00147             pair<string, int>("do_something", 20000),
00148             pair<string, int>("call_me", 20001),
00149             pair<string, int>("get_stat", 20002)
00150         };
00151         static const vector<pair<string, int> > ret(methods, methods + sizeof methods / sizeof methods[0]);
00152         return ret;
00153     };
00154     static const map<string, int>& method_id_by_name() {
00155         static const map<string, int> ret(method_list().begin(), method_list().end());
00156         return ret;
00157     }
00158     static const map<int, string>& method_name_by_id() {
00159         static const map<int, string> ret = RPCObject::reverse_map(method_id_by_name());
00160         return ret;
00161     }
00162 };
00163 template<>
00164 class Remote<Borealis::QOSOptimizer> : public RemoteObject {
00165     friend class RPCClient;
00166   protected:
00167     Remote<Borealis::QOSOptimizer>(RPCClient& cli, rpc_object_id object_id) :
00168         RemoteObject(cli, object_id) {}
00169 
00170   public:
00171     Remote<Borealis::QOSOptimizer>() {}
00172     void do_something(const Callback<void, RPC< void > >& completion, double life, double tp) const {
00173         RPCDefs<Borealis::QOSOptimizer>::do_something_IN *req =
00174             new RPCDefs<Borealis::QOSOptimizer>::do_something_IN(life, tp);
00175         req->object_id = object_id();
00176         req->method_id = RPCDefs<Borealis::QOSOptimizer>::do_something_METHOD_ID;
00177         req->method_name = "do_something";
00178         req->cb = completion;
00179         client().send_request(ptr<rpc_request>(req));
00180     }
00181     RPC< void > do_something(double life, double tp) const {
00182         RPCDefs<Borealis::QOSOptimizer>::do_something_IN *req =
00183             new RPCDefs<Borealis::QOSOptimizer>::do_something_IN(life, tp);
00184         ptr<rpc_request> preq(req);
00185         req->object_id = object_id();
00186         req->method_id = RPCDefs<Borealis::QOSOptimizer>::do_something_METHOD_ID;
00187         req->method_name = "do_something";
00188         bool done = false; RPC< void > ret;
00189         req->cb = wrap(&rpc_sync_completion< void >, &done, &ret);
00190         client().send_request(preq);
00191         while (!done && client().block()) ;
00192         req->cb = Callback<void, RPC< void > >();
00193         return ret;
00194     }
00195     typedef const RPCDefs<Borealis::QOSOptimizer>::do_something_OUT &do_something_result;
00196     void call_me(const Callback<void, RPC< int > >& completion) const {
00197         RPCDefs<Borealis::QOSOptimizer>::call_me_IN *req =
00198             new RPCDefs<Borealis::QOSOptimizer>::call_me_IN();
00199         req->object_id = object_id();
00200         req->method_id = RPCDefs<Borealis::QOSOptimizer>::call_me_METHOD_ID;
00201         req->method_name = "call_me";
00202         req->cb = completion;
00203         client().send_request(ptr<rpc_request>(req));
00204     }
00205     RPC< int > call_me() const {
00206         RPCDefs<Borealis::QOSOptimizer>::call_me_IN *req =
00207             new RPCDefs<Borealis::QOSOptimizer>::call_me_IN();
00208         ptr<rpc_request> preq(req);
00209         req->object_id = object_id();
00210         req->method_id = RPCDefs<Borealis::QOSOptimizer>::call_me_METHOD_ID;
00211         req->method_name = "call_me";
00212         bool done = false; RPC< int > ret;
00213         req->cb = wrap(&rpc_sync_completion< int >, &done, &ret);
00214         client().send_request(preq);
00215         while (!done && client().block()) ;
00216         req->cb = Callback<void, RPC< int > >();
00217         return ret;
00218     }
00219     typedef const RPCDefs<Borealis::QOSOptimizer>::call_me_OUT &call_me_result;
00220     void get_stat(const Callback<void, RPC< vector<Stats> > >& completion) const {
00221         RPCDefs<Borealis::QOSOptimizer>::get_stat_IN *req =
00222             new RPCDefs<Borealis::QOSOptimizer>::get_stat_IN();
00223         req->object_id = object_id();
00224         req->method_id = RPCDefs<Borealis::QOSOptimizer>::get_stat_METHOD_ID;
00225         req->method_name = "get_stat";
00226         req->cb = completion;
00227         client().send_request(ptr<rpc_request>(req));
00228     }
00229     RPC< vector<Stats> > get_stat() const {
00230         RPCDefs<Borealis::QOSOptimizer>::get_stat_IN *req =
00231             new RPCDefs<Borealis::QOSOptimizer>::get_stat_IN();
00232         ptr<rpc_request> preq(req);
00233         req->object_id = object_id();
00234         req->method_id = RPCDefs<Borealis::QOSOptimizer>::get_stat_METHOD_ID;
00235         req->method_name = "get_stat";
00236         bool done = false; RPC< vector<Stats> > ret;
00237         req->cb = wrap(&rpc_sync_completion< vector<Stats> >, &done, &ret);
00238         client().send_request(preq);
00239         while (!done && client().block()) ;
00240         req->cb = Callback<void, RPC< vector<Stats> > >();
00241         return ret;
00242     }
00243     typedef const RPCDefs<Borealis::QOSOptimizer>::get_stat_OUT &get_stat_result;
00244 };
00245 };
00246 template<> struct RPCDefs<Borealis::QOSOptimizer> : __nmstl_tmp_rpc_defs::RPCDefs<Borealis::QOSOptimizer> {};
00247 template<> struct Remote<Borealis::QOSOptimizer> : __nmstl_tmp_rpc_defs::Remote<Borealis::QOSOptimizer> {
00248     Remote<Borealis::QOSOptimizer>() {}
00249     Remote<Borealis::QOSOptimizer>(RPCClient& cli, rpc_object_id object_id) :
00250         __nmstl_tmp_rpc_defs::Remote<Borealis::QOSOptimizer>(cli, object_id) {}
00251 
00252     Remote<Borealis::QOSOptimizer>(const __nmstl_tmp_rpc_defs::Remote<Borealis::QOSOptimizer>& x) :
00253         __nmstl_tmp_rpc_defs::Remote<Borealis::QOSOptimizer>(x) {}
00254 };
00255 
00256 
00257 #endif // !defined(DOXYGEN_SKIP)
00258 
00259 NMSTL_NAMESPACE_END;
00260 
00261 #endif // !defined(___OPTIMIZER_NHOPT_RPC_QOSOPTIMIZER_H)
00262 
00263 
00264 
00265 
00266 
00267 #ifdef NMSTL_RPC_DEFINE
00268 
00269 #include <string>
00270 #include <map>
00271 #include <NMSTL/rpc>
00272 
00273 void Borealis::QOSOptimizer::handle_request(const NMSTL::RPCObject::response_cb& cb, const NMSTL::ptr<NMSTL::rpc_request>& req) {
00274     switch(req->method_id) {
00275       case NMSTL::RPCDefs<Borealis::QOSOptimizer>::do_something_METHOD_ID:
00276         {
00277             const NMSTL::RPCDefs<Borealis::QOSOptimizer>::do_something_IN* inp =
00278                 dynamic_cast<const NMSTL::RPCDefs<Borealis::QOSOptimizer>::do_something_IN*>(req.get());
00279 
00280             if (!inp) {
00281                 string err = string("Invalid RPC request type ") + typeid(*(req.get())) +
00282                      " to Borealis::QOSOptimizer::do_something; expected " +
00283                      typeid(NMSTL::RPCDefs<Borealis::QOSOptimizer>::do_something_IN);
00284                 WARN << err;
00285                 cb(err, 0, true);
00286                 return;
00287             }
00288 
00289             const NMSTL::RPCDefs<Borealis::QOSOptimizer>::do_something_IN& in = *inp;
00290             RPC< void > result = do_something(in.life, in.tp);
00291             if (result.valid()) {
00292                 NMSTL::rpc_message_1< void > ret;
00293                 cb(true, &ret, true);
00294             } else {
00295                 cb(result.stat(), 0, true);
00296             }
00297             break;
00298         }
00299       case NMSTL::RPCDefs<Borealis::QOSOptimizer>::call_me_METHOD_ID:
00300         {
00301             const NMSTL::RPCDefs<Borealis::QOSOptimizer>::call_me_IN* inp =
00302                 dynamic_cast<const NMSTL::RPCDefs<Borealis::QOSOptimizer>::call_me_IN*>(req.get());
00303 
00304             if (!inp) {
00305                 string err = string("Invalid RPC request type ") + typeid(*(req.get())) +
00306                      " to Borealis::QOSOptimizer::call_me; expected " +
00307                      typeid(NMSTL::RPCDefs<Borealis::QOSOptimizer>::call_me_IN);
00308                 WARN << err;
00309                 cb(err, 0, true);
00310                 return;
00311             }
00312 
00313             RPC< int > result = call_me();
00314             if (result.valid()) {
00315                 NMSTL::rpc_message_1< int > ret(*result);
00316                 cb(true, &ret, true);
00317             } else {
00318                 cb(result.stat(), 0, true);
00319             }
00320             break;
00321         }
00322       case NMSTL::RPCDefs<Borealis::QOSOptimizer>::get_stat_METHOD_ID:
00323         {
00324             const NMSTL::RPCDefs<Borealis::QOSOptimizer>::get_stat_IN* inp =
00325                 dynamic_cast<const NMSTL::RPCDefs<Borealis::QOSOptimizer>::get_stat_IN*>(req.get());
00326 
00327             if (!inp) {
00328                 string err = string("Invalid RPC request type ") + typeid(*(req.get())) +
00329                      " to Borealis::QOSOptimizer::get_stat; expected " +
00330                      typeid(NMSTL::RPCDefs<Borealis::QOSOptimizer>::get_stat_IN);
00331                 WARN << err;
00332                 cb(err, 0, true);
00333                 return;
00334             }
00335 
00336             RPC< vector<Stats> > result = get_stat();
00337             if (result.valid()) {
00338                 NMSTL::rpc_message_1< vector<Stats> > ret(*result);
00339                 cb(true, &ret, true);
00340             } else {
00341                 cb(result.stat(), 0, true);
00342             }
00343             break;
00344         }
00345       default:
00346         string err = string("Unknown method_id ") + req->method_id + " in Borealis::QOSOptimizer::handle_request";
00347         WARN << err;
00348         cb(err, 0, true);
00349     }
00350 }
00351 void Borealis::QOSOptimizer::handle_request(const response_cb& cb, rpc_id method_id, ISerial& is) {
00352     switch(method_id) {
00353       case RPCDefs<Borealis::QOSOptimizer>::do_something_METHOD_ID:
00354         {
00355             RPCDefs<Borealis::QOSOptimizer>::do_something_IN in;
00356             is >> in;
00357             if (!is) {
00358                 WARN << "Invalid RPC request to Borealis::QOSOptimizer::do_something: " << is.stat();
00359                 cb(is.stat(), 0, true);
00360                 return;
00361             }
00362             DEBUG << "Handling do_something";
00363             RPC< void > result = do_something(in.life, in.tp);
00364             if (result.valid()) {
00365                 NMSTL::rpc_message_1< void > ret;
00366                 cb(true, &ret, true);
00367             } else {
00368                 cb(result.stat(), 0, true);
00369             }
00370             break;
00371         }
00372       case RPCDefs<Borealis::QOSOptimizer>::call_me_METHOD_ID:
00373         {
00374             RPCDefs<Borealis::QOSOptimizer>::call_me_IN in;
00375             is >> in;
00376             if (!is) {
00377                 WARN << "Invalid RPC request to Borealis::QOSOptimizer::call_me: " << is.stat();
00378                 cb(is.stat(), 0, true);
00379                 return;
00380             }
00381             DEBUG << "Handling call_me";
00382             RPC< int > result = call_me();
00383             if (result.valid()) {
00384                 NMSTL::rpc_message_1< int > ret(*result);
00385                 cb(true, &ret, true);
00386             } else {
00387                 cb(result.stat(), 0, true);
00388             }
00389             break;
00390         }
00391       case RPCDefs<Borealis::QOSOptimizer>::get_stat_METHOD_ID:
00392         {
00393             RPCDefs<Borealis::QOSOptimizer>::get_stat_IN in;
00394             is >> in;
00395             if (!is) {
00396                 WARN << "Invalid RPC request to Borealis::QOSOptimizer::get_stat: " << is.stat();
00397                 cb(is.stat(), 0, true);
00398                 return;
00399             }
00400             DEBUG << "Handling get_stat";
00401             RPC< vector<Stats> > result = get_stat();
00402             if (result.valid()) {
00403                 NMSTL::rpc_message_1< vector<Stats> > ret(*result);
00404                 cb(true, &ret, true);
00405             } else {
00406                 cb(result.stat(), 0, true);
00407             }
00408             break;
00409         }
00410       default:
00411         string err = string("Unknown method_id ") + method_id + " in Borealis::QOSOptimizer::handle_request";
00412         WARN << err;
00413         cb(err, 0, true);
00414     }
00415 }
00416 NMSTL::rpc_id Borealis::QOSOptimizer::method_id_for_name(string method_name) {
00417     map<string, int>::const_iterator i = RPCDefs<Borealis::QOSOptimizer>::method_id_by_name().find(method_name);
00418     return (i == RPCDefs<Borealis::QOSOptimizer>::method_id_by_name().end()) ? rpc_id() : i->second;
00419 }
00420 string Borealis::QOSOptimizer::method_name_for_id(NMSTL::rpc_id method_id) {
00421     map<int, string>::const_iterator i = RPCDefs<Borealis::QOSOptimizer>::method_name_by_id().find(method_id);
00422     return (i == RPCDefs<Borealis::QOSOptimizer>::method_name_by_id().end()) ? string() : i->second;
00423 }
00424 NMSTL::ptr<NMSTL::rpc_request> Borealis::QOSOptimizer::make_request(NMSTL::rpc_id method_id, NMSTL::ISerial& is) {
00425     switch(method_id) {
00426       case NMSTL::RPCDefs<Borealis::QOSOptimizer>::do_something_METHOD_ID:
00427         {
00428             NMSTL::RPCDefs<Borealis::QOSOptimizer>::do_something_IN *in = new NMSTL::RPCDefs<Borealis::QOSOptimizer>::do_something_IN;
00429             NMSTL::ptr<NMSTL::rpc_request> req(in);
00430             if (is >> *in) return req;
00431         }
00432       case NMSTL::RPCDefs<Borealis::QOSOptimizer>::call_me_METHOD_ID:
00433         {
00434             NMSTL::RPCDefs<Borealis::QOSOptimizer>::call_me_IN *in = new NMSTL::RPCDefs<Borealis::QOSOptimizer>::call_me_IN;
00435             NMSTL::ptr<NMSTL::rpc_request> req(in);
00436             if (is >> *in) return req;
00437         }
00438       case NMSTL::RPCDefs<Borealis::QOSOptimizer>::get_stat_METHOD_ID:
00439         {
00440             NMSTL::RPCDefs<Borealis::QOSOptimizer>::get_stat_IN *in = new NMSTL::RPCDefs<Borealis::QOSOptimizer>::get_stat_IN;
00441             NMSTL::ptr<NMSTL::rpc_request> req(in);
00442             if (is >> *in) return req;
00443         }
00444     }
00445     return NMSTL::ptr<NMSTL::rpc_request>();
00446 }
00447 
00448 
00449 #endif
00450
Generated on Fri Nov 12 15:15:21 2004 for Borealis by doxygen 1.3.8