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

rpc_NHOptimizer.h

Go to the documentation of this file.
00001 /*****
00002  *
00003  * ../optimizer/nhopt/rpc_NHOptimizer.h
00004  *
00005  * Include this file to gain access to the following classes:
00006  *
00007  *   - Remote<NHOptimizer>
00008  *
00009  * This file is automatically generated by nmstl-rpcgen.
00010  * Do not modify it!
00011  *
00012  *****/
00013 
00014 #ifndef ___OPTIMIZER_NHOPT_RPC_NHOPTIMIZER_H
00015 #define ___OPTIMIZER_NHOPT_RPC_NHOPTIMIZER_H
00016 
00017 #include <NMSTL/rpc>
00018 #include "LoadOffer.h"
00019 
00020 namespace Borealis { class NHOptimizer; };
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::NHOptimizer> {
00038   public:
00041     void handle_load_offer(const Callback<void, RPC< ptr<LoadOffer> > >& completion,
00042                            ptr<LoadOffer> offer);
00043 
00045     RPC< ptr<LoadOffer> > handle_load_offer(ptr<LoadOffer> offer);
00046 
00049     void get_load_moves(const Callback<void, RPC< vector<Time> > >& completion);
00050 
00052     RPC< vector<Time> > get_load_moves();
00053 
00054 };
00055 
00056 
00057 /*****
00058  *
00059  * You can safely ignore everything after here.
00060  *
00061  *****/
00062 
00063 
00064 
00065 
00066 
00067 #else // !defined(DOXYGEN_SKIP)
00068 
00069 namespace __nmstl_tmp_rpc_defs {
00070 template<typename X> struct RPCDefs;
00071 template<typename X> struct Remote;
00072 using namespace Borealis;
00073 template<>
00074 struct RPCDefs<Borealis::NHOptimizer> {
00075     static const int handle_load_offer_METHOD_ID = 20000;
00076     struct handle_load_offer_IN : public rpc_request_1< ptr<LoadOffer> > {
00077         ptr<LoadOffer> offer; 
00078         handle_load_offer_IN() {}
00079         handle_load_offer_IN(ptr<LoadOffer> offer) : offer(offer) {}
00080         rpc_message *clone() const { return new handle_load_offer_IN(*this); }
00081         string as_string() const {
00082             string out;
00083             out << "handle_load_offer_IN{" << "offer=" << offer << "}";
00084             return out;
00085         }
00086         NMSTL_SIMPLY_SERIALIZABLE(handle_load_offer_IN, << Serial::tag("param") << offer );
00087         NMSTL_SERIAL_TAG(handle_load_offer_IN, "params");
00088     };
00089     class handle_load_offer_OUT {
00090         RPCStatus m_stat;
00091         ptr<LoadOffer> m_val;
00092       public:
00093         operator const void * () const { return m_stat; }
00094         const RPCStatus& stat() const { return m_stat; }
00095         ptr<LoadOffer> get() const { return m_val; }
00096     };
00097     static const int get_load_moves_METHOD_ID = 20001;
00098     struct get_load_moves_IN : public rpc_request_1< vector<Time> > {
00099         
00100         get_load_moves_IN() {}
00101         rpc_message *clone() const { return new get_load_moves_IN(*this); }
00102         string as_string() const {
00103             string out;
00104             out << "get_load_moves_IN{" << "}";
00105             return out;
00106         }
00107         NMSTL_SIMPLY_SERIALIZABLE(get_load_moves_IN, << Serial::tag("param") );
00108         NMSTL_SERIAL_TAG(get_load_moves_IN, "params");
00109     };
00110     class get_load_moves_OUT {
00111         RPCStatus m_stat;
00112         vector<Time> m_val;
00113       public:
00114         operator const void * () const { return m_stat; }
00115         const RPCStatus& stat() const { return m_stat; }
00116         vector<Time> get() const { return m_val; }
00117     };
00118     static const vector<pair<string, int> >& method_list() {
00119         static const pair<string, int> methods[] = {
00120             pair<string, int>("handle_load_offer", 20000),
00121             pair<string, int>("get_load_moves", 20001)
00122         };
00123         static const vector<pair<string, int> > ret(methods, methods + sizeof methods / sizeof methods[0]);
00124         return ret;
00125     };
00126     static const map<string, int>& method_id_by_name() {
00127         static const map<string, int> ret(method_list().begin(), method_list().end());
00128         return ret;
00129     }
00130     static const map<int, string>& method_name_by_id() {
00131         static const map<int, string> ret = RPCObject::reverse_map(method_id_by_name());
00132         return ret;
00133     }
00134 };
00135 template<>
00136 class Remote<Borealis::NHOptimizer> : public RemoteObject {
00137     friend class RPCClient;
00138   protected:
00139     Remote<Borealis::NHOptimizer>(RPCClient& cli, rpc_object_id object_id) :
00140         RemoteObject(cli, object_id) {}
00141 
00142   public:
00143     Remote<Borealis::NHOptimizer>() {}
00144     void handle_load_offer(const Callback<void, RPC< ptr<LoadOffer> > >& completion, ptr<LoadOffer> offer) const {
00145         RPCDefs<Borealis::NHOptimizer>::handle_load_offer_IN *req =
00146             new RPCDefs<Borealis::NHOptimizer>::handle_load_offer_IN(offer);
00147         req->object_id = object_id();
00148         req->method_id = RPCDefs<Borealis::NHOptimizer>::handle_load_offer_METHOD_ID;
00149         req->method_name = "handle_load_offer";
00150         req->cb = completion;
00151         client().send_request(ptr<rpc_request>(req));
00152     }
00153     RPC< ptr<LoadOffer> > handle_load_offer(ptr<LoadOffer> offer) const {
00154         RPCDefs<Borealis::NHOptimizer>::handle_load_offer_IN *req =
00155             new RPCDefs<Borealis::NHOptimizer>::handle_load_offer_IN(offer);
00156         ptr<rpc_request> preq(req);
00157         req->object_id = object_id();
00158         req->method_id = RPCDefs<Borealis::NHOptimizer>::handle_load_offer_METHOD_ID;
00159         req->method_name = "handle_load_offer";
00160         bool done = false; RPC< ptr<LoadOffer> > ret;
00161         req->cb = wrap(&rpc_sync_completion< ptr<LoadOffer> >, &done, &ret);
00162         client().send_request(preq);
00163         while (!done && client().block()) ;
00164         req->cb = Callback<void, RPC< ptr<LoadOffer> > >();
00165         return ret;
00166     }
00167     typedef const RPCDefs<Borealis::NHOptimizer>::handle_load_offer_OUT &handle_load_offer_result;
00168     void get_load_moves(const Callback<void, RPC< vector<Time> > >& completion) const {
00169         RPCDefs<Borealis::NHOptimizer>::get_load_moves_IN *req =
00170             new RPCDefs<Borealis::NHOptimizer>::get_load_moves_IN();
00171         req->object_id = object_id();
00172         req->method_id = RPCDefs<Borealis::NHOptimizer>::get_load_moves_METHOD_ID;
00173         req->method_name = "get_load_moves";
00174         req->cb = completion;
00175         client().send_request(ptr<rpc_request>(req));
00176     }
00177     RPC< vector<Time> > get_load_moves() const {
00178         RPCDefs<Borealis::NHOptimizer>::get_load_moves_IN *req =
00179             new RPCDefs<Borealis::NHOptimizer>::get_load_moves_IN();
00180         ptr<rpc_request> preq(req);
00181         req->object_id = object_id();
00182         req->method_id = RPCDefs<Borealis::NHOptimizer>::get_load_moves_METHOD_ID;
00183         req->method_name = "get_load_moves";
00184         bool done = false; RPC< vector<Time> > ret;
00185         req->cb = wrap(&rpc_sync_completion< vector<Time> >, &done, &ret);
00186         client().send_request(preq);
00187         while (!done && client().block()) ;
00188         req->cb = Callback<void, RPC< vector<Time> > >();
00189         return ret;
00190     }
00191     typedef const RPCDefs<Borealis::NHOptimizer>::get_load_moves_OUT &get_load_moves_result;
00192 };
00193 };
00194 template<> struct RPCDefs<Borealis::NHOptimizer> : __nmstl_tmp_rpc_defs::RPCDefs<Borealis::NHOptimizer> {};
00195 template<> struct Remote<Borealis::NHOptimizer> : __nmstl_tmp_rpc_defs::Remote<Borealis::NHOptimizer> {
00196     Remote<Borealis::NHOptimizer>() {}
00197     Remote<Borealis::NHOptimizer>(RPCClient& cli, rpc_object_id object_id) :
00198         __nmstl_tmp_rpc_defs::Remote<Borealis::NHOptimizer>(cli, object_id) {}
00199 
00200     Remote<Borealis::NHOptimizer>(const __nmstl_tmp_rpc_defs::Remote<Borealis::NHOptimizer>& x) :
00201         __nmstl_tmp_rpc_defs::Remote<Borealis::NHOptimizer>(x) {}
00202 };
00203 
00204 
00205 #endif // !defined(DOXYGEN_SKIP)
00206 
00207 NMSTL_NAMESPACE_END;
00208 
00209 #endif // !defined(___OPTIMIZER_NHOPT_RPC_NHOPTIMIZER_H)
00210 
00211 
00212 
00213 
00214 
00215 #ifdef NMSTL_RPC_DEFINE
00216 
00217 #include <string>
00218 #include <map>
00219 #include <NMSTL/rpc>
00220 
00221 void Borealis::NHOptimizer::handle_request(const NMSTL::RPCObject::response_cb& cb, const NMSTL::ptr<NMSTL::rpc_request>& req) {
00222     switch(req->method_id) {
00223       case NMSTL::RPCDefs<Borealis::NHOptimizer>::handle_load_offer_METHOD_ID:
00224         {
00225             const NMSTL::RPCDefs<Borealis::NHOptimizer>::handle_load_offer_IN* inp =
00226                 dynamic_cast<const NMSTL::RPCDefs<Borealis::NHOptimizer>::handle_load_offer_IN*>(req.get());
00227 
00228             if (!inp) {
00229                 string err = string("Invalid RPC request type ") + typeid(*(req.get())) +
00230                      " to Borealis::NHOptimizer::handle_load_offer; expected " +
00231                      typeid(NMSTL::RPCDefs<Borealis::NHOptimizer>::handle_load_offer_IN);
00232                 WARN << err;
00233                 cb(err, 0, true);
00234                 return;
00235             }
00236 
00237             const NMSTL::RPCDefs<Borealis::NHOptimizer>::handle_load_offer_IN& in = *inp;
00238             NMSTL::AsyncRPC< ptr<LoadOffer> > pending = handle_load_offer(in.offer);
00239             pending.set_response_handler(cb);
00240             break;
00241         }
00242       case NMSTL::RPCDefs<Borealis::NHOptimizer>::get_load_moves_METHOD_ID:
00243         {
00244             const NMSTL::RPCDefs<Borealis::NHOptimizer>::get_load_moves_IN* inp =
00245                 dynamic_cast<const NMSTL::RPCDefs<Borealis::NHOptimizer>::get_load_moves_IN*>(req.get());
00246 
00247             if (!inp) {
00248                 string err = string("Invalid RPC request type ") + typeid(*(req.get())) +
00249                      " to Borealis::NHOptimizer::get_load_moves; expected " +
00250                      typeid(NMSTL::RPCDefs<Borealis::NHOptimizer>::get_load_moves_IN);
00251                 WARN << err;
00252                 cb(err, 0, true);
00253                 return;
00254             }
00255 
00256             RPC< vector<Time> > result = get_load_moves();
00257             if (result.valid()) {
00258                 NMSTL::rpc_message_1< vector<Time> > ret(*result);
00259                 cb(true, &ret, true);
00260             } else {
00261                 cb(result.stat(), 0, true);
00262             }
00263             break;
00264         }
00265       default:
00266         string err = string("Unknown method_id ") + req->method_id + " in Borealis::NHOptimizer::handle_request";
00267         WARN << err;
00268         cb(err, 0, true);
00269     }
00270 }
00271 void Borealis::NHOptimizer::handle_request(const response_cb& cb, rpc_id method_id, ISerial& is) {
00272     switch(method_id) {
00273       case RPCDefs<Borealis::NHOptimizer>::handle_load_offer_METHOD_ID:
00274         {
00275             RPCDefs<Borealis::NHOptimizer>::handle_load_offer_IN in;
00276             is >> in;
00277             if (!is) {
00278                 WARN << "Invalid RPC request to Borealis::NHOptimizer::handle_load_offer: " << is.stat();
00279                 cb(is.stat(), 0, true);
00280                 return;
00281             }
00282             DEBUG << "Handling handle_load_offer";
00283             AsyncRPC< ptr<LoadOffer> > pending = handle_load_offer(in.offer);
00284             pending.set_response_handler(cb);
00285             break;
00286         }
00287       case RPCDefs<Borealis::NHOptimizer>::get_load_moves_METHOD_ID:
00288         {
00289             RPCDefs<Borealis::NHOptimizer>::get_load_moves_IN in;
00290             is >> in;
00291             if (!is) {
00292                 WARN << "Invalid RPC request to Borealis::NHOptimizer::get_load_moves: " << is.stat();
00293                 cb(is.stat(), 0, true);
00294                 return;
00295             }
00296             DEBUG << "Handling get_load_moves";
00297             RPC< vector<Time> > result = get_load_moves();
00298             if (result.valid()) {
00299                 NMSTL::rpc_message_1< vector<Time> > ret(*result);
00300                 cb(true, &ret, true);
00301             } else {
00302                 cb(result.stat(), 0, true);
00303             }
00304             break;
00305         }
00306       default:
00307         string err = string("Unknown method_id ") + method_id + " in Borealis::NHOptimizer::handle_request";
00308         WARN << err;
00309         cb(err, 0, true);
00310     }
00311 }
00312 NMSTL::rpc_id Borealis::NHOptimizer::method_id_for_name(string method_name) {
00313     map<string, int>::const_iterator i = RPCDefs<Borealis::NHOptimizer>::method_id_by_name().find(method_name);
00314     return (i == RPCDefs<Borealis::NHOptimizer>::method_id_by_name().end()) ? rpc_id() : i->second;
00315 }
00316 string Borealis::NHOptimizer::method_name_for_id(NMSTL::rpc_id method_id) {
00317     map<int, string>::const_iterator i = RPCDefs<Borealis::NHOptimizer>::method_name_by_id().find(method_id);
00318     return (i == RPCDefs<Borealis::NHOptimizer>::method_name_by_id().end()) ? string() : i->second;
00319 }
00320 NMSTL::ptr<NMSTL::rpc_request> Borealis::NHOptimizer::make_request(NMSTL::rpc_id method_id, NMSTL::ISerial& is) {
00321     switch(method_id) {
00322       case NMSTL::RPCDefs<Borealis::NHOptimizer>::handle_load_offer_METHOD_ID:
00323         {
00324             NMSTL::RPCDefs<Borealis::NHOptimizer>::handle_load_offer_IN *in = new NMSTL::RPCDefs<Borealis::NHOptimizer>::handle_load_offer_IN;
00325             NMSTL::ptr<NMSTL::rpc_request> req(in);
00326             if (is >> *in) return req;
00327         }
00328       case NMSTL::RPCDefs<Borealis::NHOptimizer>::get_load_moves_METHOD_ID:
00329         {
00330             NMSTL::RPCDefs<Borealis::NHOptimizer>::get_load_moves_IN *in = new NMSTL::RPCDefs<Borealis::NHOptimizer>::get_load_moves_IN;
00331             NMSTL::ptr<NMSTL::rpc_request> req(in);
00332             if (is >> *in) return req;
00333         }
00334     }
00335     return NMSTL::ptr<NMSTL::rpc_request>();
00336 }
00337 
00338 
00339 #endif
00340
Generated on Fri Nov 12 15:15:21 2004 for Borealis by doxygen 1.3.8