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

rpc_Admin.h

Go to the documentation of this file.
00001 /*****
00002  *
00003  * ../admin/rpc_Admin.h
00004  *
00005  * Include this file to gain access to the following classes:
00006  *
00007  *   - Remote<Admin>
00008  *
00009  * This file is automatically generated by nmstl-rpcgen.
00010  * Do not modify it!
00011  *
00012  *****/
00013 
00014 #ifndef ___ADMIN_RPC_ADMIN_H
00015 #define ___ADMIN_RPC_ADMIN_H
00016 
00017 #include <NMSTL/rpc>
00018 #include "CPViewDescription.h"
00019 #include "Name.h"
00020 #include "Query.h"
00021 #include "Schema.h"
00022 #include "Stats.h"
00023 #include "StreamDef.h"
00024 
00025 namespace Borealis { class Admin; };
00026 
00027 
00028 NMSTL_NAMESPACE_BEGIN;
00029 
00030 #ifdef DOXYGEN_SKIP
00031 
00032 
00033 
00034 
00035 /*****
00036  *
00037  * Following are the public interfaces to RPC objects.
00038  *
00039  *****/
00040 
00041 template<typename T> class Remote;
00042 class Remote<Borealis::Admin> {
00043   public:
00046     void create_schema(const Callback<void, RPC< void > >& completion,
00047                        Schema schema);
00048 
00050     RPC< void > create_schema(Schema schema);
00051 
00054     void create_stream(const Callback<void, RPC< void > >& completion,
00055                        StreamDef streamdef);
00056 
00058     RPC< void > create_stream(StreamDef streamdef);
00059 
00062     void create_cp(const Callback<void, RPC< void > >& completion,
00063                    CPViewDescription view_desc, StreamDef streamdef);
00064 
00066     RPC< void > create_cp(CPViewDescription view_desc, StreamDef streamdef);
00067 
00070     void create_query(const Callback<void, RPC< void > >& completion,
00071                       Query query);
00072 
00074     RPC< void > create_query(Query query);
00075 
00078     void create_query_xml(const Callback<void, RPC< void > >& completion,
00079                           string query);
00080 
00082     RPC< void > create_query_xml(string query);
00083 
00086     void set_query_status(const Callback<void, RPC< void > >& completion,
00087                           Name name, QueryStatus status);
00088 
00090     RPC< void > set_query_status(Name name, QueryStatus status);
00091 
00094     void set_queries_status(const Callback<void, RPC< void > >& completion,
00095                             vector<Name> name, QueryStatus status);
00096 
00098     RPC< void > set_queries_status(vector<Name> name, QueryStatus status);
00099 
00102     void subscribe(const Callback<void, RPC< void > >& completion,
00103                    Subscription sub, unsigned int add_or_remove);
00104 
00106     RPC< void > subscribe(Subscription sub, unsigned int add_or_remove);
00107 
00110     void subscribe_many(const Callback<void, RPC< void > >& completion,
00111                         vector<Subscription> sub, unsigned int add_or_remove);
00112 
00114     RPC< void > subscribe_many(vector<Subscription> sub, unsigned int add_or_remove);
00115 
00118     void create_and_start_queries(const Callback<void, RPC< void > >& completion,
00119                                   vector<Query> queries);
00120 
00122     RPC< void > create_and_start_queries(vector<Query> queries);
00123 
00126     void queries_and_subscriptions(const Callback<void, RPC< void > >& completion,
00127                                    vector<Query> queries, vector<Subscription> subs, unsigned int add_or_remove);
00128 
00130     RPC< void > queries_and_subscriptions(vector<Query> queries, vector<Subscription> subs, unsigned int add_or_remove);
00131 
00134     void move_load(const Callback<void, RPC< void > >& completion,
00135                    vector<Name> query_names, string partner);
00136 
00138     RPC< void > move_load(vector<Name> query_names, string partner);
00139 
00142     void split_query(const Callback<void, RPC< void > >& completion,
00143                      Name query_hunk_name, map<Name, vector<Name> > boxes_per_hunk);
00144 
00146     RPC< void > split_query(Name query_hunk_name, map<Name, vector<Name> > boxes_per_hunk);
00147 
00150     void merge_query(const Callback<void, RPC< void > >& completion,
00151                      vector<Name> existing_query_hunk_names, Name new_query_hunk_name);
00152 
00154     RPC< void > merge_query(vector<Name> existing_query_hunk_names, Name new_query_hunk_name);
00155 
00158     void add_stream_observer(const Callback<void, RPC< InputStreamInfo > >& completion);
00159 
00162     void add_query_observer(const Callback<void, RPC< Query > >& completion);
00163 
00166     void add_sub_observer(const Callback<void, RPC< vector<Subscription> > >& completion);
00167 
00168 };
00169 
00170 
00171 /*****
00172  *
00173  * You can safely ignore everything after here.
00174  *
00175  *****/
00176 
00177 
00178 
00179 
00180 
00181 #else // !defined(DOXYGEN_SKIP)
00182 
00183 namespace __nmstl_tmp_rpc_defs {
00184 template<typename X> struct RPCDefs;
00185 template<typename X> struct Remote;
00186 using namespace Borealis;
00187 template<>
00188 struct RPCDefs<Borealis::Admin> {
00189     static const int create_schema_METHOD_ID = 20000;
00190     struct create_schema_IN : public rpc_request_1< void > {
00191         Schema schema; 
00192         create_schema_IN() {}
00193         create_schema_IN(Schema schema) : schema(schema) {}
00194         rpc_message *clone() const { return new create_schema_IN(*this); }
00195         string as_string() const {
00196             string out;
00197             out << "create_schema_IN{" << "schema=" << schema << "}";
00198             return out;
00199         }
00200         NMSTL_SIMPLY_SERIALIZABLE(create_schema_IN, << Serial::tag("param") << schema );
00201         NMSTL_SERIAL_TAG(create_schema_IN, "params");
00202     };
00203     class create_schema_OUT {
00204         RPCStatus m_stat;
00205       public:
00206         operator const void * () const { return m_stat; }
00207         const RPCStatus& stat() const { return m_stat; }
00208         bool get() const { return true; }
00209     };
00210     static const int create_stream_METHOD_ID = 20001;
00211     struct create_stream_IN : public rpc_request_1< void > {
00212         StreamDef streamdef; 
00213         create_stream_IN() {}
00214         create_stream_IN(StreamDef streamdef) : streamdef(streamdef) {}
00215         rpc_message *clone() const { return new create_stream_IN(*this); }
00216         string as_string() const {
00217             string out;
00218             out << "create_stream_IN{" << "streamdef=" << streamdef << "}";
00219             return out;
00220         }
00221         NMSTL_SIMPLY_SERIALIZABLE(create_stream_IN, << Serial::tag("param") << streamdef );
00222         NMSTL_SERIAL_TAG(create_stream_IN, "params");
00223     };
00224     class create_stream_OUT {
00225         RPCStatus m_stat;
00226       public:
00227         operator const void * () const { return m_stat; }
00228         const RPCStatus& stat() const { return m_stat; }
00229         bool get() const { return true; }
00230     };
00231     static const int create_cp_METHOD_ID = 20002;
00232     struct create_cp_IN : public rpc_request_1< void > {
00233         CPViewDescription view_desc; StreamDef streamdef; 
00234         create_cp_IN() {}
00235         create_cp_IN(CPViewDescription view_desc, StreamDef streamdef) : view_desc(view_desc), streamdef(streamdef) {}
00236         rpc_message *clone() const { return new create_cp_IN(*this); }
00237         string as_string() const {
00238             string out;
00239             out << "create_cp_IN{" << "view_desc=" << view_desc << ", streamdef=" << streamdef << "}";
00240             return out;
00241         }
00242         NMSTL_SIMPLY_SERIALIZABLE(create_cp_IN, << Serial::tag("param") << view_desc << streamdef );
00243         NMSTL_SERIAL_TAG(create_cp_IN, "params");
00244     };
00245     class create_cp_OUT {
00246         RPCStatus m_stat;
00247       public:
00248         operator const void * () const { return m_stat; }
00249         const RPCStatus& stat() const { return m_stat; }
00250         bool get() const { return true; }
00251     };
00252     static const int create_query_METHOD_ID = 20003;
00253     struct create_query_IN : public rpc_request_1< void > {
00254         Query query; 
00255         create_query_IN() {}
00256         create_query_IN(Query query) : query(query) {}
00257         rpc_message *clone() const { return new create_query_IN(*this); }
00258         string as_string() const {
00259             string out;
00260             out << "create_query_IN{" << "query=" << query << "}";
00261             return out;
00262         }
00263         NMSTL_SIMPLY_SERIALIZABLE(create_query_IN, << Serial::tag("param") << query );
00264         NMSTL_SERIAL_TAG(create_query_IN, "params");
00265     };
00266     class create_query_OUT {
00267         RPCStatus m_stat;
00268       public:
00269         operator const void * () const { return m_stat; }
00270         const RPCStatus& stat() const { return m_stat; }
00271         bool get() const { return true; }
00272     };
00273     static const int create_query_xml_METHOD_ID = 20004;
00274     struct create_query_xml_IN : public rpc_request_1< void > {
00275         string query; 
00276         create_query_xml_IN() {}
00277         create_query_xml_IN(string query) : query(query) {}
00278         rpc_message *clone() const { return new create_query_xml_IN(*this); }
00279         string as_string() const {
00280             string out;
00281             out << "create_query_xml_IN{" << "query=" << query << "}";
00282             return out;
00283         }
00284         NMSTL_SIMPLY_SERIALIZABLE(create_query_xml_IN, << Serial::tag("param") << query );
00285         NMSTL_SERIAL_TAG(create_query_xml_IN, "params");
00286     };
00287     class create_query_xml_OUT {
00288         RPCStatus m_stat;
00289       public:
00290         operator const void * () const { return m_stat; }
00291         const RPCStatus& stat() const { return m_stat; }
00292         bool get() const { return true; }
00293     };
00294     static const int set_query_status_METHOD_ID = 20005;
00295     struct set_query_status_IN : public rpc_request_1< void > {
00296         Name name; QueryStatus status; 
00297         set_query_status_IN() {}
00298         set_query_status_IN(Name name, QueryStatus status) : name(name), status(status) {}
00299         rpc_message *clone() const { return new set_query_status_IN(*this); }
00300         string as_string() const {
00301             string out;
00302             out << "set_query_status_IN{" << "name=" << name << ", status=" << status << "}";
00303             return out;
00304         }
00305         NMSTL_SIMPLY_SERIALIZABLE(set_query_status_IN, << Serial::tag("param") << name << status );
00306         NMSTL_SERIAL_TAG(set_query_status_IN, "params");
00307     };
00308     class set_query_status_OUT {
00309         RPCStatus m_stat;
00310       public:
00311         operator const void * () const { return m_stat; }
00312         const RPCStatus& stat() const { return m_stat; }
00313         bool get() const { return true; }
00314     };
00315     static const int set_queries_status_METHOD_ID = 20006;
00316     struct set_queries_status_IN : public rpc_request_1< void > {
00317         vector<Name> name; QueryStatus status; 
00318         set_queries_status_IN() {}
00319         set_queries_status_IN(vector<Name> name, QueryStatus status) : name(name), status(status) {}
00320         rpc_message *clone() const { return new set_queries_status_IN(*this); }
00321         string as_string() const {
00322             string out;
00323             out << "set_queries_status_IN{" << "name=" << name << ", status=" << status << "}";
00324             return out;
00325         }
00326         NMSTL_SIMPLY_SERIALIZABLE(set_queries_status_IN, << Serial::tag("param") << name << status );
00327         NMSTL_SERIAL_TAG(set_queries_status_IN, "params");
00328     };
00329     class set_queries_status_OUT {
00330         RPCStatus m_stat;
00331       public:
00332         operator const void * () const { return m_stat; }
00333         const RPCStatus& stat() const { return m_stat; }
00334         bool get() const { return true; }
00335     };
00336     static const int subscribe_METHOD_ID = 20007;
00337     struct subscribe_IN : public rpc_request_1< void > {
00338         Subscription sub; unsigned int add_or_remove; 
00339         subscribe_IN() {}
00340         subscribe_IN(Subscription sub, unsigned int add_or_remove) : sub(sub), add_or_remove(add_or_remove) {}
00341         rpc_message *clone() const { return new subscribe_IN(*this); }
00342         string as_string() const {
00343             string out;
00344             out << "subscribe_IN{" << "sub=" << sub << ", add_or_remove=" << add_or_remove << "}";
00345             return out;
00346         }
00347         NMSTL_SIMPLY_SERIALIZABLE(subscribe_IN, << Serial::tag("param") << sub << add_or_remove );
00348         NMSTL_SERIAL_TAG(subscribe_IN, "params");
00349     };
00350     class subscribe_OUT {
00351         RPCStatus m_stat;
00352       public:
00353         operator const void * () const { return m_stat; }
00354         const RPCStatus& stat() const { return m_stat; }
00355         bool get() const { return true; }
00356     };
00357     static const int subscribe_many_METHOD_ID = 20008;
00358     struct subscribe_many_IN : public rpc_request_1< void > {
00359         vector<Subscription> sub; unsigned int add_or_remove; 
00360         subscribe_many_IN() {}
00361         subscribe_many_IN(vector<Subscription> sub, unsigned int add_or_remove) : sub(sub), add_or_remove(add_or_remove) {}
00362         rpc_message *clone() const { return new subscribe_many_IN(*this); }
00363         string as_string() const {
00364             string out;
00365             out << "subscribe_many_IN{" << "sub=" << sub << ", add_or_remove=" << add_or_remove << "}";
00366             return out;
00367         }
00368         NMSTL_SIMPLY_SERIALIZABLE(subscribe_many_IN, << Serial::tag("param") << sub << add_or_remove );
00369         NMSTL_SERIAL_TAG(subscribe_many_IN, "params");
00370     };
00371     class subscribe_many_OUT {
00372         RPCStatus m_stat;
00373       public:
00374         operator const void * () const { return m_stat; }
00375         const RPCStatus& stat() const { return m_stat; }
00376         bool get() const { return true; }
00377     };
00378     static const int create_and_start_queries_METHOD_ID = 20009;
00379     struct create_and_start_queries_IN : public rpc_request_1< void > {
00380         vector<Query> queries; 
00381         create_and_start_queries_IN() {}
00382         create_and_start_queries_IN(vector<Query> queries) : queries(queries) {}
00383         rpc_message *clone() const { return new create_and_start_queries_IN(*this); }
00384         string as_string() const {
00385             string out;
00386             out << "create_and_start_queries_IN{" << "queries=" << queries << "}";
00387             return out;
00388         }
00389         NMSTL_SIMPLY_SERIALIZABLE(create_and_start_queries_IN, << Serial::tag("param") << queries );
00390         NMSTL_SERIAL_TAG(create_and_start_queries_IN, "params");
00391     };
00392     class create_and_start_queries_OUT {
00393         RPCStatus m_stat;
00394       public:
00395         operator const void * () const { return m_stat; }
00396         const RPCStatus& stat() const { return m_stat; }
00397         bool get() const { return true; }
00398     };
00399     static const int queries_and_subscriptions_METHOD_ID = 20010;
00400     struct queries_and_subscriptions_IN : public rpc_request_1< void > {
00401         vector<Query> queries; vector<Subscription> subs; unsigned int add_or_remove; 
00402         queries_and_subscriptions_IN() {}
00403         queries_and_subscriptions_IN(vector<Query> queries, vector<Subscription> subs, unsigned int add_or_remove) : queries(queries), subs(subs), add_or_remove(add_or_remove) {}
00404         rpc_message *clone() const { return new queries_and_subscriptions_IN(*this); }
00405         string as_string() const {
00406             string out;
00407             out << "queries_and_subscriptions_IN{" << "queries=" << queries << ", subs=" << subs << ", add_or_remove=" << add_or_remove << "}";
00408             return out;
00409         }
00410         NMSTL_SIMPLY_SERIALIZABLE(queries_and_subscriptions_IN, << Serial::tag("param") << queries << subs << add_or_remove );
00411         NMSTL_SERIAL_TAG(queries_and_subscriptions_IN, "params");
00412     };
00413     class queries_and_subscriptions_OUT {
00414         RPCStatus m_stat;
00415       public:
00416         operator const void * () const { return m_stat; }
00417         const RPCStatus& stat() const { return m_stat; }
00418         bool get() const { return true; }
00419     };
00420     static const int move_load_METHOD_ID = 20011;
00421     struct move_load_IN : public rpc_request_1< void > {
00422         vector<Name> query_names; string partner; 
00423         move_load_IN() {}
00424         move_load_IN(vector<Name> query_names, string partner) : query_names(query_names), partner(partner) {}
00425         rpc_message *clone() const { return new move_load_IN(*this); }
00426         string as_string() const {
00427             string out;
00428             out << "move_load_IN{" << "query_names=" << query_names << ", partner=" << partner << "}";
00429             return out;
00430         }
00431         NMSTL_SIMPLY_SERIALIZABLE(move_load_IN, << Serial::tag("param") << query_names << partner );
00432         NMSTL_SERIAL_TAG(move_load_IN, "params");
00433     };
00434     class move_load_OUT {
00435         RPCStatus m_stat;
00436       public:
00437         operator const void * () const { return m_stat; }
00438         const RPCStatus& stat() const { return m_stat; }
00439         bool get() const { return true; }
00440     };
00441     static const int split_query_METHOD_ID = 20012;
00442     struct split_query_IN : public rpc_request_1< void > {
00443         Name query_hunk_name; map<Name, vector<Name> > boxes_per_hunk; 
00444         split_query_IN() {}
00445         split_query_IN(Name query_hunk_name, map<Name, vector<Name> > boxes_per_hunk) : query_hunk_name(query_hunk_name), boxes_per_hunk(boxes_per_hunk) {}
00446         rpc_message *clone() const { return new split_query_IN(*this); }
00447         string as_string() const {
00448             string out;
00449             out << "split_query_IN{" << "query_hunk_name=" << query_hunk_name << ", boxes_per_hunk=" << boxes_per_hunk << "}";
00450             return out;
00451         }
00452         NMSTL_SIMPLY_SERIALIZABLE(split_query_IN, << Serial::tag("param") << query_hunk_name << boxes_per_hunk );
00453         NMSTL_SERIAL_TAG(split_query_IN, "params");
00454     };
00455     class split_query_OUT {
00456         RPCStatus m_stat;
00457       public:
00458         operator const void * () const { return m_stat; }
00459         const RPCStatus& stat() const { return m_stat; }
00460         bool get() const { return true; }
00461     };
00462     static const int merge_query_METHOD_ID = 20013;
00463     struct merge_query_IN : public rpc_request_1< void > {
00464         vector<Name> existing_query_hunk_names; Name new_query_hunk_name; 
00465         merge_query_IN() {}
00466         merge_query_IN(vector<Name> existing_query_hunk_names, Name new_query_hunk_name) : existing_query_hunk_names(existing_query_hunk_names), new_query_hunk_name(new_query_hunk_name) {}
00467         rpc_message *clone() const { return new merge_query_IN(*this); }
00468         string as_string() const {
00469             string out;
00470             out << "merge_query_IN{" << "existing_query_hunk_names=" << existing_query_hunk_names << ", new_query_hunk_name=" << new_query_hunk_name << "}";
00471             return out;
00472         }
00473         NMSTL_SIMPLY_SERIALIZABLE(merge_query_IN, << Serial::tag("param") << existing_query_hunk_names << new_query_hunk_name );
00474         NMSTL_SERIAL_TAG(merge_query_IN, "params");
00475     };
00476     class merge_query_OUT {
00477         RPCStatus m_stat;
00478       public:
00479         operator const void * () const { return m_stat; }
00480         const RPCStatus& stat() const { return m_stat; }
00481         bool get() const { return true; }
00482     };
00483     static const int add_stream_observer_METHOD_ID = 20014;
00484     struct add_stream_observer_IN : public rpc_request_1< InputStreamInfo > {
00485         
00486         add_stream_observer_IN() {}
00487         rpc_message *clone() const { return new add_stream_observer_IN(*this); }
00488         string as_string() const {
00489             string out;
00490             out << "add_stream_observer_IN{" << "}";
00491             return out;
00492         }
00493         NMSTL_SIMPLY_SERIALIZABLE(add_stream_observer_IN, << Serial::tag("param") );
00494         NMSTL_SERIAL_TAG(add_stream_observer_IN, "params");
00495     };
00496     class add_stream_observer_OUT {
00497         RPCStatus m_stat;
00498         InputStreamInfo m_val;
00499       public:
00500         operator const void * () const { return m_stat; }
00501         const RPCStatus& stat() const { return m_stat; }
00502         InputStreamInfo get() const { return m_val; }
00503     };
00504     static const int add_query_observer_METHOD_ID = 20015;
00505     struct add_query_observer_IN : public rpc_request_1< Query > {
00506         
00507         add_query_observer_IN() {}
00508         rpc_message *clone() const { return new add_query_observer_IN(*this); }
00509         string as_string() const {
00510             string out;
00511             out << "add_query_observer_IN{" << "}";
00512             return out;
00513         }
00514         NMSTL_SIMPLY_SERIALIZABLE(add_query_observer_IN, << Serial::tag("param") );
00515         NMSTL_SERIAL_TAG(add_query_observer_IN, "params");
00516     };
00517     class add_query_observer_OUT {
00518         RPCStatus m_stat;
00519         Query m_val;
00520       public:
00521         operator const void * () const { return m_stat; }
00522         const RPCStatus& stat() const { return m_stat; }
00523         Query get() const { return m_val; }
00524     };
00525     static const int add_sub_observer_METHOD_ID = 20016;
00526     struct add_sub_observer_IN : public rpc_request_1< vector<Subscription> > {
00527         
00528         add_sub_observer_IN() {}
00529         rpc_message *clone() const { return new add_sub_observer_IN(*this); }
00530         string as_string() const {
00531             string out;
00532             out << "add_sub_observer_IN{" << "}";
00533             return out;
00534         }
00535         NMSTL_SIMPLY_SERIALIZABLE(add_sub_observer_IN, << Serial::tag("param") );
00536         NMSTL_SERIAL_TAG(add_sub_observer_IN, "params");
00537     };
00538     class add_sub_observer_OUT {
00539         RPCStatus m_stat;
00540         vector<Subscription> m_val;
00541       public:
00542         operator const void * () const { return m_stat; }
00543         const RPCStatus& stat() const { return m_stat; }
00544         vector<Subscription> get() const { return m_val; }
00545     };
00546     static const vector<pair<string, int> >& method_list() {
00547         static const pair<string, int> methods[] = {
00548             pair<string, int>("create_schema", 20000),
00549             pair<string, int>("create_stream", 20001),
00550             pair<string, int>("create_cp", 20002),
00551             pair<string, int>("create_query", 20003),
00552             pair<string, int>("create_query_xml", 20004),
00553             pair<string, int>("set_query_status", 20005),
00554             pair<string, int>("set_queries_status", 20006),
00555             pair<string, int>("subscribe", 20007),
00556             pair<string, int>("subscribe_many", 20008),
00557             pair<string, int>("create_and_start_queries", 20009),
00558             pair<string, int>("queries_and_subscriptions", 20010),
00559             pair<string, int>("move_load", 20011),
00560             pair<string, int>("split_query", 20012),
00561             pair<string, int>("merge_query", 20013),
00562             pair<string, int>("add_stream_observer", 20014),
00563             pair<string, int>("add_query_observer", 20015),
00564             pair<string, int>("add_sub_observer", 20016)
00565         };
00566         static const vector<pair<string, int> > ret(methods, methods + sizeof methods / sizeof methods[0]);
00567         return ret;
00568     };
00569     static const map<string, int>& method_id_by_name() {
00570         static const map<string, int> ret(method_list().begin(), method_list().end());
00571         return ret;
00572     }
00573     static const map<int, string>& method_name_by_id() {
00574         static const map<int, string> ret = RPCObject::reverse_map(method_id_by_name());
00575         return ret;
00576     }
00577 };
00578 template<>
00579 class Remote<Borealis::Admin> : public RemoteObject {
00580     friend class RPCClient;
00581   protected:
00582     Remote<Borealis::Admin>(RPCClient& cli, rpc_object_id object_id) :
00583         RemoteObject(cli, object_id) {}
00584 
00585   public:
00586     Remote<Borealis::Admin>() {}
00587     void create_schema(const Callback<void, RPC< void > >& completion, Schema schema) const {
00588         RPCDefs<Borealis::Admin>::create_schema_IN *req =
00589             new RPCDefs<Borealis::Admin>::create_schema_IN(schema);
00590         req->object_id = object_id();
00591         req->method_id = RPCDefs<Borealis::Admin>::create_schema_METHOD_ID;
00592         req->method_name = "create_schema";
00593         req->cb = completion;
00594         client().send_request(ptr<rpc_request>(req));
00595     }
00596     RPC< void > create_schema(Schema schema) const {
00597         RPCDefs<Borealis::Admin>::create_schema_IN *req =
00598             new RPCDefs<Borealis::Admin>::create_schema_IN(schema);
00599         ptr<rpc_request> preq(req);
00600         req->object_id = object_id();
00601         req->method_id = RPCDefs<Borealis::Admin>::create_schema_METHOD_ID;
00602         req->method_name = "create_schema";
00603         bool done = false; RPC< void > ret;
00604         req->cb = wrap(&rpc_sync_completion< void >, &done, &ret);
00605         client().send_request(preq);
00606         while (!done && client().block()) ;
00607         req->cb = Callback<void, RPC< void > >();
00608         return ret;
00609     }
00610     typedef const RPCDefs<Borealis::Admin>::create_schema_OUT &create_schema_result;
00611     void create_stream(const Callback<void, RPC< void > >& completion, StreamDef streamdef) const {
00612         RPCDefs<Borealis::Admin>::create_stream_IN *req =
00613             new RPCDefs<Borealis::Admin>::create_stream_IN(streamdef);
00614         req->object_id = object_id();
00615         req->method_id = RPCDefs<Borealis::Admin>::create_stream_METHOD_ID;
00616         req->method_name = "create_stream";
00617         req->cb = completion;
00618         client().send_request(ptr<rpc_request>(req));
00619     }
00620     RPC< void > create_stream(StreamDef streamdef) const {
00621         RPCDefs<Borealis::Admin>::create_stream_IN *req =
00622             new RPCDefs<Borealis::Admin>::create_stream_IN(streamdef);
00623         ptr<rpc_request> preq(req);
00624         req->object_id = object_id();
00625         req->method_id = RPCDefs<Borealis::Admin>::create_stream_METHOD_ID;
00626         req->method_name = "create_stream";
00627         bool done = false; RPC< void > ret;
00628         req->cb = wrap(&rpc_sync_completion< void >, &done, &ret);
00629         client().send_request(preq);
00630         while (!done && client().block()) ;
00631         req->cb = Callback<void, RPC< void > >();
00632         return ret;
00633     }
00634     typedef const RPCDefs<Borealis::Admin>::create_stream_OUT &create_stream_result;
00635     void create_cp(const Callback<void, RPC< void > >& completion, CPViewDescription view_desc, StreamDef streamdef) const {
00636         RPCDefs<Borealis::Admin>::create_cp_IN *req =
00637             new RPCDefs<Borealis::Admin>::create_cp_IN(view_desc, streamdef);
00638         req->object_id = object_id();
00639         req->method_id = RPCDefs<Borealis::Admin>::create_cp_METHOD_ID;
00640         req->method_name = "create_cp";
00641         req->cb = completion;
00642         client().send_request(ptr<rpc_request>(req));
00643     }
00644     RPC< void > create_cp(CPViewDescription view_desc, StreamDef streamdef) const {
00645         RPCDefs<Borealis::Admin>::create_cp_IN *req =
00646             new RPCDefs<Borealis::Admin>::create_cp_IN(view_desc, streamdef);
00647         ptr<rpc_request> preq(req);
00648         req->object_id = object_id();
00649         req->method_id = RPCDefs<Borealis::Admin>::create_cp_METHOD_ID;
00650         req->method_name = "create_cp";
00651         bool done = false; RPC< void > ret;
00652         req->cb = wrap(&rpc_sync_completion< void >, &done, &ret);
00653         client().send_request(preq);
00654         while (!done && client().block()) ;
00655         req->cb = Callback<void, RPC< void > >();
00656         return ret;
00657     }
00658     typedef const RPCDefs<Borealis::Admin>::create_cp_OUT &create_cp_result;
00659     void create_query(const Callback<void, RPC< void > >& completion, Query query) const {
00660         RPCDefs<Borealis::Admin>::create_query_IN *req =
00661             new RPCDefs<Borealis::Admin>::create_query_IN(query);
00662         req->object_id = object_id();
00663         req->method_id = RPCDefs<Borealis::Admin>::create_query_METHOD_ID;
00664         req->method_name = "create_query";
00665         req->cb = completion;
00666         client().send_request(ptr<rpc_request>(req));
00667     }
00668     RPC< void > create_query(Query query) const {
00669         RPCDefs<Borealis::Admin>::create_query_IN *req =
00670             new RPCDefs<Borealis::Admin>::create_query_IN(query);
00671         ptr<rpc_request> preq(req);
00672         req->object_id = object_id();
00673         req->method_id = RPCDefs<Borealis::Admin>::create_query_METHOD_ID;
00674         req->method_name = "create_query";
00675         bool done = false; RPC< void > ret;
00676         req->cb = wrap(&rpc_sync_completion< void >, &done, &ret);
00677         client().send_request(preq);
00678         while (!done && client().block()) ;
00679         req->cb = Callback<void, RPC< void > >();
00680         return ret;
00681     }
00682     typedef const RPCDefs<Borealis::Admin>::create_query_OUT &create_query_result;
00683     void create_query_xml(const Callback<void, RPC< void > >& completion, string query) const {
00684         RPCDefs<Borealis::Admin>::create_query_xml_IN *req =
00685             new RPCDefs<Borealis::Admin>::create_query_xml_IN(query);
00686         req->object_id = object_id();
00687         req->method_id = RPCDefs<Borealis::Admin>::create_query_xml_METHOD_ID;
00688         req->method_name = "create_query_xml";
00689         req->cb = completion;
00690         client().send_request(ptr<rpc_request>(req));
00691     }
00692     RPC< void > create_query_xml(string query) const {
00693         RPCDefs<Borealis::Admin>::create_query_xml_IN *req =
00694             new RPCDefs<Borealis::Admin>::create_query_xml_IN(query);
00695         ptr<rpc_request> preq(req);
00696         req->object_id = object_id();
00697         req->method_id = RPCDefs<Borealis::Admin>::create_query_xml_METHOD_ID;
00698         req->method_name = "create_query_xml";
00699         bool done = false; RPC< void > ret;
00700         req->cb = wrap(&rpc_sync_completion< void >, &done, &ret);
00701         client().send_request(preq);
00702         while (!done && client().block()) ;
00703         req->cb = Callback<void, RPC< void > >();
00704         return ret;
00705     }
00706     typedef const RPCDefs<Borealis::Admin>::create_query_xml_OUT &create_query_xml_result;
00707     void set_query_status(const Callback<void, RPC< void > >& completion, Name name, QueryStatus status) const {
00708         RPCDefs<Borealis::Admin>::set_query_status_IN *req =
00709             new RPCDefs<Borealis::Admin>::set_query_status_IN(name, status);
00710         req->object_id = object_id();
00711         req->method_id = RPCDefs<Borealis::Admin>::set_query_status_METHOD_ID;
00712         req->method_name = "set_query_status";
00713         req->cb = completion;
00714         client().send_request(ptr<rpc_request>(req));
00715     }
00716     RPC< void > set_query_status(Name name, QueryStatus status) const {
00717         RPCDefs<Borealis::Admin>::set_query_status_IN *req =
00718             new RPCDefs<Borealis::Admin>::set_query_status_IN(name, status);
00719         ptr<rpc_request> preq(req);
00720         req->object_id = object_id();
00721         req->method_id = RPCDefs<Borealis::Admin>::set_query_status_METHOD_ID;
00722         req->method_name = "set_query_status";
00723         bool done = false; RPC< void > ret;
00724         req->cb = wrap(&rpc_sync_completion< void >, &done, &ret);
00725         client().send_request(preq);
00726         while (!done && client().block()) ;
00727         req->cb = Callback<void, RPC< void > >();
00728         return ret;
00729     }
00730     typedef const RPCDefs<Borealis::Admin>::set_query_status_OUT &set_query_status_result;
00731     void set_queries_status(const Callback<void, RPC< void > >& completion, vector<Name> name, QueryStatus status) const {
00732         RPCDefs<Borealis::Admin>::set_queries_status_IN *req =
00733             new RPCDefs<Borealis::Admin>::set_queries_status_IN(name, status);
00734         req->object_id = object_id();
00735         req->method_id = RPCDefs<Borealis::Admin>::set_queries_status_METHOD_ID;
00736         req->method_name = "set_queries_status";
00737         req->cb = completion;
00738         client().send_request(ptr<rpc_request>(req));
00739     }
00740     RPC< void > set_queries_status(vector<Name> name, QueryStatus status) const {
00741         RPCDefs<Borealis::Admin>::set_queries_status_IN *req =
00742             new RPCDefs<Borealis::Admin>::set_queries_status_IN(name, status);
00743         ptr<rpc_request> preq(req);
00744         req->object_id = object_id();
00745         req->method_id = RPCDefs<Borealis::Admin>::set_queries_status_METHOD_ID;
00746         req->method_name = "set_queries_status";
00747         bool done = false; RPC< void > ret;
00748         req->cb = wrap(&rpc_sync_completion< void >, &done, &ret);
00749         client().send_request(preq);
00750         while (!done && client().block()) ;
00751         req->cb = Callback<void, RPC< void > >();
00752         return ret;
00753     }
00754     typedef const RPCDefs<Borealis::Admin>::set_queries_status_OUT &set_queries_status_result;
00755     void subscribe(const Callback<void, RPC< void > >& completion, Subscription sub, unsigned int add_or_remove) const {
00756         RPCDefs<Borealis::Admin>::subscribe_IN *req =
00757             new RPCDefs<Borealis::Admin>::subscribe_IN(sub, add_or_remove);
00758         req->object_id = object_id();
00759         req->method_id = RPCDefs<Borealis::Admin>::subscribe_METHOD_ID;
00760         req->method_name = "subscribe";
00761         req->cb = completion;
00762         client().send_request(ptr<rpc_request>(req));
00763     }
00764     RPC< void > subscribe(Subscription sub, unsigned int add_or_remove) const {
00765         RPCDefs<Borealis::Admin>::subscribe_IN *req =
00766             new RPCDefs<Borealis::Admin>::subscribe_IN(sub, add_or_remove);
00767         ptr<rpc_request> preq(req);
00768         req->object_id = object_id();
00769         req->method_id = RPCDefs<Borealis::Admin>::subscribe_METHOD_ID;
00770         req->method_name = "subscribe";
00771         bool done = false; RPC< void > ret;
00772         req->cb = wrap(&rpc_sync_completion< void >, &done, &ret);
00773         client().send_request(preq);
00774         while (!done && client().block()) ;
00775         req->cb = Callback<void, RPC< void > >();
00776         return ret;
00777     }
00778     typedef const RPCDefs<Borealis::Admin>::subscribe_OUT &subscribe_result;
00779     void subscribe_many(const Callback<void, RPC< void > >& completion, vector<Subscription> sub, unsigned int add_or_remove) const {
00780         RPCDefs<Borealis::Admin>::subscribe_many_IN *req =
00781             new RPCDefs<Borealis::Admin>::subscribe_many_IN(sub, add_or_remove);
00782         req->object_id = object_id();
00783         req->method_id = RPCDefs<Borealis::Admin>::subscribe_many_METHOD_ID;
00784         req->method_name = "subscribe_many";
00785         req->cb = completion;
00786         client().send_request(ptr<rpc_request>(req));
00787     }
00788     RPC< void > subscribe_many(vector<Subscription> sub, unsigned int add_or_remove) const {
00789         RPCDefs<Borealis::Admin>::subscribe_many_IN *req =
00790             new RPCDefs<Borealis::Admin>::subscribe_many_IN(sub, add_or_remove);
00791         ptr<rpc_request> preq(req);
00792         req->object_id = object_id();
00793         req->method_id = RPCDefs<Borealis::Admin>::subscribe_many_METHOD_ID;
00794         req->method_name = "subscribe_many";
00795         bool done = false; RPC< void > ret;
00796         req->cb = wrap(&rpc_sync_completion< void >, &done, &ret);
00797         client().send_request(preq);
00798         while (!done && client().block()) ;
00799         req->cb = Callback<void, RPC< void > >();
00800         return ret;
00801     }
00802     typedef const RPCDefs<Borealis::Admin>::subscribe_many_OUT &subscribe_many_result;
00803     void create_and_start_queries(const Callback<void, RPC< void > >& completion, vector<Query> queries) const {
00804         RPCDefs<Borealis::Admin>::create_and_start_queries_IN *req =
00805             new RPCDefs<Borealis::Admin>::create_and_start_queries_IN(queries);
00806         req->object_id = object_id();
00807         req->method_id = RPCDefs<Borealis::Admin>::create_and_start_queries_METHOD_ID;
00808         req->method_name = "create_and_start_queries";
00809         req->cb = completion;
00810         client().send_request(ptr<rpc_request>(req));
00811     }
00812     RPC< void > create_and_start_queries(vector<Query> queries) const {
00813         RPCDefs<Borealis::Admin>::create_and_start_queries_IN *req =
00814             new RPCDefs<Borealis::Admin>::create_and_start_queries_IN(queries);
00815         ptr<rpc_request> preq(req);
00816         req->object_id = object_id();
00817         req->method_id = RPCDefs<Borealis::Admin>::create_and_start_queries_METHOD_ID;
00818         req->method_name = "create_and_start_queries";
00819         bool done = false; RPC< void > ret;
00820         req->cb = wrap(&rpc_sync_completion< void >, &done, &ret);
00821         client().send_request(preq);
00822         while (!done && client().block()) ;
00823         req->cb = Callback<void, RPC< void > >();
00824         return ret;
00825     }
00826     typedef const RPCDefs<Borealis::Admin>::create_and_start_queries_OUT &create_and_start_queries_result;
00827     void queries_and_subscriptions(const Callback<void, RPC< void > >& completion, vector<Query> queries, vector<Subscription> subs, unsigned int add_or_remove) const {
00828         RPCDefs<Borealis::Admin>::queries_and_subscriptions_IN *req =
00829             new RPCDefs<Borealis::Admin>::queries_and_subscriptions_IN(queries, subs, add_or_remove);
00830         req->object_id = object_id();
00831         req->method_id = RPCDefs<Borealis::Admin>::queries_and_subscriptions_METHOD_ID;
00832         req->method_name = "queries_and_subscriptions";
00833         req->cb = completion;
00834         client().send_request(ptr<rpc_request>(req));
00835     }
00836     RPC< void > queries_and_subscriptions(vector<Query> queries, vector<Subscription> subs, unsigned int add_or_remove) const {
00837         RPCDefs<Borealis::Admin>::queries_and_subscriptions_IN *req =
00838             new RPCDefs<Borealis::Admin>::queries_and_subscriptions_IN(queries, subs, add_or_remove);
00839         ptr<rpc_request> preq(req);
00840         req->object_id = object_id();
00841         req->method_id = RPCDefs<Borealis::Admin>::queries_and_subscriptions_METHOD_ID;
00842         req->method_name = "queries_and_subscriptions";
00843         bool done = false; RPC< void > ret;
00844         req->cb = wrap(&rpc_sync_completion< void >, &done, &ret);
00845         client().send_request(preq);
00846         while (!done && client().block()) ;
00847         req->cb = Callback<void, RPC< void > >();
00848         return ret;
00849     }
00850     typedef const RPCDefs<Borealis::Admin>::queries_and_subscriptions_OUT &queries_and_subscriptions_result;
00851     void move_load(const Callback<void, RPC< void > >& completion, vector<Name> query_names, string partner) const {
00852         RPCDefs<Borealis::Admin>::move_load_IN *req =
00853             new RPCDefs<Borealis::Admin>::move_load_IN(query_names, partner);
00854         req->object_id = object_id();
00855         req->method_id = RPCDefs<Borealis::Admin>::move_load_METHOD_ID;
00856         req->method_name = "move_load";
00857         req->cb = completion;
00858         client().send_request(ptr<rpc_request>(req));
00859     }
00860     RPC< void > move_load(vector<Name> query_names, string partner) const {
00861         RPCDefs<Borealis::Admin>::move_load_IN *req =
00862             new RPCDefs<Borealis::Admin>::move_load_IN(query_names, partner);
00863         ptr<rpc_request> preq(req);
00864         req->object_id = object_id();
00865         req->method_id = RPCDefs<Borealis::Admin>::move_load_METHOD_ID;
00866         req->method_name = "move_load";
00867         bool done = false; RPC< void > ret;
00868         req->cb = wrap(&rpc_sync_completion< void >, &done, &ret);
00869         client().send_request(preq);
00870         while (!done && client().block()) ;
00871         req->cb = Callback<void, RPC< void > >();
00872         return ret;
00873     }
00874     typedef const RPCDefs<Borealis::Admin>::move_load_OUT &move_load_result;
00875     void split_query(const Callback<void, RPC< void > >& completion, Name query_hunk_name, map<Name, vector<Name> > boxes_per_hunk) const {
00876         RPCDefs<Borealis::Admin>::split_query_IN *req =
00877             new RPCDefs<Borealis::Admin>::split_query_IN(query_hunk_name, boxes_per_hunk);
00878         req->object_id = object_id();
00879         req->method_id = RPCDefs<Borealis::Admin>::split_query_METHOD_ID;
00880         req->method_name = "split_query";
00881         req->cb = completion;
00882         client().send_request(ptr<rpc_request>(req));
00883     }
00884     RPC< void > split_query(Name query_hunk_name, map<Name, vector<Name> > boxes_per_hunk) const {
00885         RPCDefs<Borealis::Admin>::split_query_IN *req =
00886             new RPCDefs<Borealis::Admin>::split_query_IN(query_hunk_name, boxes_per_hunk);
00887         ptr<rpc_request> preq(req);
00888         req->object_id = object_id();
00889         req->method_id = RPCDefs<Borealis::Admin>::split_query_METHOD_ID;
00890         req->method_name = "split_query";
00891         bool done = false; RPC< void > ret;
00892         req->cb = wrap(&rpc_sync_completion< void >, &done, &ret);
00893         client().send_request(preq);
00894         while (!done && client().block()) ;
00895         req->cb = Callback<void, RPC< void > >();
00896         return ret;
00897     }
00898     typedef const RPCDefs<Borealis::Admin>::split_query_OUT &split_query_result;
00899     void merge_query(const Callback<void, RPC< void > >& completion, vector<Name> existing_query_hunk_names, Name new_query_hunk_name) const {
00900         RPCDefs<Borealis::Admin>::merge_query_IN *req =
00901             new RPCDefs<Borealis::Admin>::merge_query_IN(existing_query_hunk_names, new_query_hunk_name);
00902         req->object_id = object_id();
00903         req->method_id = RPCDefs<Borealis::Admin>::merge_query_METHOD_ID;
00904         req->method_name = "merge_query";
00905         req->cb = completion;
00906         client().send_request(ptr<rpc_request>(req));
00907     }
00908     RPC< void > merge_query(vector<Name> existing_query_hunk_names, Name new_query_hunk_name) const {
00909         RPCDefs<Borealis::Admin>::merge_query_IN *req =
00910             new RPCDefs<Borealis::Admin>::merge_query_IN(existing_query_hunk_names, new_query_hunk_name);
00911         ptr<rpc_request> preq(req);
00912         req->object_id = object_id();
00913         req->method_id = RPCDefs<Borealis::Admin>::merge_query_METHOD_ID;
00914         req->method_name = "merge_query";
00915         bool done = false; RPC< void > ret;
00916         req->cb = wrap(&rpc_sync_completion< void >, &done, &ret);
00917         client().send_request(preq);
00918         while (!done && client().block()) ;
00919         req->cb = Callback<void, RPC< void > >();
00920         return ret;
00921     }
00922     typedef const RPCDefs<Borealis::Admin>::merge_query_OUT &merge_query_result;
00923     void add_stream_observer(const Callback<void, RPC< InputStreamInfo > >& completion) const {
00924         RPCDefs<Borealis::Admin>::add_stream_observer_IN *req =
00925             new RPCDefs<Borealis::Admin>::add_stream_observer_IN();
00926         req->object_id = object_id();
00927         req->method_id = RPCDefs<Borealis::Admin>::add_stream_observer_METHOD_ID;
00928         req->method_name = "add_stream_observer";
00929         req->cb = completion;
00930         client().send_request(ptr<rpc_request>(req));
00931     }
00932     void add_query_observer(const Callback<void, RPC< Query > >& completion) const {
00933         RPCDefs<Borealis::Admin>::add_query_observer_IN *req =
00934             new RPCDefs<Borealis::Admin>::add_query_observer_IN();
00935         req->object_id = object_id();
00936         req->method_id = RPCDefs<Borealis::Admin>::add_query_observer_METHOD_ID;
00937         req->method_name = "add_query_observer";
00938         req->cb = completion;
00939         client().send_request(ptr<rpc_request>(req));
00940     }
00941     void add_sub_observer(const Callback<void, RPC< vector<Subscription> > >& completion) const {
00942         RPCDefs<Borealis::Admin>::add_sub_observer_IN *req =
00943             new RPCDefs<Borealis::Admin>::add_sub_observer_IN();
00944         req->object_id = object_id();
00945         req->method_id = RPCDefs<Borealis::Admin>::add_sub_observer_METHOD_ID;
00946         req->method_name = "add_sub_observer";
00947         req->cb = completion;
00948         client().send_request(ptr<rpc_request>(req));
00949     }
00950 };
00951 };
00952 template<> struct RPCDefs<Borealis::Admin> : __nmstl_tmp_rpc_defs::RPCDefs<Borealis::Admin> {};
00953 template<> struct Remote<Borealis::Admin> : __nmstl_tmp_rpc_defs::Remote<Borealis::Admin> {
00954     Remote<Borealis::Admin>() {}
00955     Remote<Borealis::Admin>(RPCClient& cli, rpc_object_id object_id) :
00956         __nmstl_tmp_rpc_defs::Remote<Borealis::Admin>(cli, object_id) {}
00957 
00958     Remote<Borealis::Admin>(const __nmstl_tmp_rpc_defs::Remote<Borealis::Admin>& x) :
00959         __nmstl_tmp_rpc_defs::Remote<Borealis::Admin>(x) {}
00960 };
00961 
00962 
00963 #endif // !defined(DOXYGEN_SKIP)
00964 
00965 NMSTL_NAMESPACE_END;
00966 
00967 #endif // !defined(___ADMIN_RPC_ADMIN_H)
00968 
00969 
00970 
00971 
00972 
00973 #ifdef NMSTL_RPC_DEFINE
00974 
00975 #include <string>
00976 #include <map>
00977 #include <NMSTL/rpc>
00978 
00979 void Borealis::Admin::handle_request(const NMSTL::RPCObject::response_cb& cb, const NMSTL::ptr<NMSTL::rpc_request>& req) {
00980     switch(req->method_id) {
00981       case NMSTL::RPCDefs<Borealis::Admin>::create_schema_METHOD_ID:
00982         {
00983             const NMSTL::RPCDefs<Borealis::Admin>::create_schema_IN* inp =
00984                 dynamic_cast<const NMSTL::RPCDefs<Borealis::Admin>::create_schema_IN*>(req.get());
00985 
00986             if (!inp) {
00987                 string err = string("Invalid RPC request type ") + typeid(*(req.get())) +
00988                      " to Borealis::Admin::create_schema; expected " +
00989                      typeid(NMSTL::RPCDefs<Borealis::Admin>::create_schema_IN);
00990                 WARN << err;
00991                 cb(err, 0, true);
00992                 return;
00993             }
00994 
00995             const NMSTL::RPCDefs<Borealis::Admin>::create_schema_IN& in = *inp;
00996             NMSTL::AsyncRPC< void > pending = create_schema(in.schema);
00997             pending.set_response_handler(cb);
00998             break;
00999         }
01000       case NMSTL::RPCDefs<Borealis::Admin>::create_stream_METHOD_ID:
01001         {
01002             const NMSTL::RPCDefs<Borealis::Admin>::create_stream_IN* inp =
01003                 dynamic_cast<const NMSTL::RPCDefs<Borealis::Admin>::create_stream_IN*>(req.get());
01004 
01005             if (!inp) {
01006                 string err = string("Invalid RPC request type ") + typeid(*(req.get())) +
01007                      " to Borealis::Admin::create_stream; expected " +
01008                      typeid(NMSTL::RPCDefs<Borealis::Admin>::create_stream_IN);
01009                 WARN << err;
01010                 cb(err, 0, true);
01011                 return;
01012             }
01013 
01014             const NMSTL::RPCDefs<Borealis::Admin>::create_stream_IN& in = *inp;
01015             NMSTL::AsyncRPC< void > pending = create_stream(in.streamdef);
01016             pending.set_response_handler(cb);
01017             break;
01018         }
01019       case NMSTL::RPCDefs<Borealis::Admin>::create_cp_METHOD_ID:
01020         {
01021             const NMSTL::RPCDefs<Borealis::Admin>::create_cp_IN* inp =
01022                 dynamic_cast<const NMSTL::RPCDefs<Borealis::Admin>::create_cp_IN*>(req.get());
01023 
01024             if (!inp) {
01025                 string err = string("Invalid RPC request type ") + typeid(*(req.get())) +
01026                      " to Borealis::Admin::create_cp; expected " +
01027                      typeid(NMSTL::RPCDefs<Borealis::Admin>::create_cp_IN);
01028                 WARN << err;
01029                 cb(err, 0, true);
01030                 return;
01031             }
01032 
01033             const NMSTL::RPCDefs<Borealis::Admin>::create_cp_IN& in = *inp;
01034             NMSTL::AsyncRPC< void > pending = create_cp(in.view_desc, in.streamdef);
01035             pending.set_response_handler(cb);
01036             break;
01037         }
01038       case NMSTL::RPCDefs<Borealis::Admin>::create_query_METHOD_ID:
01039         {
01040             const NMSTL::RPCDefs<Borealis::Admin>::create_query_IN* inp =
01041                 dynamic_cast<const NMSTL::RPCDefs<Borealis::Admin>::create_query_IN*>(req.get());
01042 
01043             if (!inp) {
01044                 string err = string("Invalid RPC request type ") + typeid(*(req.get())) +
01045                      " to Borealis::Admin::create_query; expected " +
01046                      typeid(NMSTL::RPCDefs<Borealis::Admin>::create_query_IN);
01047                 WARN << err;
01048                 cb(err, 0, true);
01049                 return;
01050             }
01051 
01052             const NMSTL::RPCDefs<Borealis::Admin>::create_query_IN& in = *inp;
01053             NMSTL::AsyncRPC< void > pending = create_query(in.query);
01054             pending.set_response_handler(cb);
01055             break;
01056         }
01057       case NMSTL::RPCDefs<Borealis::Admin>::create_query_xml_METHOD_ID:
01058         {
01059             const NMSTL::RPCDefs<Borealis::Admin>::create_query_xml_IN* inp =
01060                 dynamic_cast<const NMSTL::RPCDefs<Borealis::Admin>::create_query_xml_IN*>(req.get());
01061 
01062             if (!inp) {
01063                 string err = string("Invalid RPC request type ") + typeid(*(req.get())) +
01064                      " to Borealis::Admin::create_query_xml; expected " +
01065                      typeid(NMSTL::RPCDefs<Borealis::Admin>::create_query_xml_IN);
01066                 WARN << err;
01067                 cb(err, 0, true);
01068                 return;
01069             }
01070 
01071             const NMSTL::RPCDefs<Borealis::Admin>::create_query_xml_IN& in = *inp;
01072             NMSTL::AsyncRPC< void > pending = create_query_xml(in.query);
01073             pending.set_response_handler(cb);
01074             break;
01075         }
01076       case NMSTL::RPCDefs<Borealis::Admin>::set_query_status_METHOD_ID:
01077         {
01078             const NMSTL::RPCDefs<Borealis::Admin>::set_query_status_IN* inp =
01079                 dynamic_cast<const NMSTL::RPCDefs<Borealis::Admin>::set_query_status_IN*>(req.get());
01080 
01081             if (!inp) {
01082                 string err = string("Invalid RPC request type ") + typeid(*(req.get())) +
01083                      " to Borealis::Admin::set_query_status; expected " +
01084                      typeid(NMSTL::RPCDefs<Borealis::Admin>::set_query_status_IN);
01085                 WARN << err;
01086                 cb(err, 0, true);
01087                 return;
01088             }
01089 
01090             const NMSTL::RPCDefs<Borealis::Admin>::set_query_status_IN& in = *inp;
01091             NMSTL::AsyncRPC< void > pending = set_query_status(in.name, in.status);
01092             pending.set_response_handler(cb);
01093             break;
01094         }
01095       case NMSTL::RPCDefs<Borealis::Admin>::set_queries_status_METHOD_ID:
01096         {
01097             const NMSTL::RPCDefs<Borealis::Admin>::set_queries_status_IN* inp =
01098                 dynamic_cast<const NMSTL::RPCDefs<Borealis::Admin>::set_queries_status_IN*>(req.get());
01099 
01100             if (!inp) {
01101                 string err = string("Invalid RPC request type ") + typeid(*(req.get())) +
01102                      " to Borealis::Admin::set_queries_status; expected " +
01103                      typeid(NMSTL::RPCDefs<Borealis::Admin>::set_queries_status_IN);
01104                 WARN << err;
01105                 cb(err, 0, true);
01106                 return;
01107             }
01108 
01109             const NMSTL::RPCDefs<Borealis::Admin>::set_queries_status_IN& in = *inp;
01110             NMSTL::AsyncRPC< void > pending = set_queries_status(in.name, in.status);
01111             pending.set_response_handler(cb);
01112             break;
01113         }
01114       case NMSTL::RPCDefs<Borealis::Admin>::subscribe_METHOD_ID:
01115         {
01116             const NMSTL::RPCDefs<Borealis::Admin>::subscribe_IN* inp =
01117                 dynamic_cast<const NMSTL::RPCDefs<Borealis::Admin>::subscribe_IN*>(req.get());
01118 
01119             if (!inp) {
01120                 string err = string("Invalid RPC request type ") + typeid(*(req.get())) +
01121                      " to Borealis::Admin::subscribe; expected " +
01122                      typeid(NMSTL::RPCDefs<Borealis::Admin>::subscribe_IN);
01123                 WARN << err;
01124                 cb(err, 0, true);
01125                 return;
01126             }
01127 
01128             const NMSTL::RPCDefs<Borealis::Admin>::subscribe_IN& in = *inp;
01129             NMSTL::AsyncRPC< void > pending = subscribe(in.sub, in.add_or_remove);
01130             pending.set_response_handler(cb);
01131             break;
01132         }
01133       case NMSTL::RPCDefs<Borealis::Admin>::subscribe_many_METHOD_ID:
01134         {
01135             const NMSTL::RPCDefs<Borealis::Admin>::subscribe_many_IN* inp =
01136                 dynamic_cast<const NMSTL::RPCDefs<Borealis::Admin>::subscribe_many_IN*>(req.get());
01137 
01138             if (!inp) {
01139                 string err = string("Invalid RPC request type ") + typeid(*(req.get())) +
01140                      " to Borealis::Admin::subscribe_many; expected " +
01141                      typeid(NMSTL::RPCDefs<Borealis::Admin>::subscribe_many_IN);
01142                 WARN << err;
01143                 cb(err, 0, true);
01144                 return;
01145             }
01146 
01147             const NMSTL::RPCDefs<Borealis::Admin>::subscribe_many_IN& in = *inp;
01148             NMSTL::AsyncRPC< void > pending = subscribe_many(in.sub, in.add_or_remove);
01149             pending.set_response_handler(cb);
01150             break;
01151         }
01152       case NMSTL::RPCDefs<Borealis::Admin>::create_and_start_queries_METHOD_ID:
01153         {
01154             const NMSTL::RPCDefs<Borealis::Admin>::create_and_start_queries_IN* inp =
01155                 dynamic_cast<const NMSTL::RPCDefs<Borealis::Admin>::create_and_start_queries_IN*>(req.get());
01156 
01157             if (!inp) {
01158                 string err = string("Invalid RPC request type ") + typeid(*(req.get())) +
01159                      " to Borealis::Admin::create_and_start_queries; expected " +
01160                      typeid(NMSTL::RPCDefs<Borealis::Admin>::create_and_start_queries_IN);
01161                 WARN << err;
01162                 cb(err, 0, true);
01163                 return;
01164             }
01165 
01166             const NMSTL::RPCDefs<Borealis::Admin>::create_and_start_queries_IN& in = *inp;
01167             NMSTL::AsyncRPC< void > pending = create_and_start_queries(in.queries);
01168             pending.set_response_handler(cb);
01169             break;
01170         }
01171       case NMSTL::RPCDefs<Borealis::Admin>::queries_and_subscriptions_METHOD_ID:
01172         {
01173             const NMSTL::RPCDefs<Borealis::Admin>::queries_and_subscriptions_IN* inp =
01174                 dynamic_cast<const NMSTL::RPCDefs<Borealis::Admin>::queries_and_subscriptions_IN*>(req.get());
01175 
01176             if (!inp) {
01177                 string err = string("Invalid RPC request type ") + typeid(*(req.get())) +
01178                      " to Borealis::Admin::queries_and_subscriptions; expected " +
01179                      typeid(NMSTL::RPCDefs<Borealis::Admin>::queries_and_subscriptions_IN);
01180                 WARN << err;
01181                 cb(err, 0, true);
01182                 return;
01183             }
01184 
01185             const NMSTL::RPCDefs<Borealis::Admin>::queries_and_subscriptions_IN& in = *inp;
01186             NMSTL::AsyncRPC< void > pending = queries_and_subscriptions(in.queries, in.subs, in.add_or_remove);
01187             pending.set_response_handler(cb);
01188             break;
01189         }
01190       case NMSTL::RPCDefs<Borealis::Admin>::move_load_METHOD_ID:
01191         {
01192             const NMSTL::RPCDefs<Borealis::Admin>::move_load_IN* inp =
01193                 dynamic_cast<const NMSTL::RPCDefs<Borealis::Admin>::move_load_IN*>(req.get());
01194 
01195             if (!inp) {
01196                 string err = string("Invalid RPC request type ") + typeid(*(req.get())) +
01197                      " to Borealis::Admin::move_load; expected " +
01198                      typeid(NMSTL::RPCDefs<Borealis::Admin>::move_load_IN);
01199                 WARN << err;
01200                 cb(err, 0, true);
01201                 return;
01202             }
01203 
01204             const NMSTL::RPCDefs<Borealis::Admin>::move_load_IN& in = *inp;
01205             NMSTL::AsyncRPC< void > pending = move_load(in.query_names, in.partner);
01206             pending.set_response_handler(cb);
01207             break;
01208         }
01209       case NMSTL::RPCDefs<Borealis::Admin>::split_query_METHOD_ID:
01210         {
01211             const NMSTL::RPCDefs<Borealis::Admin>::split_query_IN* inp =
01212                 dynamic_cast<const NMSTL::RPCDefs<Borealis::Admin>::split_query_IN*>(req.get());
01213 
01214             if (!inp) {
01215                 string err = string("Invalid RPC request type ") + typeid(*(req.get())) +
01216                      " to Borealis::Admin::split_query; expected " +
01217                      typeid(NMSTL::RPCDefs<Borealis::Admin>::split_query_IN);
01218                 WARN << err;
01219                 cb(err, 0, true);
01220                 return;
01221             }
01222 
01223             const NMSTL::RPCDefs<Borealis::Admin>::split_query_IN& in = *inp;
01224             NMSTL::AsyncRPC< void > pending = split_query(in.query_hunk_name, in.boxes_per_hunk);
01225             pending.set_response_handler(cb);
01226             break;
01227         }
01228       case NMSTL::RPCDefs<Borealis::Admin>::merge_query_METHOD_ID:
01229         {
01230             const NMSTL::RPCDefs<Borealis::Admin>::merge_query_IN* inp =
01231                 dynamic_cast<const NMSTL::RPCDefs<Borealis::Admin>::merge_query_IN*>(req.get());
01232 
01233             if (!inp) {
01234                 string err = string("Invalid RPC request type ") + typeid(*(req.get())) +
01235                      " to Borealis::Admin::merge_query; expected " +
01236                      typeid(NMSTL::RPCDefs<Borealis::Admin>::merge_query_IN);
01237                 WARN << err;
01238                 cb(err, 0, true);
01239                 return;
01240             }
01241 
01242             const NMSTL::RPCDefs<Borealis::Admin>::merge_query_IN& in = *inp;
01243             NMSTL::AsyncRPC< void > pending = merge_query(in.existing_query_hunk_names, in.new_query_hunk_name);
01244             pending.set_response_handler(cb);
01245             break;
01246         }
01247       case NMSTL::RPCDefs<Borealis::Admin>::add_stream_observer_METHOD_ID:
01248         {
01249             const NMSTL::RPCDefs<Borealis::Admin>::add_stream_observer_IN* inp =
01250                 dynamic_cast<const NMSTL::RPCDefs<Borealis::Admin>::add_stream_observer_IN*>(req.get());
01251 
01252             if (!inp) {
01253                 string err = string("Invalid RPC request type ") + typeid(*(req.get())) +
01254                      " to Borealis::Admin::add_stream_observer; expected " +
01255                      typeid(NMSTL::RPCDefs<Borealis::Admin>::add_stream_observer_IN);
01256                 WARN << err;
01257                 cb(err, 0, true);
01258                 return;
01259             }
01260 
01261             NMSTL::MultiRPC< InputStreamInfo > pending = add_stream_observer();
01262             pending.set_response_handler(cb);
01263             break;
01264         }
01265       case NMSTL::RPCDefs<Borealis::Admin>::add_query_observer_METHOD_ID:
01266         {
01267             const NMSTL::RPCDefs<Borealis::Admin>::add_query_observer_IN* inp =
01268                 dynamic_cast<const NMSTL::RPCDefs<Borealis::Admin>::add_query_observer_IN*>(req.get());
01269 
01270             if (!inp) {
01271                 string err = string("Invalid RPC request type ") + typeid(*(req.get())) +
01272                      " to Borealis::Admin::add_query_observer; expected " +
01273                      typeid(NMSTL::RPCDefs<Borealis::Admin>::add_query_observer_IN);
01274                 WARN << err;
01275                 cb(err, 0, true);
01276                 return;
01277             }
01278 
01279             NMSTL::MultiRPC< Query > pending = add_query_observer();
01280             pending.set_response_handler(cb);
01281             break;
01282         }
01283       case NMSTL::RPCDefs<Borealis::Admin>::add_sub_observer_METHOD_ID:
01284         {
01285             const NMSTL::RPCDefs<Borealis::Admin>::add_sub_observer_IN* inp =
01286                 dynamic_cast<const NMSTL::RPCDefs<Borealis::Admin>::add_sub_observer_IN*>(req.get());
01287 
01288             if (!inp) {
01289                 string err = string("Invalid RPC request type ") + typeid(*(req.get())) +
01290                      " to Borealis::Admin::add_sub_observer; expected " +
01291                      typeid(NMSTL::RPCDefs<Borealis::Admin>::add_sub_observer_IN);
01292                 WARN << err;
01293                 cb(err, 0, true);
01294                 return;
01295             }
01296 
01297             NMSTL::MultiRPC< vector<Subscription> > pending = add_sub_observer();
01298             pending.set_response_handler(cb);
01299             break;
01300         }
01301       default:
01302         string err = string("Unknown method_id ") + req->method_id + " in Borealis::Admin::handle_request";
01303         WARN << err;
01304         cb(err, 0, true);
01305     }
01306 }
01307 void Borealis::Admin::handle_request(const response_cb& cb, rpc_id method_id, ISerial& is) {
01308     switch(method_id) {
01309       case RPCDefs<Borealis::Admin>::create_schema_METHOD_ID:
01310         {
01311             RPCDefs<Borealis::Admin>::create_schema_IN in;
01312             is >> in;
01313             if (!is) {
01314                 WARN << "Invalid RPC request to Borealis::Admin::create_schema: " << is.stat();
01315                 cb(is.stat(), 0, true);
01316                 return;
01317             }
01318             DEBUG << "Handling create_schema";
01319             AsyncRPC< void > pending = create_schema(in.schema);
01320             pending.set_response_handler(cb);
01321             break;
01322         }
01323       case RPCDefs<Borealis::Admin>::create_stream_METHOD_ID:
01324         {
01325             RPCDefs<Borealis::Admin>::create_stream_IN in;
01326             is >> in;
01327             if (!is) {
01328                 WARN << "Invalid RPC request to Borealis::Admin::create_stream: " << is.stat();
01329                 cb(is.stat(), 0, true);
01330                 return;
01331             }
01332             DEBUG << "Handling create_stream";
01333             AsyncRPC< void > pending = create_stream(in.streamdef);
01334             pending.set_response_handler(cb);
01335             break;
01336         }
01337       case RPCDefs<Borealis::Admin>::create_cp_METHOD_ID:
01338         {
01339             RPCDefs<Borealis::Admin>::create_cp_IN in;
01340             is >> in;
01341             if (!is) {
01342                 WARN << "Invalid RPC request to Borealis::Admin::create_cp: " << is.stat();
01343                 cb(is.stat(), 0, true);
01344                 return;
01345             }
01346             DEBUG << "Handling create_cp";
01347             AsyncRPC< void > pending = create_cp(in.view_desc, in.streamdef);
01348             pending.set_response_handler(cb);
01349             break;
01350         }
01351       case RPCDefs<Borealis::Admin>::create_query_METHOD_ID:
01352         {
01353             RPCDefs<Borealis::Admin>::create_query_IN in;
01354             is >> in;
01355             if (!is) {
01356                 WARN << "Invalid RPC request to Borealis::Admin::create_query: " << is.stat();
01357                 cb(is.stat(), 0, true);
01358                 return;
01359             }
01360             DEBUG << "Handling create_query";
01361             AsyncRPC< void > pending = create_query(in.query);
01362             pending.set_response_handler(cb);
01363             break;
01364         }
01365       case RPCDefs<Borealis::Admin>::create_query_xml_METHOD_ID:
01366         {
01367             RPCDefs<Borealis::Admin>::create_query_xml_IN in;
01368             is >> in;
01369             if (!is) {
01370                 WARN << "Invalid RPC request to Borealis::Admin::create_query_xml: " << is.stat();
01371                 cb(is.stat(), 0, true);
01372                 return;
01373             }
01374             DEBUG << "Handling create_query_xml";
01375             AsyncRPC< void > pending = create_query_xml(in.query);
01376             pending.set_response_handler(cb);
01377             break;
01378         }
01379       case RPCDefs<Borealis::Admin>::set_query_status_METHOD_ID:
01380         {
01381             RPCDefs<Borealis::Admin>::set_query_status_IN in;
01382             is >> in;
01383             if (!is) {
01384                 WARN << "Invalid RPC request to Borealis::Admin::set_query_status: " << is.stat();
01385                 cb(is.stat(), 0, true);
01386                 return;
01387             }
01388             DEBUG << "Handling set_query_status";
01389             AsyncRPC< void > pending = set_query_status(in.name, in.status);
01390             pending.set_response_handler(cb);
01391             break;
01392         }
01393       case RPCDefs<Borealis::Admin>::set_queries_status_METHOD_ID:
01394         {
01395             RPCDefs<Borealis::Admin>::set_queries_status_IN in;
01396             is >> in;
01397             if (!is) {
01398                 WARN << "Invalid RPC request to Borealis::Admin::set_queries_status: " << is.stat();
01399                 cb(is.stat(), 0, true);
01400                 return;
01401             }
01402             DEBUG << "Handling set_queries_status";
01403             AsyncRPC< void > pending = set_queries_status(in.name, in.status);
01404             pending.set_response_handler(cb);
01405             break;
01406         }
01407       case RPCDefs<Borealis::Admin>::subscribe_METHOD_ID:
01408         {
01409             RPCDefs<Borealis::Admin>::subscribe_IN in;
01410             is >> in;
01411             if (!is) {
01412                 WARN << "Invalid RPC request to Borealis::Admin::subscribe: " << is.stat();
01413                 cb(is.stat(), 0, true);
01414                 return;
01415             }
01416             DEBUG << "Handling subscribe";
01417             AsyncRPC< void > pending = subscribe(in.sub, in.add_or_remove);
01418             pending.set_response_handler(cb);
01419             break;
01420         }
01421       case RPCDefs<Borealis::Admin>::subscribe_many_METHOD_ID:
01422         {
01423             RPCDefs<Borealis::Admin>::subscribe_many_IN in;
01424             is >> in;
01425             if (!is) {
01426                 WARN << "Invalid RPC request to Borealis::Admin::subscribe_many: " << is.stat();
01427                 cb(is.stat(), 0, true);
01428                 return;
01429             }
01430             DEBUG << "Handling subscribe_many";
01431             AsyncRPC< void > pending = subscribe_many(in.sub, in.add_or_remove);
01432             pending.set_response_handler(cb);
01433             break;
01434         }
01435       case RPCDefs<Borealis::Admin>::create_and_start_queries_METHOD_ID:
01436         {
01437             RPCDefs<Borealis::Admin>::create_and_start_queries_IN in;
01438             is >> in;
01439             if (!is) {
01440                 WARN << "Invalid RPC request to Borealis::Admin::create_and_start_queries: " << is.stat();
01441                 cb(is.stat(), 0, true);
01442                 return;
01443             }
01444             DEBUG << "Handling create_and_start_queries";
01445             AsyncRPC< void > pending = create_and_start_queries(in.queries);
01446             pending.set_response_handler(cb);
01447             break;
01448         }
01449       case RPCDefs<Borealis::Admin>::queries_and_subscriptions_METHOD_ID:
01450         {
01451             RPCDefs<Borealis::Admin>::queries_and_subscriptions_IN in;
01452             is >> in;
01453             if (!is) {
01454                 WARN << "Invalid RPC request to Borealis::Admin::queries_and_subscriptions: " << is.stat();
01455                 cb(is.stat(), 0, true);
01456                 return;
01457             }
01458             DEBUG << "Handling queries_and_subscriptions";
01459             AsyncRPC< void > pending = queries_and_subscriptions(in.queries, in.subs, in.add_or_remove);
01460             pending.set_response_handler(cb);
01461             break;
01462         }
01463       case RPCDefs<Borealis::Admin>::move_load_METHOD_ID:
01464         {
01465             RPCDefs<Borealis::Admin>::move_load_IN in;
01466             is >> in;
01467             if (!is) {
01468                 WARN << "Invalid RPC request to Borealis::Admin::move_load: " << is.stat();
01469                 cb(is.stat(), 0, true);
01470                 return;
01471             }
01472             DEBUG << "Handling move_load";
01473             AsyncRPC< void > pending = move_load(in.query_names, in.partner);
01474             pending.set_response_handler(cb);
01475             break;
01476         }
01477       case RPCDefs<Borealis::Admin>::split_query_METHOD_ID:
01478         {
01479             RPCDefs<Borealis::Admin>::split_query_IN in;
01480             is >> in;
01481             if (!is) {
01482                 WARN << "Invalid RPC request to Borealis::Admin::split_query: " << is.stat();
01483                 cb(is.stat(), 0, true);
01484                 return;
01485             }
01486             DEBUG << "Handling split_query";
01487             AsyncRPC< void > pending = split_query(in.query_hunk_name, in.boxes_per_hunk);
01488             pending.set_response_handler(cb);
01489             break;
01490         }
01491       case RPCDefs<Borealis::Admin>::merge_query_METHOD_ID:
01492         {
01493             RPCDefs<Borealis::Admin>::merge_query_IN in;
01494             is >> in;
01495             if (!is) {
01496                 WARN << "Invalid RPC request to Borealis::Admin::merge_query: " << is.stat();
01497                 cb(is.stat(), 0, true);
01498                 return;
01499             }
01500             DEBUG << "Handling merge_query";
01501             AsyncRPC< void > pending = merge_query(in.existing_query_hunk_names, in.new_query_hunk_name);
01502             pending.set_response_handler(cb);
01503             break;
01504         }
01505       case RPCDefs<Borealis::Admin>::add_stream_observer_METHOD_ID:
01506         {
01507             RPCDefs<Borealis::Admin>::add_stream_observer_IN in;
01508             is >> in;
01509             if (!is) {
01510                 WARN << "Invalid RPC request to Borealis::Admin::add_stream_observer: " << is.stat();
01511                 cb(is.stat(), 0, true);
01512                 return;
01513             }
01514             DEBUG << "Handling add_stream_observer";
01515             MultiRPC< InputStreamInfo > pending = add_stream_observer();
01516             pending.set_response_handler(cb);
01517             break;
01518         }
01519       case RPCDefs<Borealis::Admin>::add_query_observer_METHOD_ID:
01520         {
01521             RPCDefs<Borealis::Admin>::add_query_observer_IN in;
01522             is >> in;
01523             if (!is) {
01524                 WARN << "Invalid RPC request to Borealis::Admin::add_query_observer: " << is.stat();
01525                 cb(is.stat(), 0, true);
01526                 return;
01527             }
01528             DEBUG << "Handling add_query_observer";
01529             MultiRPC< Query > pending = add_query_observer();
01530             pending.set_response_handler(cb);
01531             break;
01532         }
01533       case RPCDefs<Borealis::Admin>::add_sub_observer_METHOD_ID:
01534         {
01535             RPCDefs<Borealis::Admin>::add_sub_observer_IN in;
01536             is >> in;
01537             if (!is) {
01538                 WARN << "Invalid RPC request to Borealis::Admin::add_sub_observer: " << is.stat();
01539                 cb(is.stat(), 0, true);
01540                 return;
01541             }
01542             DEBUG << "Handling add_sub_observer";
01543             MultiRPC< vector<Subscription> > pending = add_sub_observer();
01544             pending.set_response_handler(cb);
01545             break;
01546         }
01547       default:
01548         string err = string("Unknown method_id ") + method_id + " in Borealis::Admin::handle_request";
01549         WARN << err;
01550         cb(err, 0, true);
01551     }
01552 }
01553 NMSTL::rpc_id Borealis::Admin::method_id_for_name(string method_name) {
01554     map<string, int>::const_iterator i = RPCDefs<Borealis::Admin>::method_id_by_name().find(method_name);
01555     return (i == RPCDefs<Borealis::Admin>::method_id_by_name().end()) ? rpc_id() : i->second;
01556 }
01557 string Borealis::Admin::method_name_for_id(NMSTL::rpc_id method_id) {
01558     map<int, string>::const_iterator i = RPCDefs<Borealis::Admin>::method_name_by_id().find(method_id);
01559     return (i == RPCDefs<Borealis::Admin>::method_name_by_id().end()) ? string() : i->second;
01560 }
01561 NMSTL::ptr<NMSTL::rpc_request> Borealis::Admin::make_request(NMSTL::rpc_id method_id, NMSTL::ISerial& is) {
01562     switch(method_id) {
01563       case NMSTL::RPCDefs<Borealis::Admin>::create_schema_METHOD_ID:
01564         {
01565             NMSTL::RPCDefs<Borealis::Admin>::create_schema_IN *in = new NMSTL::RPCDefs<Borealis::Admin>::create_schema_IN;
01566             NMSTL::ptr<NMSTL::rpc_request> req(in);
01567             if (is >> *in) return req;
01568         }
01569       case NMSTL::RPCDefs<Borealis::Admin>::create_stream_METHOD_ID:
01570         {
01571             NMSTL::RPCDefs<Borealis::Admin>::create_stream_IN *in = new NMSTL::RPCDefs<Borealis::Admin>::create_stream_IN;
01572             NMSTL::ptr<NMSTL::rpc_request> req(in);
01573             if (is >> *in) return req;
01574         }
01575       case NMSTL::RPCDefs<Borealis::Admin>::create_cp_METHOD_ID:
01576         {
01577             NMSTL::RPCDefs<Borealis::Admin>::create_cp_IN *in = new NMSTL::RPCDefs<Borealis::Admin>::create_cp_IN;
01578             NMSTL::ptr<NMSTL::rpc_request> req(in);
01579             if (is >> *in) return req;
01580         }
01581       case NMSTL::RPCDefs<Borealis::Admin>::create_query_METHOD_ID:
01582         {
01583             NMSTL::RPCDefs<Borealis::Admin>::create_query_IN *in = new NMSTL::RPCDefs<Borealis::Admin>::create_query_IN;
01584             NMSTL::ptr<NMSTL::rpc_request> req(in);
01585             if (is >> *in) return req;
01586         }
01587       case NMSTL::RPCDefs<Borealis::Admin>::create_query_xml_METHOD_ID:
01588         {
01589             NMSTL::RPCDefs<Borealis::Admin>::create_query_xml_IN *in = new NMSTL::RPCDefs<Borealis::Admin>::create_query_xml_IN;
01590             NMSTL::ptr<NMSTL::rpc_request> req(in);
01591             if (is >> *in) return req;
01592         }
01593       case NMSTL::RPCDefs<Borealis::Admin>::set_query_status_METHOD_ID:
01594         {
01595             NMSTL::RPCDefs<Borealis::Admin>::set_query_status_IN *in = new NMSTL::RPCDefs<Borealis::Admin>::set_query_status_IN;
01596             NMSTL::ptr<NMSTL::rpc_request> req(in);
01597             if (is >> *in) return req;
01598         }
01599       case NMSTL::RPCDefs<Borealis::Admin>::set_queries_status_METHOD_ID:
01600         {
01601             NMSTL::RPCDefs<Borealis::Admin>::set_queries_status_IN *in = new NMSTL::RPCDefs<Borealis::Admin>::set_queries_status_IN;
01602             NMSTL::ptr<NMSTL::rpc_request> req(in);
01603             if (is >> *in) return req;
01604         }
01605       case NMSTL::RPCDefs<Borealis::Admin>::subscribe_METHOD_ID:
01606         {
01607             NMSTL::RPCDefs<Borealis::Admin>::subscribe_IN *in = new NMSTL::RPCDefs<Borealis::Admin>::subscribe_IN;
01608             NMSTL::ptr<NMSTL::rpc_request> req(in);
01609             if (is >> *in) return req;
01610         }
01611       case NMSTL::RPCDefs<Borealis::Admin>::subscribe_many_METHOD_ID:
01612         {
01613             NMSTL::RPCDefs<Borealis::Admin>::subscribe_many_IN *in = new NMSTL::RPCDefs<Borealis::Admin>::subscribe_many_IN;
01614             NMSTL::ptr<NMSTL::rpc_request> req(in);
01615             if (is >> *in) return req;
01616         }
01617       case NMSTL::RPCDefs<Borealis::Admin>::create_and_start_queries_METHOD_ID:
01618         {
01619             NMSTL::RPCDefs<Borealis::Admin>::create_and_start_queries_IN *in = new NMSTL::RPCDefs<Borealis::Admin>::create_and_start_queries_IN;
01620             NMSTL::ptr<NMSTL::rpc_request> req(in);
01621             if (is >> *in) return req;
01622         }
01623       case NMSTL::RPCDefs<Borealis::Admin>::queries_and_subscriptions_METHOD_ID:
01624         {
01625             NMSTL::RPCDefs<Borealis::Admin>::queries_and_subscriptions_IN *in = new NMSTL::RPCDefs<Borealis::Admin>::queries_and_subscriptions_IN;
01626             NMSTL::ptr<NMSTL::rpc_request> req(in);
01627             if (is >> *in) return req;
01628         }
01629       case NMSTL::RPCDefs<Borealis::Admin>::move_load_METHOD_ID:
01630         {
01631             NMSTL::RPCDefs<Borealis::Admin>::move_load_IN *in = new NMSTL::RPCDefs<Borealis::Admin>::move_load_IN;
01632             NMSTL::ptr<NMSTL::rpc_request> req(in);
01633             if (is >> *in) return req;
01634         }
01635       case NMSTL::RPCDefs<Borealis::Admin>::split_query_METHOD_ID:
01636         {
01637             NMSTL::RPCDefs<Borealis::Admin>::split_query_IN *in = new NMSTL::RPCDefs<Borealis::Admin>::split_query_IN;
01638             NMSTL::ptr<NMSTL::rpc_request> req(in);
01639             if (is >> *in) return req;
01640         }
01641       case NMSTL::RPCDefs<Borealis::Admin>::merge_query_METHOD_ID:
01642         {
01643             NMSTL::RPCDefs<Borealis::Admin>::merge_query_IN *in = new NMSTL::RPCDefs<Borealis::Admin>::merge_query_IN;
01644             NMSTL::ptr<NMSTL::rpc_request> req(in);
01645             if (is >> *in) return req;
01646         }
01647       case NMSTL::RPCDefs<Borealis::Admin>::add_stream_observer_METHOD_ID:
01648         {
01649             NMSTL::RPCDefs<Borealis::Admin>::add_stream_observer_IN *in = new NMSTL::RPCDefs<Borealis::Admin>::add_stream_observer_IN;
01650             NMSTL::ptr<NMSTL::rpc_request> req(in);
01651             if (is >> *in) return req;
01652         }
01653       case NMSTL::RPCDefs<Borealis::Admin>::add_query_observer_METHOD_ID:
01654         {
01655             NMSTL::RPCDefs<Borealis::Admin>::add_query_observer_IN *in = new NMSTL::RPCDefs<Borealis::Admin>::add_query_observer_IN;
01656             NMSTL::ptr<NMSTL::rpc_request> req(in);
01657             if (is >> *in) return req;
01658         }
01659       case NMSTL::RPCDefs<Borealis::Admin>::add_sub_observer_METHOD_ID:
01660         {
01661             NMSTL::RPCDefs<Borealis::Admin>::add_sub_observer_IN *in = new NMSTL::RPCDefs<Borealis::Admin>::add_sub_observer_IN;
01662             NMSTL::ptr<NMSTL::rpc_request> req(in);
01663             if (is >> *in) return req;
01664         }
01665     }
01666     return NMSTL::ptr<NMSTL::rpc_request>();
01667 }
01668 
01669 
01670 #endif
01671
Generated on Fri Nov 12 15:15:21 2004 for Borealis by doxygen 1.3.8