Borealis: rpc_CentralLookupServer.h Source File

00001 /***** 00002 * 00003 * ../../src/rpc_CentralLookupServer.h 00004 * 00005 * Include this file to gain access to the following classes: 00006 * 00007 * - Remote<CentralLookupServer> 00008 * 00009 * This file is automatically generated by nmstl-rpcgen. 00010 * Do not modify it! 00011 * 00012 *****/ 00013 00014 #ifndef ______SRC_RPC_CENTRALLOOKUPSERVER_H 00015 #define ______SRC_RPC_CENTRALLOOKUPSERVER_H 00016 00017 #include <NMSTL/rpc> 00018 00019 00020 namespace Borealis { class CentralLookupServer; }; 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::CentralLookupServer> { 00038 public: 00041 void register_object(const Callback<void, RPC< void > >& completion, 00042 ptr<Object> object); 00043 00045 RPC< void > register_object(ptr<Object> object); 00046 00049 void register_object_set(const Callback<void, RPC< void > >& completion, 00050 ptr<Object> object); 00051 00053 RPC< void > register_object_set(ptr<Object> object); 00054 00057 void register_objects(const Callback<void, RPC< void > >& completion, 00058 vector< ptr<Object> > objects); 00059 00061 RPC< void > register_objects(vector< ptr<Object> > objects); 00062 00065 void register_object_sets(const Callback<void, RPC< void > >& completion, 00066 vector< ptr<Object> > objects); 00067 00069 RPC< void > register_object_sets(vector< ptr<Object> > objects); 00070 00073 void lookup_object(const Callback<void, RPC< ptr<Object> > >& completion, 00074 Name name); 00075 00077 RPC< ptr<Object> > lookup_object(Name name); 00078 00081 void lookup_object_set(const Callback<void, RPC< vector< ptr<Object> > > >& completion, 00082 Name name); 00083 00085 RPC< vector< ptr<Object> > > lookup_object_set(Name name); 00086 00089 void lookup_objects(const Callback<void, RPC< vector< ptr<Object> > > >& completion, 00090 vector<Name> names); 00091 00093 RPC< vector< ptr<Object> > > lookup_objects(vector<Name> names); 00094 00097 void lookup_object_sets(const Callback<void, RPC< vector< vector< ptr<Object> > > > >& completion, 00098 vector<Name> names); 00099 00101 RPC< vector< vector< ptr<Object> > > > lookup_object_sets(vector<Name> names); 00102 00105 void register_node(const Callback<void, RPC< void > >& completion, 00106 MedusaID node, InetAddress address); 00107 00109 RPC< void > register_node(MedusaID node, InetAddress address); 00110 00113 void lookup_node(const Callback<void, RPC< InetAddress > >& completion, 00114 MedusaID node); 00115 00117 RPC< InetAddress > lookup_node(MedusaID node); 00118 00121 void set_backup_pair(const Callback<void, RPC< void > >& completion, 00122 MedusaID primary, MedusaID secondary); 00123 00125 RPC< void > set_backup_pair(MedusaID primary, MedusaID secondary); 00126 00129 void get_backup(const Callback<void, RPC< MedusaID > >& completion, 00130 MedusaID primary); 00131 00133 RPC< MedusaID > get_backup(MedusaID primary); 00134 00137 void add_responsability(const Callback<void, RPC< void > >& completion, 00138 MedusaID node, ptr<Object> object, bool standalone); 00139 00141 RPC< void > add_responsability(MedusaID node, ptr<Object> object, bool standalone); 00142 00145 void add_responsabilities(const Callback<void, RPC< void > >& completion, 00146 MedusaID node, vector< pair< ptr<Object>,bool > > objects); 00147 00149 RPC< void > add_responsabilities(MedusaID node, vector< pair< ptr<Object>,bool > > objects); 00150 00153 void remove_responsability(const Callback<void, RPC< void > >& completion, 00154 MedusaID node, Name name); 00155 00157 RPC< void > remove_responsability(MedusaID node, Name name); 00158 00161 void remove_responsabilities(const Callback<void, RPC< void > >& completion, 00162 MedusaID node, vector<Name> names); 00163 00165 RPC< void > remove_responsabilities(MedusaID node, vector<Name> names); 00166 00169 void get_responsabilities(const Callback<void, RPC< vector< ptr<Object> > > >& completion, 00170 MedusaID node); 00171 00173 RPC< vector< ptr<Object> > > get_responsabilities(MedusaID node); 00174 00177 void dump(const Callback<void, RPC< string > >& completion); 00178 00180 RPC< string > dump(); 00181 00182 }; 00183 00184 00185 /***** 00186 * 00187 * You can safely ignore everything after here. 00188 * 00189 *****/ 00190 00191 00192 00193 00194 00195 #else // !defined(DOXYGEN_SKIP) 00196 00197 namespace __nmstl_tmp_rpc_defs { 00198 template<typename X> struct RPCDefs; 00199 template<typename X> struct Remote; 00200 using namespace Borealis; 00201 template<> 00202 struct RPCDefs<Borealis::CentralLookupServer> { 00203 static const int register_object_METHOD_ID = 20000; 00204 struct register_object_IN : public rpc_request_1< void > { 00205 ptr<Object> object; 00206 register_object_IN() {} 00207 register_object_IN(ptr<Object> object) : object(object) {} 00208 rpc_message *clone() const { return new register_object_IN(*this); } 00209 string as_string() const { 00210 string out; 00211 out << "register_object_IN{" << "object=" << object << "}"; 00212 return out; 00213 } 00214 NMSTL_SIMPLY_SERIALIZABLE(register_object_IN, << Serial::tag("param") << object ); 00215 NMSTL_SERIAL_TAG(register_object_IN, "params"); 00216 }; 00217 class register_object_OUT { 00218 RPCStatus m_stat; 00219 public: 00220 operator const void * () const { return m_stat; } 00221 const RPCStatus& stat() const { return m_stat; } 00222 bool get() const { return true; } 00223 }; 00224 static const int register_object_set_METHOD_ID = 20001; 00225 struct register_object_set_IN : public rpc_request_1< void > { 00226 ptr<Object> object; 00227 register_object_set_IN() {} 00228 register_object_set_IN(ptr<Object> object) : object(object) {} 00229 rpc_message *clone() const { return new register_object_set_IN(*this); } 00230 string as_string() const { 00231 string out; 00232 out << "register_object_set_IN{" << "object=" << object << "}"; 00233 return out; 00234 } 00235 NMSTL_SIMPLY_SERIALIZABLE(register_object_set_IN, << Serial::tag("param") << object ); 00236 NMSTL_SERIAL_TAG(register_object_set_IN, "params"); 00237 }; 00238 class register_object_set_OUT { 00239 RPCStatus m_stat; 00240 public: 00241 operator const void * () const { return m_stat; } 00242 const RPCStatus& stat() const { return m_stat; } 00243 bool get() const { return true; } 00244 }; 00245 static const int register_objects_METHOD_ID = 20002; 00246 struct register_objects_IN : public rpc_request_1< void > { 00247 vector< ptr<Object> > objects; 00248 register_objects_IN() {} 00249 register_objects_IN(vector< ptr<Object> > objects) : objects(objects) {} 00250 rpc_message *clone() const { return new register_objects_IN(*this); } 00251 string as_string() const { 00252 string out; 00253 out << "register_objects_IN{" << "objects=" << objects << "}"; 00254 return out; 00255 } 00256 NMSTL_SIMPLY_SERIALIZABLE(register_objects_IN, << Serial::tag("param") << objects ); 00257 NMSTL_SERIAL_TAG(register_objects_IN, "params"); 00258 }; 00259 class register_objects_OUT { 00260 RPCStatus m_stat; 00261 public: 00262 operator const void * () const { return m_stat; } 00263 const RPCStatus& stat() const { return m_stat; } 00264 bool get() const { return true; } 00265 }; 00266 static const int register_object_sets_METHOD_ID = 20003; 00267 struct register_object_sets_IN : public rpc_request_1< void > { 00268 vector< ptr<Object> > objects; 00269 register_object_sets_IN() {} 00270 register_object_sets_IN(vector< ptr<Object> > objects) : objects(objects) {} 00271 rpc_message *clone() const { return new register_object_sets_IN(*this); } 00272 string as_string() const { 00273 string out; 00274 out << "register_object_sets_IN{" << "objects=" << objects << "}"; 00275 return out; 00276 } 00277 NMSTL_SIMPLY_SERIALIZABLE(register_object_sets_IN, << Serial::tag("param") << objects ); 00278 NMSTL_SERIAL_TAG(register_object_sets_IN, "params"); 00279 }; 00280 class register_object_sets_OUT { 00281 RPCStatus m_stat; 00282 public: 00283 operator const void * () const { return m_stat; } 00284 const RPCStatus& stat() const { return m_stat; } 00285 bool get() const { return true; } 00286 }; 00287 static const int lookup_object_METHOD_ID = 20004; 00288 struct lookup_object_IN : public rpc_request_1< ptr<Object> > { 00289 Name name; 00290 lookup_object_IN() {} 00291 lookup_object_IN(Name name) : name(name) {} 00292 rpc_message *clone() const { return new lookup_object_IN(*this); } 00293 string as_string() const { 00294 string out; 00295 out << "lookup_object_IN{" << "name=" << name << "}"; 00296 return out; 00297 } 00298 NMSTL_SIMPLY_SERIALIZABLE(lookup_object_IN, << Serial::tag("param") << name ); 00299 NMSTL_SERIAL_TAG(lookup_object_IN, "params"); 00300 }; 00301 class lookup_object_OUT { 00302 RPCStatus m_stat; 00303 ptr<Object> m_val; 00304 public: 00305 operator const void * () const { return m_stat; } 00306 const RPCStatus& stat() const { return m_stat; } 00307 ptr<Object> get() const { return m_val; } 00308 }; 00309 static const int lookup_object_set_METHOD_ID = 20005; 00310 struct lookup_object_set_IN : public rpc_request_1< vector< ptr<Object> > > { 00311 Name name; 00312 lookup_object_set_IN() {} 00313 lookup_object_set_IN(Name name) : name(name) {} 00314 rpc_message *clone() const { return new lookup_object_set_IN(*this); } 00315 string as_string() const { 00316 string out; 00317 out << "lookup_object_set_IN{" << "name=" << name << "}"; 00318 return out; 00319 } 00320 NMSTL_SIMPLY_SERIALIZABLE(lookup_object_set_IN, << Serial::tag("param") << name ); 00321 NMSTL_SERIAL_TAG(lookup_object_set_IN, "params"); 00322 }; 00323 class lookup_object_set_OUT { 00324 RPCStatus m_stat; 00325 vector< ptr<Object> > m_val; 00326 public: 00327 operator const void * () const { return m_stat; } 00328 const RPCStatus& stat() const { return m_stat; } 00329 vector< ptr<Object> > get() const { return m_val; } 00330 }; 00331 static const int lookup_objects_METHOD_ID = 20006; 00332 struct lookup_objects_IN : public rpc_request_1< vector< ptr<Object> > > { 00333 vector<Name> names; 00334 lookup_objects_IN() {} 00335 lookup_objects_IN(vector<Name> names) : names(names) {} 00336 rpc_message *clone() const { return new lookup_objects_IN(*this); } 00337 string as_string() const { 00338 string out; 00339 out << "lookup_objects_IN{" << "names=" << names << "}"; 00340 return out; 00341 } 00342 NMSTL_SIMPLY_SERIALIZABLE(lookup_objects_IN, << Serial::tag("param") << names ); 00343 NMSTL_SERIAL_TAG(lookup_objects_IN, "params"); 00344 }; 00345 class lookup_objects_OUT { 00346 RPCStatus m_stat; 00347 vector< ptr<Object> > m_val; 00348 public: 00349 operator const void * () const { return m_stat; } 00350 const RPCStatus& stat() const { return m_stat; } 00351 vector< ptr<Object> > get() const { return m_val; } 00352 }; 00353 static const int lookup_object_sets_METHOD_ID = 20007; 00354 struct lookup_object_sets_IN : public rpc_request_1< vector< vector< ptr<Object> > > > { 00355 vector<Name> names; 00356 lookup_object_sets_IN() {} 00357 lookup_object_sets_IN(vector<Name> names) : names(names) {} 00358 rpc_message *clone() const { return new lookup_object_sets_IN(*this); } 00359 string as_string() const { 00360 string out; 00361 out << "lookup_object_sets_IN{" << "names=" << names << "}"; 00362 return out; 00363 } 00364 NMSTL_SIMPLY_SERIALIZABLE(lookup_object_sets_IN, << Serial::tag("param") << names ); 00365 NMSTL_SERIAL_TAG(lookup_object_sets_IN, "params"); 00366 }; 00367 class lookup_object_sets_OUT { 00368 RPCStatus m_stat; 00369 vector< vector< ptr<Object> > > m_val; 00370 public: 00371 operator const void * () const { return m_stat; } 00372 const RPCStatus& stat() const { return m_stat; } 00373 vector< vector< ptr<Object> > > get() const { return m_val; } 00374 }; 00375 static const int register_node_METHOD_ID = 20008; 00376 struct register_node_IN : public rpc_request_1< void > { 00377 MedusaID node; InetAddress address; 00378 register_node_IN() {} 00379 register_node_IN(MedusaID node, InetAddress address) : node(node), address(address) {} 00380 rpc_message *clone() const { return new register_node_IN(*this); } 00381 string as_string() const { 00382 string out; 00383 out << "register_node_IN{" << "node=" << node << ", address=" << address << "}"; 00384 return out; 00385 } 00386 NMSTL_SIMPLY_SERIALIZABLE(register_node_IN, << Serial::tag("param") << node << address ); 00387 NMSTL_SERIAL_TAG(register_node_IN, "params"); 00388 }; 00389 class register_node_OUT { 00390 RPCStatus m_stat; 00391 public: 00392 operator const void * () const { return m_stat; } 00393 const RPCStatus& stat() const { return m_stat; } 00394 bool get() const { return true; } 00395 }; 00396 static const int lookup_node_METHOD_ID = 20009; 00397 struct lookup_node_IN : public rpc_request_1< InetAddress > { 00398 MedusaID node; 00399 lookup_node_IN() {} 00400 lookup_node_IN(MedusaID node) : node(node) {} 00401 rpc_message *clone() const { return new lookup_node_IN(*this); } 00402 string as_string() const { 00403 string out; 00404 out << "lookup_node_IN{" << "node=" << node << "}"; 00405 return out; 00406 } 00407 NMSTL_SIMPLY_SERIALIZABLE(lookup_node_IN, << Serial::tag("param") << node ); 00408 NMSTL_SERIAL_TAG(lookup_node_IN, "params"); 00409 }; 00410 class lookup_node_OUT { 00411 RPCStatus m_stat; 00412 InetAddress m_val; 00413 public: 00414 operator const void * () const { return m_stat; } 00415 const RPCStatus& stat() const { return m_stat; } 00416 InetAddress get() const { return m_val; } 00417 }; 00418 static const int set_backup_pair_METHOD_ID = 20010; 00419 struct set_backup_pair_IN : public rpc_request_1< void > { 00420 MedusaID primary; MedusaID secondary; 00421 set_backup_pair_IN() {} 00422 set_backup_pair_IN(MedusaID primary, MedusaID secondary) : primary(primary), secondary(secondary) {} 00423 rpc_message *clone() const { return new set_backup_pair_IN(*this); } 00424 string as_string() const { 00425 string out; 00426 out << "set_backup_pair_IN{" << "primary=" << primary << ", secondary=" << secondary << "}"; 00427 return out; 00428 } 00429 NMSTL_SIMPLY_SERIALIZABLE(set_backup_pair_IN, << Serial::tag("param") << primary << secondary ); 00430 NMSTL_SERIAL_TAG(set_backup_pair_IN, "params"); 00431 }; 00432 class set_backup_pair_OUT { 00433 RPCStatus m_stat; 00434 public: 00435 operator const void * () const { return m_stat; } 00436 const RPCStatus& stat() const { return m_stat; } 00437 bool get() const { return true; } 00438 }; 00439 static const int get_backup_METHOD_ID = 20011; 00440 struct get_backup_IN : public rpc_request_1< MedusaID > { 00441 MedusaID primary; 00442 get_backup_IN() {} 00443 get_backup_IN(MedusaID primary) : primary(primary) {} 00444 rpc_message *clone() const { return new get_backup_IN(*this); } 00445 string as_string() const { 00446 string out; 00447 out << "get_backup_IN{" << "primary=" << primary << "}"; 00448 return out; 00449 } 00450 NMSTL_SIMPLY_SERIALIZABLE(get_backup_IN, << Serial::tag("param") << primary ); 00451 NMSTL_SERIAL_TAG(get_backup_IN, "params"); 00452 }; 00453 class get_backup_OUT { 00454 RPCStatus m_stat; 00455 MedusaID m_val; 00456 public: 00457 operator const void * () const { return m_stat; } 00458 const RPCStatus& stat() const { return m_stat; } 00459 MedusaID get() const { return m_val; } 00460 }; 00461 static const int add_responsability_METHOD_ID = 20012; 00462 struct add_responsability_IN : public rpc_request_1< void > { 00463 MedusaID node; ptr<Object> object; bool standalone; 00464 add_responsability_IN() {} 00465 add_responsability_IN(MedusaID node, ptr<Object> object, bool standalone) : node(node), object(object), standalone(standalone) {} 00466 rpc_message *clone() const { return new add_responsability_IN(*this); } 00467 string as_string() const { 00468 string out; 00469 out << "add_responsability_IN{" << "node=" << node << ", object=" << object << ", standalone=" << standalone << "}"; 00470 return out; 00471 } 00472 NMSTL_SIMPLY_SERIALIZABLE(add_responsability_IN, << Serial::tag("param") << node << object << standalone ); 00473 NMSTL_SERIAL_TAG(add_responsability_IN, "params"); 00474 }; 00475 class add_responsability_OUT { 00476 RPCStatus m_stat; 00477 public: 00478 operator const void * () const { return m_stat; } 00479 const RPCStatus& stat() const { return m_stat; } 00480 bool get() const { return true; } 00481 }; 00482 static const int add_responsabilities_METHOD_ID = 20013; 00483 struct add_responsabilities_IN : public rpc_request_1< void > { 00484 MedusaID node; vector< pair< ptr<Object>,bool > > objects; 00485 add_responsabilities_IN() {} 00486 add_responsabilities_IN(MedusaID node, vector< pair< ptr<Object>,bool > > objects) : node(node), objects(objects) {} 00487 rpc_message *clone() const { return new add_responsabilities_IN(*this); } 00488 string as_string() const { 00489 string out; 00490 out << "add_responsabilities_IN{" << "node=" << node << ", objects=" << objects << "}"; 00491 return out; 00492 } 00493 NMSTL_SIMPLY_SERIALIZABLE(add_responsabilities_IN, << Serial::tag("param") << node << objects ); 00494 NMSTL_SERIAL_TAG(add_responsabilities_IN, "params"); 00495 }; 00496 class add_responsabilities_OUT { 00497 RPCStatus m_stat; 00498 public: 00499 operator const void * () const { return m_stat; } 00500 const RPCStatus& stat() const { return m_stat; } 00501 bool get() const { return true; } 00502 }; 00503 static const int remove_responsability_METHOD_ID = 20014; 00504 struct remove_responsability_IN : public rpc_request_1< void > { 00505 MedusaID node; Name name; 00506 remove_responsability_IN() {} 00507 remove_responsability_IN(MedusaID node, Name name) : node(node), name(name) {} 00508 rpc_message *clone() const { return new remove_responsability_IN(*this); } 00509 string as_string() const { 00510 string out; 00511 out << "remove_responsability_IN{" << "node=" << node << ", name=" << name << "}"; 00512 return out; 00513 } 00514 NMSTL_SIMPLY_SERIALIZABLE(remove_responsability_IN, << Serial::tag("param") << node << name ); 00515 NMSTL_SERIAL_TAG(remove_responsability_IN, "params"); 00516 }; 00517 class remove_responsability_OUT { 00518 RPCStatus m_stat; 00519 public: 00520 operator const void * () const { return m_stat; } 00521 const RPCStatus& stat() const { return m_stat; } 00522 bool get() const { return true; } 00523 }; 00524 static const int remove_responsabilities_METHOD_ID = 20015; 00525 struct remove_responsabilities_IN : public rpc_request_1< void > { 00526 MedusaID node; vector<Name> names; 00527 remove_responsabilities_IN() {} 00528 remove_responsabilities_IN(MedusaID node, vector<Name> names) : node(node), names(names) {} 00529 rpc_message *clone() const { return new remove_responsabilities_IN(*this); } 00530 string as_string() const { 00531 string out; 00532 out << "remove_responsabilities_IN{" << "node=" << node << ", names=" << names << "}"; 00533 return out; 00534 } 00535 NMSTL_SIMPLY_SERIALIZABLE(remove_responsabilities_IN, << Serial::tag("param") << node << names ); 00536 NMSTL_SERIAL_TAG(remove_responsabilities_IN, "params"); 00537 }; 00538 class remove_responsabilities_OUT { 00539 RPCStatus m_stat; 00540 public: 00541 operator const void * () const { return m_stat; } 00542 const RPCStatus& stat() const { return m_stat; } 00543 bool get() const { return true; } 00544 }; 00545 static const int get_responsabilities_METHOD_ID = 20016; 00546 struct get_responsabilities_IN : public rpc_request_1< vector< ptr<Object> > > { 00547 MedusaID node; 00548 get_responsabilities_IN() {} 00549 get_responsabilities_IN(MedusaID node) : node(node) {} 00550 rpc_message *clone() const { return new get_responsabilities_IN(*this); } 00551 string as_string() const { 00552 string out; 00553 out << "get_responsabilities_IN{" << "node=" << node << "}"; 00554 return out; 00555 } 00556 NMSTL_SIMPLY_SERIALIZABLE(get_responsabilities_IN, << Serial::tag("param") << node ); 00557 NMSTL_SERIAL_TAG(get_responsabilities_IN, "params"); 00558 }; 00559 class get_responsabilities_OUT { 00560 RPCStatus m_stat; 00561 vector< ptr<Object> > m_val; 00562 public: 00563 operator const void * () const { return m_stat; } 00564 const RPCStatus& stat() const { return m_stat; } 00565 vector< ptr<Object> > get() const { return m_val; } 00566 }; 00567 static const int dump_METHOD_ID = 20017; 00568 struct dump_IN : public rpc_request_1< string > { 00569 00570 dump_IN() {} 00571 rpc_message *clone() const { return new dump_IN(*this); } 00572 string as_string() const { 00573 string out; 00574 out << "dump_IN{" << "}"; 00575 return out; 00576 } 00577 NMSTL_SIMPLY_SERIALIZABLE(dump_IN, << Serial::tag("param") ); 00578 NMSTL_SERIAL_TAG(dump_IN, "params"); 00579 }; 00580 class dump_OUT { 00581 RPCStatus m_stat; 00582 string m_val; 00583 public: 00584 operator const void * () const { return m_stat; } 00585 const RPCStatus& stat() const { return m_stat; } 00586 string get() const { return m_val; } 00587 }; 00588 static const vector<pair<string, int> >& method_list() { 00589 static const pair<string, int> methods[] = { 00590 pair<string, int>("register_object", 20000), 00591 pair<string, int>("register_object_set", 20001), 00592 pair<string, int>("register_objects", 20002), 00593 pair<string, int>("register_object_sets", 20003), 00594 pair<string, int>("lookup_object", 20004), 00595 pair<string, int>("lookup_object_set", 20005), 00596 pair<string, int>("lookup_objects", 20006), 00597 pair<string, int>("lookup_object_sets", 20007), 00598 pair<string, int>("register_node", 20008), 00599 pair<string, int>("lookup_node", 20009), 00600 pair<string, int>("set_backup_pair", 20010), 00601 pair<string, int>("get_backup", 20011), 00602 pair<string, int>("add_responsability", 20012), 00603 pair<string, int>("add_responsabilities", 20013), 00604 pair<string, int>("remove_responsability", 20014), 00605 pair<string, int>("remove_responsabilities", 20015), 00606 pair<string, int>("get_responsabilities", 20016), 00607 pair<string, int>("dump", 20017) 00608 }; 00609 static const vector<pair<string, int> > ret(methods, methods + sizeof methods / sizeof methods[0]); 00610 return ret; 00611 }; 00612 static const map<string, int>& method_id_by_name() { 00613 static const map<string, int> ret(method_list().begin(), method_list().end()); 00614 return ret; 00615 } 00616 static const map<int, string>& method_name_by_id() { 00617 static const map<int, string> ret = RPCObject::reverse_map(method_id_by_name()); 00618 return ret; 00619 } 00620 }; 00621 template<> 00622 class Remote<Borealis::CentralLookupServer> : public RemoteObject { 00623 friend class RPCClient; 00624 protected: 00625 Remote<Borealis::CentralLookupServer>(RPCClient& cli, rpc_object_id object_id) : 00626 RemoteObject(cli, object_id) {} 00627 00628 public: 00629 Remote<Borealis::CentralLookupServer>() {} 00630 void register_object(const Callback<void, RPC< void > >& completion, ptr<Object> object) const { 00631 RPCDefs<Borealis::CentralLookupServer>::register_object_IN *req = 00632 new RPCDefs<Borealis::CentralLookupServer>::register_object_IN(object); 00633 req->object_id = object_id(); 00634 req->method_id = RPCDefs<Borealis::CentralLookupServer>::register_object_METHOD_ID; 00635 req->method_name = "register_object"; 00636 req->cb = completion; 00637 client().send_request(ptr<rpc_request>(req)); 00638 } 00639 RPC< void > register_object(ptr<Object> object) const { 00640 RPCDefs<Borealis::CentralLookupServer>::register_object_IN *req = 00641 new RPCDefs<Borealis::CentralLookupServer>::register_object_IN(object); 00642 ptr<rpc_request> preq(req); 00643 req->object_id = object_id(); 00644 req->method_id = RPCDefs<Borealis::CentralLookupServer>::register_object_METHOD_ID; 00645 req->method_name = "register_object"; 00646 bool done = false; RPC< void > ret; 00647 req->cb = wrap(&rpc_sync_completion< void >, &done, &ret); 00648 client().send_request(preq); 00649 while (!done && client().block()) ; 00650 req->cb = Callback<void, RPC< void > >(); 00651 return ret; 00652 } 00653 typedef const RPCDefs<Borealis::CentralLookupServer>::register_object_OUT &register_object_result; 00654 void register_object_set(const Callback<void, RPC< void > >& completion, ptr<Object> object) const { 00655 RPCDefs<Borealis::CentralLookupServer>::register_object_set_IN *req = 00656 new RPCDefs<Borealis::CentralLookupServer>::register_object_set_IN(object); 00657 req->object_id = object_id(); 00658 req->method_id = RPCDefs<Borealis::CentralLookupServer>::register_object_set_METHOD_ID; 00659 req->method_name = "register_object_set"; 00660 req->cb = completion; 00661 client().send_request(ptr<rpc_request>(req)); 00662 } 00663 RPC< void > register_object_set(ptr<Object> object) const { 00664 RPCDefs<Borealis::CentralLookupServer>::register_object_set_IN *req = 00665 new RPCDefs<Borealis::CentralLookupServer>::register_object_set_IN(object); 00666 ptr<rpc_request> preq(req); 00667 req->object_id = object_id(); 00668 req->method_id = RPCDefs<Borealis::CentralLookupServer>::register_object_set_METHOD_ID; 00669 req->method_name = "register_object_set"; 00670 bool done = false; RPC< void > ret; 00671 req->cb = wrap(&rpc_sync_completion< void >, &done, &ret); 00672 client().send_request(preq); 00673 while (!done && client().block()) ; 00674 req->cb = Callback<void, RPC< void > >(); 00675 return ret; 00676 } 00677 typedef const RPCDefs<Borealis::CentralLookupServer>::register_object_set_OUT &register_object_set_result; 00678 void register_objects(const Callback<void, RPC< void > >& completion, vector< ptr<Object> > objects) const { 00679 RPCDefs<Borealis::CentralLookupServer>::register_objects_IN *req = 00680 new RPCDefs<Borealis::CentralLookupServer>::register_objects_IN(objects); 00681 req->object_id = object_id(); 00682 req->method_id = RPCDefs<Borealis::CentralLookupServer>::register_objects_METHOD_ID; 00683 req->method_name = "register_objects"; 00684 req->cb = completion; 00685 client().send_request(ptr<rpc_request>(req)); 00686 } 00687 RPC< void > register_objects(vector< ptr<Object> > objects) const { 00688 RPCDefs<Borealis::CentralLookupServer>::register_objects_IN *req = 00689 new RPCDefs<Borealis::CentralLookupServer>::register_objects_IN(objects); 00690 ptr<rpc_request> preq(req); 00691 req->object_id = object_id(); 00692 req->method_id = RPCDefs<Borealis::CentralLookupServer>::register_objects_METHOD_ID; 00693 req->method_name = "register_objects"; 00694 bool done = false; RPC< void > ret; 00695 req->cb = wrap(&rpc_sync_completion< void >, &done, &ret); 00696 client().send_request(preq); 00697 while (!done && client().block()) ; 00698 req->cb = Callback<void, RPC< void > >(); 00699 return ret; 00700 } 00701 typedef const RPCDefs<Borealis::CentralLookupServer>::register_objects_OUT &register_objects_result; 00702 void register_object_sets(const Callback<void, RPC< void > >& completion, vector< ptr<Object> > objects) const { 00703 RPCDefs<Borealis::CentralLookupServer>::register_object_sets_IN *req = 00704 new RPCDefs<Borealis::CentralLookupServer>::register_object_sets_IN(objects); 00705 req->object_id = object_id(); 00706 req->method_id = RPCDefs<Borealis::CentralLookupServer>::register_object_sets_METHOD_ID; 00707 req->method_name = "register_object_sets"; 00708 req->cb = completion; 00709 client().send_request(ptr<rpc_request>(req)); 00710 } 00711 RPC< void > register_object_sets(vector< ptr<Object> > objects) const { 00712 RPCDefs<Borealis::CentralLookupServer>::register_object_sets_IN *req = 00713 new RPCDefs<Borealis::CentralLookupServer>::register_object_sets_IN(objects); 00714 ptr<rpc_request> preq(req); 00715 req->object_id = object_id(); 00716 req->method_id = RPCDefs<Borealis::CentralLookupServer>::register_object_sets_METHOD_ID; 00717 req->method_name = "register_object_sets"; 00718 bool done = false; RPC< void > ret; 00719 req->cb = wrap(&rpc_sync_completion< void >, &done, &ret); 00720 client().send_request(preq); 00721 while (!done && client().block()) ; 00722 req->cb = Callback<void, RPC< void > >(); 00723 return ret; 00724 } 00725 typedef const RPCDefs<Borealis::CentralLookupServer>::register_object_sets_OUT &register_object_sets_result; 00726 void lookup_object(const Callback<void, RPC< ptr<Object> > >& completion, Name name) const { 00727 RPCDefs<Borealis::CentralLookupServer>::lookup_object_IN *req = 00728 new RPCDefs<Borealis::CentralLookupServer>::lookup_object_IN(name); 00729 req->object_id = object_id(); 00730 req->method_id = RPCDefs<Borealis::CentralLookupServer>::lookup_object_METHOD_ID; 00731 req->method_name = "lookup_object"; 00732 req->cb = completion; 00733 client().send_request(ptr<rpc_request>(req)); 00734 } 00735 RPC< ptr<Object> > lookup_object(Name name) const { 00736 RPCDefs<Borealis::CentralLookupServer>::lookup_object_IN *req = 00737 new RPCDefs<Borealis::CentralLookupServer>::lookup_object_IN(name); 00738 ptr<rpc_request> preq(req); 00739 req->object_id = object_id(); 00740 req->method_id = RPCDefs<Borealis::CentralLookupServer>::lookup_object_METHOD_ID; 00741 req->method_name = "lookup_object"; 00742 bool done = false; RPC< ptr<Object> > ret; 00743 req->cb = wrap(&rpc_sync_completion< ptr<Object> >, &done, &ret); 00744 client().send_request(preq); 00745 while (!done && client().block()) ; 00746 req->cb = Callback<void, RPC< ptr<Object> > >(); 00747 return ret; 00748 } 00749 typedef const RPCDefs<Borealis::CentralLookupServer>::lookup_object_OUT &lookup_object_result; 00750 void lookup_object_set(const Callback<void, RPC< vector< ptr<Object> > > >& completion, Name name) const { 00751 RPCDefs<Borealis::CentralLookupServer>::lookup_object_set_IN *req = 00752 new RPCDefs<Borealis::CentralLookupServer>::lookup_object_set_IN(name); 00753 req->object_id = object_id(); 00754 req->method_id = RPCDefs<Borealis::CentralLookupServer>::lookup_object_set_METHOD_ID; 00755 req->method_name = "lookup_object_set"; 00756 req->cb = completion; 00757 client().send_request(ptr<rpc_request>(req)); 00758 } 00759 RPC< vector< ptr<Object> > > lookup_object_set(Name name) const { 00760 RPCDefs<Borealis::CentralLookupServer>::lookup_object_set_IN *req = 00761 new RPCDefs<Borealis::CentralLookupServer>::lookup_object_set_IN(name); 00762 ptr<rpc_request> preq(req); 00763 req->object_id = object_id(); 00764 req->method_id = RPCDefs<Borealis::CentralLookupServer>::lookup_object_set_METHOD_ID; 00765 req->method_name = "lookup_object_set"; 00766 bool done = false; RPC< vector< ptr<Object> > > ret; 00767 req->cb = wrap(&rpc_sync_completion< vector< ptr<Object> > >, &done, &ret); 00768 client().send_request(preq); 00769 while (!done && client().block()) ; 00770 req->cb = Callback<void, RPC< vector< ptr<Object> > > >(); 00771 return ret; 00772 } 00773 typedef const RPCDefs<Borealis::CentralLookupServer>::lookup_object_set_OUT &lookup_object_set_result; 00774 void lookup_objects(const Callback<void, RPC< vector< ptr<Object> > > >& completion, vector<Name> names) const { 00775 RPCDefs<Borealis::CentralLookupServer>::lookup_objects_IN *req = 00776 new RPCDefs<Borealis::CentralLookupServer>::lookup_objects_IN(names); 00777 req->object_id = object_id(); 00778 req->method_id = RPCDefs<Borealis::CentralLookupServer>::lookup_objects_METHOD_ID; 00779 req->method_name = "lookup_objects"; 00780 req->cb = completion; 00781 client().send_request(ptr<rpc_request>(req)); 00782 } 00783 RPC< vector< ptr<Object> > > lookup_objects(vector<Name> names) const { 00784 RPCDefs<Borealis::CentralLookupServer>::lookup_objects_IN *req = 00785 new RPCDefs<Borealis::CentralLookupServer>::lookup_objects_IN(names); 00786 ptr<rpc_request> preq(req); 00787 req->object_id = object_id(); 00788 req->method_id = RPCDefs<Borealis::CentralLookupServer>::lookup_objects_METHOD_ID; 00789 req->method_name = "lookup_objects"; 00790 bool done = false; RPC< vector< ptr<Object> > > ret; 00791 req->cb = wrap(&rpc_sync_completion< vector< ptr<Object> > >, &done, &ret); 00792 client().send_request(preq); 00793 while (!done && client().block()) ; 00794 req->cb = Callback<void, RPC< vector< ptr<Object> > > >(); 00795 return ret; 00796 } 00797 typedef const RPCDefs<Borealis::CentralLookupServer>::lookup_objects_OUT &lookup_objects_result; 00798 void lookup_object_sets(const Callback<void, RPC< vector< vector< ptr<Object> > > > >& completion, vector<Name> names) const { 00799 RPCDefs<Borealis::CentralLookupServer>::lookup_object_sets_IN *req = 00800 new RPCDefs<Borealis::CentralLookupServer>::lookup_object_sets_IN(names); 00801 req->object_id = object_id(); 00802 req->method_id = RPCDefs<Borealis::CentralLookupServer>::lookup_object_sets_METHOD_ID; 00803 req->method_name = "lookup_object_sets"; 00804 req->cb = completion; 00805 client().send_request(ptr<rpc_request>(req)); 00806 } 00807 RPC< vector< vector< ptr<Object> > > > lookup_object_sets(vector<Name> names) const { 00808 RPCDefs<Borealis::CentralLookupServer>::lookup_object_sets_IN *req = 00809 new RPCDefs<Borealis::CentralLookupServer>::lookup_object_sets_IN(names); 00810 ptr<rpc_request> preq(req); 00811 req->object_id = object_id(); 00812 req->method_id = RPCDefs<Borealis::CentralLookupServer>::lookup_object_sets_METHOD_ID; 00813 req->method_name = "lookup_object_sets"; 00814 bool done = false; RPC< vector< vector< ptr<Object> > > > ret; 00815 req->cb = wrap(&rpc_sync_completion< vector< vector< ptr<Object> > > >, &done, &ret); 00816 client().send_request(preq); 00817 while (!done && client().block()) ; 00818 req->cb = Callback<void, RPC< vector< vector< ptr<Object> > > > >(); 00819 return ret; 00820 } 00821 typedef const RPCDefs<Borealis::CentralLookupServer>::lookup_object_sets_OUT &lookup_object_sets_result; 00822 void register_node(const Callback<void, RPC< void > >& completion, MedusaID node, InetAddress address) const { 00823 RPCDefs<Borealis::CentralLookupServer>::register_node_IN *req = 00824 new RPCDefs<Borealis::CentralLookupServer>::register_node_IN(node, address); 00825 req->object_id = object_id(); 00826 req->method_id = RPCDefs<Borealis::CentralLookupServer>::register_node_METHOD_ID; 00827 req->method_name = "register_node"; 00828 req->cb = completion; 00829 client().send_request(ptr<rpc_request>(req)); 00830 } 00831 RPC< void > register_node(MedusaID node, InetAddress address) const { 00832 RPCDefs<Borealis::CentralLookupServer>::register_node_IN *req = 00833 new RPCDefs<Borealis::CentralLookupServer>::register_node_IN(node, address); 00834 ptr<rpc_request> preq(req); 00835 req->object_id = object_id(); 00836 req->method_id = RPCDefs<Borealis::CentralLookupServer>::register_node_METHOD_ID; 00837 req->method_name = "register_node"; 00838 bool done = false; RPC< void > ret; 00839 req->cb = wrap(&rpc_sync_completion< void >, &done, &ret); 00840 client().send_request(preq); 00841 while (!done && client().block()) ; 00842 req->cb = Callback<void, RPC< void > >(); 00843 return ret; 00844 } 00845 typedef const RPCDefs<Borealis::CentralLookupServer>::register_node_OUT &register_node_result; 00846 void lookup_node(const Callback<void, RPC< InetAddress > >& completion, MedusaID node) const { 00847 RPCDefs<Borealis::CentralLookupServer>::lookup_node_IN *req = 00848 new RPCDefs<Borealis::CentralLookupServer>::lookup_node_IN(node); 00849 req->object_id = object_id(); 00850 req->method_id = RPCDefs<Borealis::CentralLookupServer>::lookup_node_METHOD_ID; 00851 req->method_name = "lookup_node"; 00852 req->cb = completion; 00853 client().send_request(ptr<rpc_request>(req)); 00854 } 00855 RPC< InetAddress > lookup_node(MedusaID node) const { 00856 RPCDefs<Borealis::CentralLookupServer>::lookup_node_IN *req = 00857 new RPCDefs<Borealis::CentralLookupServer>::lookup_node_IN(node); 00858 ptr<rpc_request> preq(req); 00859 req->object_id = object_id(); 00860 req->method_id = RPCDefs<Borealis::CentralLookupServer>::lookup_node_METHOD_ID; 00861 req->method_name = "lookup_node"; 00862 bool done = false; RPC< InetAddress > ret; 00863 req->cb = wrap(&rpc_sync_completion< InetAddress >, &done, &ret); 00864 client().send_request(preq); 00865 while (!done && client().block()) ; 00866 req->cb = Callback<void, RPC< InetAddress > >(); 00867 return ret; 00868 } 00869 typedef const RPCDefs<Borealis::CentralLookupServer>::lookup_node_OUT &lookup_node_result; 00870 void set_backup_pair(const Callback<void, RPC< void > >& completion, MedusaID primary, MedusaID secondary) const { 00871 RPCDefs<Borealis::CentralLookupServer>::set_backup_pair_IN *req = 00872 new RPCDefs<Borealis::CentralLookupServer>::set_backup_pair_IN(primary, secondary); 00873 req->object_id = object_id(); 00874 req->method_id = RPCDefs<Borealis::CentralLookupServer>::set_backup_pair_METHOD_ID; 00875 req->method_name = "set_backup_pair"; 00876 req->cb = completion; 00877 client().send_request(ptr<rpc_request>(req)); 00878 } 00879 RPC< void > set_backup_pair(MedusaID primary, MedusaID secondary) const { 00880 RPCDefs<Borealis::CentralLookupServer>::set_backup_pair_IN *req = 00881 new RPCDefs<Borealis::CentralLookupServer>::set_backup_pair_IN(primary, secondary); 00882 ptr<rpc_request> preq(req); 00883 req->object_id = object_id(); 00884 req->method_id = RPCDefs<Borealis::CentralLookupServer>::set_backup_pair_METHOD_ID; 00885 req->method_name = "set_backup_pair"; 00886 bool done = false; RPC< void > ret; 00887 req->cb = wrap(&rpc_sync_completion< void >, &done, &ret); 00888 client().send_request(preq); 00889 while (!done && client().block()) ; 00890 req->cb = Callback<void, RPC< void > >(); 00891 return ret; 00892 } 00893 typedef const RPCDefs<Borealis::CentralLookupServer>::set_backup_pair_OUT &set_backup_pair_result; 00894 void get_backup(const Callback<void, RPC< MedusaID > >& completion, MedusaID primary) const { 00895 RPCDefs<Borealis::CentralLookupServer>::get_backup_IN *req = 00896 new RPCDefs<Borealis::CentralLookupServer>::get_backup_IN(primary); 00897 req->object_id = object_id(); 00898 req->method_id = RPCDefs<Borealis::CentralLookupServer>::get_backup_METHOD_ID; 00899 req->method_name = "get_backup"; 00900 req->cb = completion; 00901 client().send_request(ptr<rpc_request>(req)); 00902 } 00903 RPC< MedusaID > get_backup(MedusaID primary) const { 00904 RPCDefs<Borealis::CentralLookupServer>::get_backup_IN *req = 00905 new RPCDefs<Borealis::CentralLookupServer>::get_backup_IN(primary); 00906 ptr<rpc_request> preq(req); 00907 req->object_id = object_id(); 00908 req->method_id = RPCDefs<Borealis::CentralLookupServer>::get_backup_METHOD_ID; 00909 req->method_name = "get_backup"; 00910 bool done = false; RPC< MedusaID > ret; 00911 req->cb = wrap(&rpc_sync_completion< MedusaID >, &done, &ret); 00912 client().send_request(preq); 00913 while (!done && client().block()) ; 00914 req->cb = Callback<void, RPC< MedusaID > >(); 00915 return ret; 00916 } 00917 typedef const RPCDefs<Borealis::CentralLookupServer>::get_backup_OUT &get_backup_result; 00918 void add_responsability(const Callback<void, RPC< void > >& completion, MedusaID node, ptr<Object> object, bool standalone) const { 00919 RPCDefs<Borealis::CentralLookupServer>::add_responsability_IN *req = 00920 new RPCDefs<Borealis::CentralLookupServer>::add_responsability_IN(node, object, standalone); 00921 req->object_id = object_id(); 00922 req->method_id = RPCDefs<Borealis::CentralLookupServer>::add_responsability_METHOD_ID; 00923 req->method_name = "add_responsability"; 00924 req->cb = completion; 00925 client().send_request(ptr<rpc_request>(req)); 00926 } 00927 RPC< void > add_responsability(MedusaID node, ptr<Object> object, bool standalone) const { 00928 RPCDefs<Borealis::CentralLookupServer>::add_responsability_IN *req = 00929 new RPCDefs<Borealis::CentralLookupServer>::add_responsability_IN(node, object, standalone); 00930 ptr<rpc_request> preq(req); 00931 req->object_id = object_id(); 00932 req->method_id = RPCDefs<Borealis::CentralLookupServer>::add_responsability_METHOD_ID; 00933 req->method_name = "add_responsability"; 00934 bool done = false; RPC< void > ret; 00935 req->cb = wrap(&rpc_sync_completion< void >, &done, &ret); 00936 client().send_request(preq); 00937 while (!done && client().block()) ; 00938 req->cb = Callback<void, RPC< void > >(); 00939 return ret; 00940 } 00941 typedef const RPCDefs<Borealis::CentralLookupServer>::add_responsability_OUT &add_responsability_result; 00942 void add_responsabilities(const Callback<void, RPC< void > >& completion, MedusaID node, vector< pair< ptr<Object>,bool > > objects) const { 00943 RPCDefs<Borealis::CentralLookupServer>::add_responsabilities_IN *req = 00944 new RPCDefs<Borealis::CentralLookupServer>::add_responsabilities_IN(node, objects); 00945 req->object_id = object_id(); 00946 req->method_id = RPCDefs<Borealis::CentralLookupServer>::add_responsabilities_METHOD_ID; 00947 req->method_name = "add_responsabilities"; 00948 req->cb = completion; 00949 client().send_request(ptr<rpc_request>(req)); 00950 } 00951 RPC< void > add_responsabilities(MedusaID node, vector< pair< ptr<Object>,bool > > objects) const { 00952 RPCDefs<Borealis::CentralLookupServer>::add_responsabilities_IN *req = 00953 new RPCDefs<Borealis::CentralLookupServer>::add_responsabilities_IN(node, objects); 00954 ptr<rpc_request> preq(req); 00955 req->object_id = object_id(); 00956 req->method_id = RPCDefs<Borealis::CentralLookupServer>::add_responsabilities_METHOD_ID; 00957 req->method_name = "add_responsabilities"; 00958 bool done = false; RPC< void > ret; 00959 req->cb = wrap(&rpc_sync_completion< void >, &done, &ret); 00960 client().send_request(preq); 00961 while (!done && client().block()) ; 00962 req->cb = Callback<void, RPC< void > >(); 00963 return ret; 00964 } 00965 typedef const RPCDefs<Borealis::CentralLookupServer>::add_responsabilities_OUT &add_responsabilities_result; 00966 void remove_responsability(const Callback<void, RPC< void > >& completion, MedusaID node, Name name) const { 00967 RPCDefs<Borealis::CentralLookupServer>::remove_responsability_IN *req = 00968 new RPCDefs<Borealis::CentralLookupServer>::remove_responsability_IN(node, name); 00969 req->object_id = object_id(); 00970 req->method_id = RPCDefs<Borealis::CentralLookupServer>::remove_responsability_METHOD_ID; 00971 req->method_name = "remove_responsability"; 00972 req->cb = completion; 00973 client().send_request(ptr<rpc_request>(req)); 00974 } 00975 RPC< void > remove_responsability(MedusaID node, Name name) const { 00976 RPCDefs<Borealis::CentralLookupServer>::remove_responsability_IN *req = 00977 new RPCDefs<Borealis::CentralLookupServer>::remove_responsability_IN(node, name); 00978 ptr<rpc_request> preq(req); 00979 req->object_id = object_id(); 00980 req->method_id = RPCDefs<Borealis::CentralLookupServer>::remove_responsability_METHOD_ID; 00981 req->method_name = "remove_responsability"; 00982 bool done = false; RPC< void > ret; 00983 req->cb = wrap(&rpc_sync_completion< void >, &done, &ret); 00984 client().send_request(preq); 00985 while (!done && client().block()) ; 00986 req->cb = Callback<void, RPC< void > >(); 00987 return ret; 00988 } 00989 typedef const RPCDefs<Borealis::CentralLookupServer>::remove_responsability_OUT &remove_responsability_result; 00990 void remove_responsabilities(const Callback<void, RPC< void > >& completion, MedusaID node, vector<Name> names) const { 00991 RPCDefs<Borealis::CentralLookupServer>::remove_responsabilities_IN *req = 00992 new RPCDefs<Borealis::CentralLookupServer>::remove_responsabilities_IN(node, names); 00993 req->object_id = object_id(); 00994 req->method_id = RPCDefs<Borealis::CentralLookupServer>::remove_responsabilities_METHOD_ID; 00995 req->method_name = "remove_responsabilities"; 00996 req->cb = completion; 00997 client().send_request(ptr<rpc_request>(req)); 00998 } 00999 RPC< void > remove_responsabilities(MedusaID node, vector<Name> names) const { 01000 RPCDefs<Borealis::CentralLookupServer>::remove_responsabilities_IN *req = 01001 new RPCDefs<Borealis::CentralLookupServer>::remove_responsabilities_IN(node, names); 01002 ptr<rpc_request> preq(req); 01003 req->object_id = object_id(); 01004 req->method_id = RPCDefs<Borealis::CentralLookupServer>::remove_responsabilities_METHOD_ID; 01005 req->method_name = "remove_responsabilities"; 01006 bool done = false; RPC< void > ret; 01007 req->cb = wrap(&rpc_sync_completion< void >, &done, &ret); 01008 client().send_request(preq); 01009 while (!done && client().block()) ; 01010 req->cb = Callback<void, RPC< void > >(); 01011 return ret; 01012 } 01013 typedef const RPCDefs<Borealis::CentralLookupServer>::remove_responsabilities_OUT &remove_responsabilities_result; 01014 void get_responsabilities(const Callback<void, RPC< vector< ptr<Object> > > >& completion, MedusaID node) const { 01015 RPCDefs<Borealis::CentralLookupServer>::get_responsabilities_IN *req = 01016 new RPCDefs<Borealis::CentralLookupServer>::get_responsabilities_IN(node); 01017 req->object_id = object_id(); 01018 req->method_id = RPCDefs<Borealis::CentralLookupServer>::get_responsabilities_METHOD_ID; 01019 req->method_name = "get_responsabilities"; 01020 req->cb = completion; 01021 client().send_request(ptr<rpc_request>(req)); 01022 } 01023 RPC< vector< ptr<Object> > > get_responsabilities(MedusaID node) const { 01024 RPCDefs<Borealis::CentralLookupServer>::get_responsabilities_IN *req = 01025 new RPCDefs<Borealis::CentralLookupServer>::get_responsabilities_IN(node); 01026 ptr<rpc_request> preq(req); 01027 req->object_id = object_id(); 01028 req->method_id = RPCDefs<Borealis::CentralLookupServer>::get_responsabilities_METHOD_ID; 01029 req->method_name = "get_responsabilities"; 01030 bool done = false; RPC< vector< ptr<Object> > > ret; 01031 req->cb = wrap(&rpc_sync_completion< vector< ptr<Object> > >, &done, &ret); 01032 client().send_request(preq); 01033 while (!done && client().block()) ; 01034 req->cb = Callback<void, RPC< vector< ptr<Object> > > >(); 01035 return ret; 01036 } 01037 typedef const RPCDefs<Borealis::CentralLookupServer>::get_responsabilities_OUT &get_responsabilities_result; 01038 void dump(const Callback<void, RPC< string > >& completion) const { 01039 RPCDefs<Borealis::CentralLookupServer>::dump_IN *req = 01040 new RPCDefs<Borealis::CentralLookupServer>::dump_IN(); 01041 req->object_id = object_id(); 01042 req->method_id = RPCDefs<Borealis::CentralLookupServer>::dump_METHOD_ID; 01043 req->method_name = "dump"; 01044 req->cb = completion; 01045 client().send_request(ptr<rpc_request>(req)); 01046 } 01047 RPC< string > dump() const { 01048 RPCDefs<Borealis::CentralLookupServer>::dump_IN *req = 01049 new RPCDefs<Borealis::CentralLookupServer>::dump_IN(); 01050 ptr<rpc_request> preq(req); 01051 req->object_id = object_id(); 01052 req->method_id = RPCDefs<Borealis::CentralLookupServer>::dump_METHOD_ID; 01053 req->method_name = "dump"; 01054 bool done = false; RPC< string > ret; 01055 req->cb = wrap(&rpc_sync_completion< string >, &done, &ret); 01056 client().send_request(preq); 01057 while (!done && client().block()) ; 01058 req->cb = Callback<void, RPC< string > >(); 01059 return ret; 01060 } 01061 typedef const RPCDefs<Borealis::CentralLookupServer>::dump_OUT &dump_result; 01062 }; 01063 }; 01064 template<> struct RPCDefs<Borealis::CentralLookupServer> : __nmstl_tmp_rpc_defs::RPCDefs<Borealis::CentralLookupServer> {}; 01065 template<> struct Remote<Borealis::CentralLookupServer> : __nmstl_tmp_rpc_defs::Remote<Borealis::CentralLookupServer> { 01066 Remote<Borealis::CentralLookupServer>() {} 01067 Remote<Borealis::CentralLookupServer>(RPCClient& cli, rpc_object_id object_id) : 01068 __nmstl_tmp_rpc_defs::Remote<Borealis::CentralLookupServer>(cli, object_id) {} 01069 01070 Remote<Borealis::CentralLookupServer>(const __nmstl_tmp_rpc_defs::Remote<Borealis::CentralLookupServer>& x) : 01071 __nmstl_tmp_rpc_defs::Remote<Borealis::CentralLookupServer>(x) {} 01072 }; 01073 01074 01075 #endif // !defined(DOXYGEN_SKIP) 01076 01077 NMSTL_NAMESPACE_END; 01078 01079 #endif // !defined(______SRC_RPC_CENTRALLOOKUPSERVER_H) 01080 01081 01082 01083 01084 01085 #ifdef NMSTL_RPC_DEFINE 01086 01087 #include <string> 01088 #include <map> 01089 #include <NMSTL/rpc> 01090 01091 void Borealis::CentralLookupServer::handle_request(const NMSTL::RPCObject::response_cb& cb, const NMSTL::ptr<NMSTL::rpc_request>& req) { 01092 switch(req->method_id) { 01093 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_object_METHOD_ID: 01094 { 01095 const NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_object_IN* inp = 01096 dynamic_cast<const NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_object_IN*>(req.get()); 01097 01098 if (!inp) { 01099 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 01100 " to Borealis::CentralLookupServer::register_object; expected " + 01101 typeid(NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_object_IN); 01102 WARN << err; 01103 cb(err, 0, true); 01104 return; 01105 } 01106 01107 const NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_object_IN& in = *inp; 01108 RPC< void > result = register_object(in.object); 01109 if (result.valid()) { 01110 NMSTL::rpc_message_1< void > ret; 01111 cb(true, &ret, true); 01112 } else { 01113 cb(result.stat(), 0, true); 01114 } 01115 break; 01116 } 01117 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_object_set_METHOD_ID: 01118 { 01119 const NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_object_set_IN* inp = 01120 dynamic_cast<const NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_object_set_IN*>(req.get()); 01121 01122 if (!inp) { 01123 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 01124 " to Borealis::CentralLookupServer::register_object_set; expected " + 01125 typeid(NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_object_set_IN); 01126 WARN << err; 01127 cb(err, 0, true); 01128 return; 01129 } 01130 01131 const NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_object_set_IN& in = *inp; 01132 RPC< void > result = register_object_set(in.object); 01133 if (result.valid()) { 01134 NMSTL::rpc_message_1< void > ret; 01135 cb(true, &ret, true); 01136 } else { 01137 cb(result.stat(), 0, true); 01138 } 01139 break; 01140 } 01141 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_objects_METHOD_ID: 01142 { 01143 const NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_objects_IN* inp = 01144 dynamic_cast<const NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_objects_IN*>(req.get()); 01145 01146 if (!inp) { 01147 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 01148 " to Borealis::CentralLookupServer::register_objects; expected " + 01149 typeid(NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_objects_IN); 01150 WARN << err; 01151 cb(err, 0, true); 01152 return; 01153 } 01154 01155 const NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_objects_IN& in = *inp; 01156 RPC< void > result = register_objects(in.objects); 01157 if (result.valid()) { 01158 NMSTL::rpc_message_1< void > ret; 01159 cb(true, &ret, true); 01160 } else { 01161 cb(result.stat(), 0, true); 01162 } 01163 break; 01164 } 01165 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_object_sets_METHOD_ID: 01166 { 01167 const NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_object_sets_IN* inp = 01168 dynamic_cast<const NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_object_sets_IN*>(req.get()); 01169 01170 if (!inp) { 01171 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 01172 " to Borealis::CentralLookupServer::register_object_sets; expected " + 01173 typeid(NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_object_sets_IN); 01174 WARN << err; 01175 cb(err, 0, true); 01176 return; 01177 } 01178 01179 const NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_object_sets_IN& in = *inp; 01180 RPC< void > result = register_object_sets(in.objects); 01181 if (result.valid()) { 01182 NMSTL::rpc_message_1< void > ret; 01183 cb(true, &ret, true); 01184 } else { 01185 cb(result.stat(), 0, true); 01186 } 01187 break; 01188 } 01189 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_object_METHOD_ID: 01190 { 01191 const NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_object_IN* inp = 01192 dynamic_cast<const NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_object_IN*>(req.get()); 01193 01194 if (!inp) { 01195 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 01196 " to Borealis::CentralLookupServer::lookup_object; expected " + 01197 typeid(NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_object_IN); 01198 WARN << err; 01199 cb(err, 0, true); 01200 return; 01201 } 01202 01203 const NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_object_IN& in = *inp; 01204 RPC< ptr<Object> > result = lookup_object(in.name); 01205 if (result.valid()) { 01206 NMSTL::rpc_message_1< ptr<Object> > ret(*result); 01207 cb(true, &ret, true); 01208 } else { 01209 cb(result.stat(), 0, true); 01210 } 01211 break; 01212 } 01213 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_object_set_METHOD_ID: 01214 { 01215 const NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_object_set_IN* inp = 01216 dynamic_cast<const NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_object_set_IN*>(req.get()); 01217 01218 if (!inp) { 01219 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 01220 " to Borealis::CentralLookupServer::lookup_object_set; expected " + 01221 typeid(NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_object_set_IN); 01222 WARN << err; 01223 cb(err, 0, true); 01224 return; 01225 } 01226 01227 const NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_object_set_IN& in = *inp; 01228 RPC< vector< ptr<Object> > > result = lookup_object_set(in.name); 01229 if (result.valid()) { 01230 NMSTL::rpc_message_1< vector< ptr<Object> > > ret(*result); 01231 cb(true, &ret, true); 01232 } else { 01233 cb(result.stat(), 0, true); 01234 } 01235 break; 01236 } 01237 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_objects_METHOD_ID: 01238 { 01239 const NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_objects_IN* inp = 01240 dynamic_cast<const NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_objects_IN*>(req.get()); 01241 01242 if (!inp) { 01243 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 01244 " to Borealis::CentralLookupServer::lookup_objects; expected " + 01245 typeid(NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_objects_IN); 01246 WARN << err; 01247 cb(err, 0, true); 01248 return; 01249 } 01250 01251 const NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_objects_IN& in = *inp; 01252 RPC< vector< ptr<Object> > > result = lookup_objects(in.names); 01253 if (result.valid()) { 01254 NMSTL::rpc_message_1< vector< ptr<Object> > > ret(*result); 01255 cb(true, &ret, true); 01256 } else { 01257 cb(result.stat(), 0, true); 01258 } 01259 break; 01260 } 01261 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_object_sets_METHOD_ID: 01262 { 01263 const NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_object_sets_IN* inp = 01264 dynamic_cast<const NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_object_sets_IN*>(req.get()); 01265 01266 if (!inp) { 01267 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 01268 " to Borealis::CentralLookupServer::lookup_object_sets; expected " + 01269 typeid(NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_object_sets_IN); 01270 WARN << err; 01271 cb(err, 0, true); 01272 return; 01273 } 01274 01275 const NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_object_sets_IN& in = *inp; 01276 RPC< vector< vector< ptr<Object> > > > result = lookup_object_sets(in.names); 01277 if (result.valid()) { 01278 NMSTL::rpc_message_1< vector< vector< ptr<Object> > > > ret(*result); 01279 cb(true, &ret, true); 01280 } else { 01281 cb(result.stat(), 0, true); 01282 } 01283 break; 01284 } 01285 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_node_METHOD_ID: 01286 { 01287 const NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_node_IN* inp = 01288 dynamic_cast<const NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_node_IN*>(req.get()); 01289 01290 if (!inp) { 01291 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 01292 " to Borealis::CentralLookupServer::register_node; expected " + 01293 typeid(NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_node_IN); 01294 WARN << err; 01295 cb(err, 0, true); 01296 return; 01297 } 01298 01299 const NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_node_IN& in = *inp; 01300 RPC< void > result = register_node(in.node, in.address); 01301 if (result.valid()) { 01302 NMSTL::rpc_message_1< void > ret; 01303 cb(true, &ret, true); 01304 } else { 01305 cb(result.stat(), 0, true); 01306 } 01307 break; 01308 } 01309 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_node_METHOD_ID: 01310 { 01311 const NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_node_IN* inp = 01312 dynamic_cast<const NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_node_IN*>(req.get()); 01313 01314 if (!inp) { 01315 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 01316 " to Borealis::CentralLookupServer::lookup_node; expected " + 01317 typeid(NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_node_IN); 01318 WARN << err; 01319 cb(err, 0, true); 01320 return; 01321 } 01322 01323 const NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_node_IN& in = *inp; 01324 RPC< InetAddress > result = lookup_node(in.node); 01325 if (result.valid()) { 01326 NMSTL::rpc_message_1< InetAddress > ret(*result); 01327 cb(true, &ret, true); 01328 } else { 01329 cb(result.stat(), 0, true); 01330 } 01331 break; 01332 } 01333 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::set_backup_pair_METHOD_ID: 01334 { 01335 const NMSTL::RPCDefs<Borealis::CentralLookupServer>::set_backup_pair_IN* inp = 01336 dynamic_cast<const NMSTL::RPCDefs<Borealis::CentralLookupServer>::set_backup_pair_IN*>(req.get()); 01337 01338 if (!inp) { 01339 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 01340 " to Borealis::CentralLookupServer::set_backup_pair; expected " + 01341 typeid(NMSTL::RPCDefs<Borealis::CentralLookupServer>::set_backup_pair_IN); 01342 WARN << err; 01343 cb(err, 0, true); 01344 return; 01345 } 01346 01347 const NMSTL::RPCDefs<Borealis::CentralLookupServer>::set_backup_pair_IN& in = *inp; 01348 RPC< void > result = set_backup_pair(in.primary, in.secondary); 01349 if (result.valid()) { 01350 NMSTL::rpc_message_1< void > ret; 01351 cb(true, &ret, true); 01352 } else { 01353 cb(result.stat(), 0, true); 01354 } 01355 break; 01356 } 01357 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::get_backup_METHOD_ID: 01358 { 01359 const NMSTL::RPCDefs<Borealis::CentralLookupServer>::get_backup_IN* inp = 01360 dynamic_cast<const NMSTL::RPCDefs<Borealis::CentralLookupServer>::get_backup_IN*>(req.get()); 01361 01362 if (!inp) { 01363 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 01364 " to Borealis::CentralLookupServer::get_backup; expected " + 01365 typeid(NMSTL::RPCDefs<Borealis::CentralLookupServer>::get_backup_IN); 01366 WARN << err; 01367 cb(err, 0, true); 01368 return; 01369 } 01370 01371 const NMSTL::RPCDefs<Borealis::CentralLookupServer>::get_backup_IN& in = *inp; 01372 RPC< MedusaID > result = get_backup(in.primary); 01373 if (result.valid()) { 01374 NMSTL::rpc_message_1< MedusaID > ret(*result); 01375 cb(true, &ret, true); 01376 } else { 01377 cb(result.stat(), 0, true); 01378 } 01379 break; 01380 } 01381 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::add_responsability_METHOD_ID: 01382 { 01383 const NMSTL::RPCDefs<Borealis::CentralLookupServer>::add_responsability_IN* inp = 01384 dynamic_cast<const NMSTL::RPCDefs<Borealis::CentralLookupServer>::add_responsability_IN*>(req.get()); 01385 01386 if (!inp) { 01387 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 01388 " to Borealis::CentralLookupServer::add_responsability; expected " + 01389 typeid(NMSTL::RPCDefs<Borealis::CentralLookupServer>::add_responsability_IN); 01390 WARN << err; 01391 cb(err, 0, true); 01392 return; 01393 } 01394 01395 const NMSTL::RPCDefs<Borealis::CentralLookupServer>::add_responsability_IN& in = *inp; 01396 RPC< void > result = add_responsability(in.node, in.object, in.standalone); 01397 if (result.valid()) { 01398 NMSTL::rpc_message_1< void > ret; 01399 cb(true, &ret, true); 01400 } else { 01401 cb(result.stat(), 0, true); 01402 } 01403 break; 01404 } 01405 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::add_responsabilities_METHOD_ID: 01406 { 01407 const NMSTL::RPCDefs<Borealis::CentralLookupServer>::add_responsabilities_IN* inp = 01408 dynamic_cast<const NMSTL::RPCDefs<Borealis::CentralLookupServer>::add_responsabilities_IN*>(req.get()); 01409 01410 if (!inp) { 01411 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 01412 " to Borealis::CentralLookupServer::add_responsabilities; expected " + 01413 typeid(NMSTL::RPCDefs<Borealis::CentralLookupServer>::add_responsabilities_IN); 01414 WARN << err; 01415 cb(err, 0, true); 01416 return; 01417 } 01418 01419 const NMSTL::RPCDefs<Borealis::CentralLookupServer>::add_responsabilities_IN& in = *inp; 01420 RPC< void > result = add_responsabilities(in.node, in.objects); 01421 if (result.valid()) { 01422 NMSTL::rpc_message_1< void > ret; 01423 cb(true, &ret, true); 01424 } else { 01425 cb(result.stat(), 0, true); 01426 } 01427 break; 01428 } 01429 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::remove_responsability_METHOD_ID: 01430 { 01431 const NMSTL::RPCDefs<Borealis::CentralLookupServer>::remove_responsability_IN* inp = 01432 dynamic_cast<const NMSTL::RPCDefs<Borealis::CentralLookupServer>::remove_responsability_IN*>(req.get()); 01433 01434 if (!inp) { 01435 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 01436 " to Borealis::CentralLookupServer::remove_responsability; expected " + 01437 typeid(NMSTL::RPCDefs<Borealis::CentralLookupServer>::remove_responsability_IN); 01438 WARN << err; 01439 cb(err, 0, true); 01440 return; 01441 } 01442 01443 const NMSTL::RPCDefs<Borealis::CentralLookupServer>::remove_responsability_IN& in = *inp; 01444 RPC< void > result = remove_responsability(in.node, in.name); 01445 if (result.valid()) { 01446 NMSTL::rpc_message_1< void > ret; 01447 cb(true, &ret, true); 01448 } else { 01449 cb(result.stat(), 0, true); 01450 } 01451 break; 01452 } 01453 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::remove_responsabilities_METHOD_ID: 01454 { 01455 const NMSTL::RPCDefs<Borealis::CentralLookupServer>::remove_responsabilities_IN* inp = 01456 dynamic_cast<const NMSTL::RPCDefs<Borealis::CentralLookupServer>::remove_responsabilities_IN*>(req.get()); 01457 01458 if (!inp) { 01459 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 01460 " to Borealis::CentralLookupServer::remove_responsabilities; expected " + 01461 typeid(NMSTL::RPCDefs<Borealis::CentralLookupServer>::remove_responsabilities_IN); 01462 WARN << err; 01463 cb(err, 0, true); 01464 return; 01465 } 01466 01467 const NMSTL::RPCDefs<Borealis::CentralLookupServer>::remove_responsabilities_IN& in = *inp; 01468 RPC< void > result = remove_responsabilities(in.node, in.names); 01469 if (result.valid()) { 01470 NMSTL::rpc_message_1< void > ret; 01471 cb(true, &ret, true); 01472 } else { 01473 cb(result.stat(), 0, true); 01474 } 01475 break; 01476 } 01477 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::get_responsabilities_METHOD_ID: 01478 { 01479 const NMSTL::RPCDefs<Borealis::CentralLookupServer>::get_responsabilities_IN* inp = 01480 dynamic_cast<const NMSTL::RPCDefs<Borealis::CentralLookupServer>::get_responsabilities_IN*>(req.get()); 01481 01482 if (!inp) { 01483 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 01484 " to Borealis::CentralLookupServer::get_responsabilities; expected " + 01485 typeid(NMSTL::RPCDefs<Borealis::CentralLookupServer>::get_responsabilities_IN); 01486 WARN << err; 01487 cb(err, 0, true); 01488 return; 01489 } 01490 01491 const NMSTL::RPCDefs<Borealis::CentralLookupServer>::get_responsabilities_IN& in = *inp; 01492 RPC< vector< ptr<Object> > > result = get_responsabilities(in.node); 01493 if (result.valid()) { 01494 NMSTL::rpc_message_1< vector< ptr<Object> > > ret(*result); 01495 cb(true, &ret, true); 01496 } else { 01497 cb(result.stat(), 0, true); 01498 } 01499 break; 01500 } 01501 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::dump_METHOD_ID: 01502 { 01503 const NMSTL::RPCDefs<Borealis::CentralLookupServer>::dump_IN* inp = 01504 dynamic_cast<const NMSTL::RPCDefs<Borealis::CentralLookupServer>::dump_IN*>(req.get()); 01505 01506 if (!inp) { 01507 string err = string("Invalid RPC request type ") + typeid(*(req.get())) + 01508 " to Borealis::CentralLookupServer::dump; expected " + 01509 typeid(NMSTL::RPCDefs<Borealis::CentralLookupServer>::dump_IN); 01510 WARN << err; 01511 cb(err, 0, true); 01512 return; 01513 } 01514 01515 RPC< string > result = dump(); 01516 if (result.valid()) { 01517 NMSTL::rpc_message_1< string > ret(*result); 01518 cb(true, &ret, true); 01519 } else { 01520 cb(result.stat(), 0, true); 01521 } 01522 break; 01523 } 01524 default: 01525 string err = string("Unknown method_id ") + req->method_id + " in Borealis::CentralLookupServer::handle_request"; 01526 WARN << err; 01527 cb(err, 0, true); 01528 } 01529 } 01530 void Borealis::CentralLookupServer::handle_request(const response_cb& cb, rpc_id method_id, ISerial& is) { 01531 switch(method_id) { 01532 case RPCDefs<Borealis::CentralLookupServer>::register_object_METHOD_ID: 01533 { 01534 RPCDefs<Borealis::CentralLookupServer>::register_object_IN in; 01535 is >> in; 01536 if (!is) { 01537 WARN << "Invalid RPC request to Borealis::CentralLookupServer::register_object: " << is.stat(); 01538 cb(is.stat(), 0, true); 01539 return; 01540 } 01541 DEBUG << "Handling register_object"; 01542 RPC< void > result = register_object(in.object); 01543 if (result.valid()) { 01544 NMSTL::rpc_message_1< void > ret; 01545 cb(true, &ret, true); 01546 } else { 01547 cb(result.stat(), 0, true); 01548 } 01549 break; 01550 } 01551 case RPCDefs<Borealis::CentralLookupServer>::register_object_set_METHOD_ID: 01552 { 01553 RPCDefs<Borealis::CentralLookupServer>::register_object_set_IN in; 01554 is >> in; 01555 if (!is) { 01556 WARN << "Invalid RPC request to Borealis::CentralLookupServer::register_object_set: " << is.stat(); 01557 cb(is.stat(), 0, true); 01558 return; 01559 } 01560 DEBUG << "Handling register_object_set"; 01561 RPC< void > result = register_object_set(in.object); 01562 if (result.valid()) { 01563 NMSTL::rpc_message_1< void > ret; 01564 cb(true, &ret, true); 01565 } else { 01566 cb(result.stat(), 0, true); 01567 } 01568 break; 01569 } 01570 case RPCDefs<Borealis::CentralLookupServer>::register_objects_METHOD_ID: 01571 { 01572 RPCDefs<Borealis::CentralLookupServer>::register_objects_IN in; 01573 is >> in; 01574 if (!is) { 01575 WARN << "Invalid RPC request to Borealis::CentralLookupServer::register_objects: " << is.stat(); 01576 cb(is.stat(), 0, true); 01577 return; 01578 } 01579 DEBUG << "Handling register_objects"; 01580 RPC< void > result = register_objects(in.objects); 01581 if (result.valid()) { 01582 NMSTL::rpc_message_1< void > ret; 01583 cb(true, &ret, true); 01584 } else { 01585 cb(result.stat(), 0, true); 01586 } 01587 break; 01588 } 01589 case RPCDefs<Borealis::CentralLookupServer>::register_object_sets_METHOD_ID: 01590 { 01591 RPCDefs<Borealis::CentralLookupServer>::register_object_sets_IN in; 01592 is >> in; 01593 if (!is) { 01594 WARN << "Invalid RPC request to Borealis::CentralLookupServer::register_object_sets: " << is.stat(); 01595 cb(is.stat(), 0, true); 01596 return; 01597 } 01598 DEBUG << "Handling register_object_sets"; 01599 RPC< void > result = register_object_sets(in.objects); 01600 if (result.valid()) { 01601 NMSTL::rpc_message_1< void > ret; 01602 cb(true, &ret, true); 01603 } else { 01604 cb(result.stat(), 0, true); 01605 } 01606 break; 01607 } 01608 case RPCDefs<Borealis::CentralLookupServer>::lookup_object_METHOD_ID: 01609 { 01610 RPCDefs<Borealis::CentralLookupServer>::lookup_object_IN in; 01611 is >> in; 01612 if (!is) { 01613 WARN << "Invalid RPC request to Borealis::CentralLookupServer::lookup_object: " << is.stat(); 01614 cb(is.stat(), 0, true); 01615 return; 01616 } 01617 DEBUG << "Handling lookup_object"; 01618 RPC< ptr<Object> > result = lookup_object(in.name); 01619 if (result.valid()) { 01620 NMSTL::rpc_message_1< ptr<Object> > ret(*result); 01621 cb(true, &ret, true); 01622 } else { 01623 cb(result.stat(), 0, true); 01624 } 01625 break; 01626 } 01627 case RPCDefs<Borealis::CentralLookupServer>::lookup_object_set_METHOD_ID: 01628 { 01629 RPCDefs<Borealis::CentralLookupServer>::lookup_object_set_IN in; 01630 is >> in; 01631 if (!is) { 01632 WARN << "Invalid RPC request to Borealis::CentralLookupServer::lookup_object_set: " << is.stat(); 01633 cb(is.stat(), 0, true); 01634 return; 01635 } 01636 DEBUG << "Handling lookup_object_set"; 01637 RPC< vector< ptr<Object> > > result = lookup_object_set(in.name); 01638 if (result.valid()) { 01639 NMSTL::rpc_message_1< vector< ptr<Object> > > ret(*result); 01640 cb(true, &ret, true); 01641 } else { 01642 cb(result.stat(), 0, true); 01643 } 01644 break; 01645 } 01646 case RPCDefs<Borealis::CentralLookupServer>::lookup_objects_METHOD_ID: 01647 { 01648 RPCDefs<Borealis::CentralLookupServer>::lookup_objects_IN in; 01649 is >> in; 01650 if (!is) { 01651 WARN << "Invalid RPC request to Borealis::CentralLookupServer::lookup_objects: " << is.stat(); 01652 cb(is.stat(), 0, true); 01653 return; 01654 } 01655 DEBUG << "Handling lookup_objects"; 01656 RPC< vector< ptr<Object> > > result = lookup_objects(in.names); 01657 if (result.valid()) { 01658 NMSTL::rpc_message_1< vector< ptr<Object> > > ret(*result); 01659 cb(true, &ret, true); 01660 } else { 01661 cb(result.stat(), 0, true); 01662 } 01663 break; 01664 } 01665 case RPCDefs<Borealis::CentralLookupServer>::lookup_object_sets_METHOD_ID: 01666 { 01667 RPCDefs<Borealis::CentralLookupServer>::lookup_object_sets_IN in; 01668 is >> in; 01669 if (!is) { 01670 WARN << "Invalid RPC request to Borealis::CentralLookupServer::lookup_object_sets: " << is.stat(); 01671 cb(is.stat(), 0, true); 01672 return; 01673 } 01674 DEBUG << "Handling lookup_object_sets"; 01675 RPC< vector< vector< ptr<Object> > > > result = lookup_object_sets(in.names); 01676 if (result.valid()) { 01677 NMSTL::rpc_message_1< vector< vector< ptr<Object> > > > ret(*result); 01678 cb(true, &ret, true); 01679 } else { 01680 cb(result.stat(), 0, true); 01681 } 01682 break; 01683 } 01684 case RPCDefs<Borealis::CentralLookupServer>::register_node_METHOD_ID: 01685 { 01686 RPCDefs<Borealis::CentralLookupServer>::register_node_IN in; 01687 is >> in; 01688 if (!is) { 01689 WARN << "Invalid RPC request to Borealis::CentralLookupServer::register_node: " << is.stat(); 01690 cb(is.stat(), 0, true); 01691 return; 01692 } 01693 DEBUG << "Handling register_node"; 01694 RPC< void > result = register_node(in.node, in.address); 01695 if (result.valid()) { 01696 NMSTL::rpc_message_1< void > ret; 01697 cb(true, &ret, true); 01698 } else { 01699 cb(result.stat(), 0, true); 01700 } 01701 break; 01702 } 01703 case RPCDefs<Borealis::CentralLookupServer>::lookup_node_METHOD_ID: 01704 { 01705 RPCDefs<Borealis::CentralLookupServer>::lookup_node_IN in; 01706 is >> in; 01707 if (!is) { 01708 WARN << "Invalid RPC request to Borealis::CentralLookupServer::lookup_node: " << is.stat(); 01709 cb(is.stat(), 0, true); 01710 return; 01711 } 01712 DEBUG << "Handling lookup_node"; 01713 RPC< InetAddress > result = lookup_node(in.node); 01714 if (result.valid()) { 01715 NMSTL::rpc_message_1< InetAddress > ret(*result); 01716 cb(true, &ret, true); 01717 } else { 01718 cb(result.stat(), 0, true); 01719 } 01720 break; 01721 } 01722 case RPCDefs<Borealis::CentralLookupServer>::set_backup_pair_METHOD_ID: 01723 { 01724 RPCDefs<Borealis::CentralLookupServer>::set_backup_pair_IN in; 01725 is >> in; 01726 if (!is) { 01727 WARN << "Invalid RPC request to Borealis::CentralLookupServer::set_backup_pair: " << is.stat(); 01728 cb(is.stat(), 0, true); 01729 return; 01730 } 01731 DEBUG << "Handling set_backup_pair"; 01732 RPC< void > result = set_backup_pair(in.primary, in.secondary); 01733 if (result.valid()) { 01734 NMSTL::rpc_message_1< void > ret; 01735 cb(true, &ret, true); 01736 } else { 01737 cb(result.stat(), 0, true); 01738 } 01739 break; 01740 } 01741 case RPCDefs<Borealis::CentralLookupServer>::get_backup_METHOD_ID: 01742 { 01743 RPCDefs<Borealis::CentralLookupServer>::get_backup_IN in; 01744 is >> in; 01745 if (!is) { 01746 WARN << "Invalid RPC request to Borealis::CentralLookupServer::get_backup: " << is.stat(); 01747 cb(is.stat(), 0, true); 01748 return; 01749 } 01750 DEBUG << "Handling get_backup"; 01751 RPC< MedusaID > result = get_backup(in.primary); 01752 if (result.valid()) { 01753 NMSTL::rpc_message_1< MedusaID > ret(*result); 01754 cb(true, &ret, true); 01755 } else { 01756 cb(result.stat(), 0, true); 01757 } 01758 break; 01759 } 01760 case RPCDefs<Borealis::CentralLookupServer>::add_responsability_METHOD_ID: 01761 { 01762 RPCDefs<Borealis::CentralLookupServer>::add_responsability_IN in; 01763 is >> in; 01764 if (!is) { 01765 WARN << "Invalid RPC request to Borealis::CentralLookupServer::add_responsability: " << is.stat(); 01766 cb(is.stat(), 0, true); 01767 return; 01768 } 01769 DEBUG << "Handling add_responsability"; 01770 RPC< void > result = add_responsability(in.node, in.object, in.standalone); 01771 if (result.valid()) { 01772 NMSTL::rpc_message_1< void > ret; 01773 cb(true, &ret, true); 01774 } else { 01775 cb(result.stat(), 0, true); 01776 } 01777 break; 01778 } 01779 case RPCDefs<Borealis::CentralLookupServer>::add_responsabilities_METHOD_ID: 01780 { 01781 RPCDefs<Borealis::CentralLookupServer>::add_responsabilities_IN in; 01782 is >> in; 01783 if (!is) { 01784 WARN << "Invalid RPC request to Borealis::CentralLookupServer::add_responsabilities: " << is.stat(); 01785 cb(is.stat(), 0, true); 01786 return; 01787 } 01788 DEBUG << "Handling add_responsabilities"; 01789 RPC< void > result = add_responsabilities(in.node, in.objects); 01790 if (result.valid()) { 01791 NMSTL::rpc_message_1< void > ret; 01792 cb(true, &ret, true); 01793 } else { 01794 cb(result.stat(), 0, true); 01795 } 01796 break; 01797 } 01798 case RPCDefs<Borealis::CentralLookupServer>::remove_responsability_METHOD_ID: 01799 { 01800 RPCDefs<Borealis::CentralLookupServer>::remove_responsability_IN in; 01801 is >> in; 01802 if (!is) { 01803 WARN << "Invalid RPC request to Borealis::CentralLookupServer::remove_responsability: " << is.stat(); 01804 cb(is.stat(), 0, true); 01805 return; 01806 } 01807 DEBUG << "Handling remove_responsability"; 01808 RPC< void > result = remove_responsability(in.node, in.name); 01809 if (result.valid()) { 01810 NMSTL::rpc_message_1< void > ret; 01811 cb(true, &ret, true); 01812 } else { 01813 cb(result.stat(), 0, true); 01814 } 01815 break; 01816 } 01817 case RPCDefs<Borealis::CentralLookupServer>::remove_responsabilities_METHOD_ID: 01818 { 01819 RPCDefs<Borealis::CentralLookupServer>::remove_responsabilities_IN in; 01820 is >> in; 01821 if (!is) { 01822 WARN << "Invalid RPC request to Borealis::CentralLookupServer::remove_responsabilities: " << is.stat(); 01823 cb(is.stat(), 0, true); 01824 return; 01825 } 01826 DEBUG << "Handling remove_responsabilities"; 01827 RPC< void > result = remove_responsabilities(in.node, in.names); 01828 if (result.valid()) { 01829 NMSTL::rpc_message_1< void > ret; 01830 cb(true, &ret, true); 01831 } else { 01832 cb(result.stat(), 0, true); 01833 } 01834 break; 01835 } 01836 case RPCDefs<Borealis::CentralLookupServer>::get_responsabilities_METHOD_ID: 01837 { 01838 RPCDefs<Borealis::CentralLookupServer>::get_responsabilities_IN in; 01839 is >> in; 01840 if (!is) { 01841 WARN << "Invalid RPC request to Borealis::CentralLookupServer::get_responsabilities: " << is.stat(); 01842 cb(is.stat(), 0, true); 01843 return; 01844 } 01845 DEBUG << "Handling get_responsabilities"; 01846 RPC< vector< ptr<Object> > > result = get_responsabilities(in.node); 01847 if (result.valid()) { 01848 NMSTL::rpc_message_1< vector< ptr<Object> > > ret(*result); 01849 cb(true, &ret, true); 01850 } else { 01851 cb(result.stat(), 0, true); 01852 } 01853 break; 01854 } 01855 case RPCDefs<Borealis::CentralLookupServer>::dump_METHOD_ID: 01856 { 01857 RPCDefs<Borealis::CentralLookupServer>::dump_IN in; 01858 is >> in; 01859 if (!is) { 01860 WARN << "Invalid RPC request to Borealis::CentralLookupServer::dump: " << is.stat(); 01861 cb(is.stat(), 0, true); 01862 return; 01863 } 01864 DEBUG << "Handling dump"; 01865 RPC< string > result = dump(); 01866 if (result.valid()) { 01867 NMSTL::rpc_message_1< string > ret(*result); 01868 cb(true, &ret, true); 01869 } else { 01870 cb(result.stat(), 0, true); 01871 } 01872 break; 01873 } 01874 default: 01875 string err = string("Unknown method_id ") + method_id + " in Borealis::CentralLookupServer::handle_request"; 01876 WARN << err; 01877 cb(err, 0, true); 01878 } 01879 } 01880 NMSTL::rpc_id Borealis::CentralLookupServer::method_id_for_name(string method_name) { 01881 map<string, int>::const_iterator i = RPCDefs<Borealis::CentralLookupServer>::method_id_by_name().find(method_name); 01882 return (i == RPCDefs<Borealis::CentralLookupServer>::method_id_by_name().end()) ? rpc_id() : i->second; 01883 } 01884 string Borealis::CentralLookupServer::method_name_for_id(NMSTL::rpc_id method_id) { 01885 map<int, string>::const_iterator i = RPCDefs<Borealis::CentralLookupServer>::method_name_by_id().find(method_id); 01886 return (i == RPCDefs<Borealis::CentralLookupServer>::method_name_by_id().end()) ? string() : i->second; 01887 } 01888 NMSTL::ptr<NMSTL::rpc_request> Borealis::CentralLookupServer::make_request(NMSTL::rpc_id method_id, NMSTL::ISerial& is) { 01889 switch(method_id) { 01890 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_object_METHOD_ID: 01891 { 01892 NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_object_IN *in = new NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_object_IN; 01893 NMSTL::ptr<NMSTL::rpc_request> req(in); 01894 if (is >> *in) return req; 01895 } 01896 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_object_set_METHOD_ID: 01897 { 01898 NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_object_set_IN *in = new NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_object_set_IN; 01899 NMSTL::ptr<NMSTL::rpc_request> req(in); 01900 if (is >> *in) return req; 01901 } 01902 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_objects_METHOD_ID: 01903 { 01904 NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_objects_IN *in = new NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_objects_IN; 01905 NMSTL::ptr<NMSTL::rpc_request> req(in); 01906 if (is >> *in) return req; 01907 } 01908 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_object_sets_METHOD_ID: 01909 { 01910 NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_object_sets_IN *in = new NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_object_sets_IN; 01911 NMSTL::ptr<NMSTL::rpc_request> req(in); 01912 if (is >> *in) return req; 01913 } 01914 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_object_METHOD_ID: 01915 { 01916 NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_object_IN *in = new NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_object_IN; 01917 NMSTL::ptr<NMSTL::rpc_request> req(in); 01918 if (is >> *in) return req; 01919 } 01920 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_object_set_METHOD_ID: 01921 { 01922 NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_object_set_IN *in = new NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_object_set_IN; 01923 NMSTL::ptr<NMSTL::rpc_request> req(in); 01924 if (is >> *in) return req; 01925 } 01926 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_objects_METHOD_ID: 01927 { 01928 NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_objects_IN *in = new NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_objects_IN; 01929 NMSTL::ptr<NMSTL::rpc_request> req(in); 01930 if (is >> *in) return req; 01931 } 01932 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_object_sets_METHOD_ID: 01933 { 01934 NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_object_sets_IN *in = new NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_object_sets_IN; 01935 NMSTL::ptr<NMSTL::rpc_request> req(in); 01936 if (is >> *in) return req; 01937 } 01938 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_node_METHOD_ID: 01939 { 01940 NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_node_IN *in = new NMSTL::RPCDefs<Borealis::CentralLookupServer>::register_node_IN; 01941 NMSTL::ptr<NMSTL::rpc_request> req(in); 01942 if (is >> *in) return req; 01943 } 01944 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_node_METHOD_ID: 01945 { 01946 NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_node_IN *in = new NMSTL::RPCDefs<Borealis::CentralLookupServer>::lookup_node_IN; 01947 NMSTL::ptr<NMSTL::rpc_request> req(in); 01948 if (is >> *in) return req; 01949 } 01950 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::set_backup_pair_METHOD_ID: 01951 { 01952 NMSTL::RPCDefs<Borealis::CentralLookupServer>::set_backup_pair_IN *in = new NMSTL::RPCDefs<Borealis::CentralLookupServer>::set_backup_pair_IN; 01953 NMSTL::ptr<NMSTL::rpc_request> req(in); 01954 if (is >> *in) return req; 01955 } 01956 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::get_backup_METHOD_ID: 01957 { 01958 NMSTL::RPCDefs<Borealis::CentralLookupServer>::get_backup_IN *in = new NMSTL::RPCDefs<Borealis::CentralLookupServer>::get_backup_IN; 01959 NMSTL::ptr<NMSTL::rpc_request> req(in); 01960 if (is >> *in) return req; 01961 } 01962 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::add_responsability_METHOD_ID: 01963 { 01964 NMSTL::RPCDefs<Borealis::CentralLookupServer>::add_responsability_IN *in = new NMSTL::RPCDefs<Borealis::CentralLookupServer>::add_responsability_IN; 01965 NMSTL::ptr<NMSTL::rpc_request> req(in); 01966 if (is >> *in) return req; 01967 } 01968 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::add_responsabilities_METHOD_ID: 01969 { 01970 NMSTL::RPCDefs<Borealis::CentralLookupServer>::add_responsabilities_IN *in = new NMSTL::RPCDefs<Borealis::CentralLookupServer>::add_responsabilities_IN; 01971 NMSTL::ptr<NMSTL::rpc_request> req(in); 01972 if (is >> *in) return req; 01973 } 01974 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::remove_responsability_METHOD_ID: 01975 { 01976 NMSTL::RPCDefs<Borealis::CentralLookupServer>::remove_responsability_IN *in = new NMSTL::RPCDefs<Borealis::CentralLookupServer>::remove_responsability_IN; 01977 NMSTL::ptr<NMSTL::rpc_request> req(in); 01978 if (is >> *in) return req; 01979 } 01980 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::remove_responsabilities_METHOD_ID: 01981 { 01982 NMSTL::RPCDefs<Borealis::CentralLookupServer>::remove_responsabilities_IN *in = new NMSTL::RPCDefs<Borealis::CentralLookupServer>::remove_responsabilities_IN; 01983 NMSTL::ptr<NMSTL::rpc_request> req(in); 01984 if (is >> *in) return req; 01985 } 01986 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::get_responsabilities_METHOD_ID: 01987 { 01988 NMSTL::RPCDefs<Borealis::CentralLookupServer>::get_responsabilities_IN *in = new NMSTL::RPCDefs<Borealis::CentralLookupServer>::get_responsabilities_IN; 01989 NMSTL::ptr<NMSTL::rpc_request> req(in); 01990 if (is >> *in) return req; 01991 } 01992 case NMSTL::RPCDefs<Borealis::CentralLookupServer>::dump_METHOD_ID: 01993 { 01994 NMSTL::RPCDefs<Borealis::CentralLookupServer>::dump_IN *in = new NMSTL::RPCDefs<Borealis::CentralLookupServer>::dump_IN; 01995 NMSTL::ptr<NMSTL::rpc_request> req(in); 01996 if (is >> *in) return req; 01997 } 01998 } 01999 return NMSTL::ptr<NMSTL::rpc_request>(); 02000 } 02001 02002 02003 #endif 02004