Ice 3.7 C++11 API Reference
IceBox.h
Go to the documentation of this file.
1 //
2 // Copyright (c) ZeroC, Inc. All rights reserved.
3 //
4 //
5 // Ice version 3.7.10
6 //
7 // <auto-generated>
8 //
9 // Generated from file `IceBox.ice'
10 //
11 // Warning: do not edit this file.
12 //
13 // </auto-generated>
14 //
15 
16 #ifndef __IceBox_IceBox_h__
17 #define __IceBox_IceBox_h__
18 
19 #include <IceUtil/PushDisableWarnings.h>
20 #include <Ice/ProxyF.h>
21 #include <Ice/ObjectF.h>
22 #include <Ice/ValueF.h>
23 #include <Ice/Exception.h>
24 #include <Ice/LocalObject.h>
25 #include <Ice/StreamHelpers.h>
26 #include <Ice/Comparable.h>
27 #include <Ice/Proxy.h>
28 #include <Ice/Object.h>
29 #include <Ice/GCObject.h>
30 #include <Ice/Value.h>
31 #include <Ice/Incoming.h>
32 #include <Ice/FactoryTableInit.h>
33 #include <IceUtil/ScopedArray.h>
34 #include <Ice/Optional.h>
35 #include <Ice/ExceptionHelpers.h>
36 #include <Ice/BuiltinSequences.h>
37 #include <Ice/CommunicatorF.h>
38 #include <Ice/PropertiesF.h>
39 #include <Ice/SliceChecksumDict.h>
40 #include <IceUtil/UndefSysMacros.h>
41 #include <IceBox/Config.h>
42 
43 #ifndef ICE_IGNORE_VERSION
44 # if ICE_INT_VERSION / 100 != 307
45 # error Ice version mismatch!
46 # endif
47 # if ICE_INT_VERSION % 100 >= 50
48 # error Beta header file detected
49 # endif
50 # if ICE_INT_VERSION % 100 < 10
51 # error Ice patch level mismatch!
52 # endif
53 #endif
54 
55 #ifndef ICEBOX_API
56 # if defined(ICE_STATIC_LIBS)
57 # define ICEBOX_API
58 # elif defined(ICEBOX_API_EXPORTS)
59 # define ICEBOX_API ICE_DECLSPEC_EXPORT
60 # else
61 # define ICEBOX_API ICE_DECLSPEC_IMPORT
62 # endif
63 #endif
64 
65 #ifdef ICE_CPP11_MAPPING // C++11 mapping
66 
67 namespace IceBox
68 {
69 
70 class Service;
71 class ServiceObserver;
72 class ServiceObserverPrx;
73 class ServiceManager;
74 class ServiceManagerPrx;
75 
76 }
77 
78 namespace IceBox
79 {
80 
88 class ICE_CLASS(ICEBOX_API) FailureException : public ::Ice::LocalExceptionHelper<FailureException, ::Ice::LocalException>
89 {
90 public:
91 
92  ICE_MEMBER(ICEBOX_API) virtual ~FailureException();
93 
94  FailureException(const FailureException&) = default;
95 
101  FailureException(const char* file, int line) : ::Ice::LocalExceptionHelper<FailureException, ::Ice::LocalException>(file, line)
102  {
103  }
104 
112  FailureException(const char* file, int line, const ::std::string& reason) : ::Ice::LocalExceptionHelper<FailureException, ::Ice::LocalException>(file, line),
113  reason(reason)
114  {
115  }
116 
121  std::tuple<const ::std::string&> ice_tuple() const
122  {
123  return std::tie(reason);
124  }
125 
130  ICE_MEMBER(ICEBOX_API) static const ::std::string& ice_staticId();
135  ICE_MEMBER(ICEBOX_API) virtual void ice_print(::std::ostream& stream) const override;
136 
140  ::std::string reason;
141 };
142 
148 class ICE_CLASS(ICEBOX_API) AlreadyStartedException : public ::Ice::UserExceptionHelper<AlreadyStartedException, ::Ice::UserException>
149 {
150 public:
151 
152  ICE_MEMBER(ICEBOX_API) virtual ~AlreadyStartedException();
153 
154  AlreadyStartedException(const AlreadyStartedException&) = default;
155 
156  AlreadyStartedException() = default;
157 
162  std::tuple<> ice_tuple() const
163  {
164  return std::tie();
165  }
166 
171  ICE_MEMBER(ICEBOX_API) static const ::std::string& ice_staticId();
172 };
173 
175 static AlreadyStartedException _iceS_AlreadyStartedException_init;
177 
183 class ICE_CLASS(ICEBOX_API) AlreadyStoppedException : public ::Ice::UserExceptionHelper<AlreadyStoppedException, ::Ice::UserException>
184 {
185 public:
186 
187  ICE_MEMBER(ICEBOX_API) virtual ~AlreadyStoppedException();
188 
189  AlreadyStoppedException(const AlreadyStoppedException&) = default;
190 
191  AlreadyStoppedException() = default;
192 
197  std::tuple<> ice_tuple() const
198  {
199  return std::tie();
200  }
201 
206  ICE_MEMBER(ICEBOX_API) static const ::std::string& ice_staticId();
207 };
208 
214 class ICE_CLASS(ICEBOX_API) NoSuchServiceException : public ::Ice::UserExceptionHelper<NoSuchServiceException, ::Ice::UserException>
215 {
216 public:
217 
218  ICE_MEMBER(ICEBOX_API) virtual ~NoSuchServiceException();
219 
220  NoSuchServiceException(const NoSuchServiceException&) = default;
221 
222  NoSuchServiceException() = default;
223 
228  std::tuple<> ice_tuple() const
229  {
230  return std::tie();
231  }
232 
237  ICE_MEMBER(ICEBOX_API) static const ::std::string& ice_staticId();
238 };
239 
240 }
241 
242 namespace IceBox
243 {
244 
249 class ICE_CLASS(ICEBOX_API) Service
250 {
251 public:
252 
253  ICE_MEMBER(ICEBOX_API) virtual ~Service();
254 
270  virtual void start(const ::std::string& name, const ::std::shared_ptr<::Ice::Communicator>& communicator, const ::Ice::StringSeq& args) = 0;
271 
275  virtual void stop() = 0;
276 };
277 
278 }
279 
280 namespace IceBox
281 {
282 
289 class ICEBOX_API ServiceObserver : public virtual ::Ice::Object
290 {
291 public:
292 
293  using ProxyType = ServiceObserverPrx;
294 
301  virtual bool ice_isA(::std::string id, const ::Ice::Current& current) const override;
302 
308  virtual ::std::vector<::std::string> ice_ids(const ::Ice::Current& current) const override;
309 
315  virtual ::std::string ice_id(const ::Ice::Current& current) const override;
316 
321  static const ::std::string& ice_staticId();
322 
328  virtual void servicesStarted(::Ice::StringSeq services, const ::Ice::Current& current) = 0;
330  bool _iceD_servicesStarted(::IceInternal::Incoming&, const ::Ice::Current&);
332 
338  virtual void servicesStopped(::Ice::StringSeq services, const ::Ice::Current& current) = 0;
340  bool _iceD_servicesStopped(::IceInternal::Incoming&, const ::Ice::Current&);
342 
344  virtual bool _iceDispatch(::IceInternal::Incoming&, const ::Ice::Current&) override;
346 };
347 
353 class ICEBOX_API ServiceManager : public virtual ::Ice::Object
354 {
355 public:
356 
357  using ProxyType = ServiceManagerPrx;
358 
365  virtual bool ice_isA(::std::string id, const ::Ice::Current& current) const override;
366 
372  virtual ::std::vector<::std::string> ice_ids(const ::Ice::Current& current) const override;
373 
379  virtual ::std::string ice_id(const ::Ice::Current& current) const override;
380 
385  static const ::std::string& ice_staticId();
386 
392  virtual ::Ice::SliceChecksumDict getSliceChecksums(const ::Ice::Current& current) const = 0;
394  bool _iceD_getSliceChecksums(::IceInternal::Incoming&, const ::Ice::Current&) const;
396 
404  virtual void startService(::std::string service, const ::Ice::Current& current) = 0;
406  bool _iceD_startService(::IceInternal::Incoming&, const ::Ice::Current&);
408 
416  virtual void stopService(::std::string service, const ::Ice::Current& current) = 0;
418  bool _iceD_stopService(::IceInternal::Incoming&, const ::Ice::Current&);
420 
426  virtual void addObserver(::std::shared_ptr<ServiceObserverPrx> observer, const ::Ice::Current& current) = 0;
428  bool _iceD_addObserver(::IceInternal::Incoming&, const ::Ice::Current&);
430 
435  virtual void shutdown(const ::Ice::Current& current) = 0;
437  bool _iceD_shutdown(::IceInternal::Incoming&, const ::Ice::Current&);
439 
441  virtual bool _iceDispatch(::IceInternal::Incoming&, const ::Ice::Current&) override;
443 };
444 
445 }
446 
447 namespace IceBox
448 {
449 
456 class ICE_CLASS(ICEBOX_API) ServiceObserverPrx : public virtual ::Ice::Proxy<ServiceObserverPrx, ::Ice::ObjectPrx>
457 {
458 public:
459 
465  void servicesStarted(const ::Ice::StringSeq& services, const ::Ice::Context& context = ::Ice::noExplicitContext)
466  {
467  _makePromiseOutgoing<void>(true, this, &ServiceObserverPrx::_iceI_servicesStarted, services, context).get();
468  }
469 
476  template<template<typename> class P = ::std::promise>
477  auto servicesStartedAsync(const ::Ice::StringSeq& services, const ::Ice::Context& context = ::Ice::noExplicitContext)
478  -> decltype(::std::declval<P<void>>().get_future())
479  {
480  return _makePromiseOutgoing<void, P>(false, this, &ServiceObserverPrx::_iceI_servicesStarted, services, context);
481  }
482 
492  ::std::function<void()>
493  servicesStartedAsync(const ::Ice::StringSeq& services,
494  ::std::function<void()> response,
495  ::std::function<void(::std::exception_ptr)> ex = nullptr,
496  ::std::function<void(bool)> sent = nullptr,
497  const ::Ice::Context& context = ::Ice::noExplicitContext)
498  {
499  return _makeLamdaOutgoing<void>(std::move(response), std::move(ex), std::move(sent), this, &IceBox::ServiceObserverPrx::_iceI_servicesStarted, services, context);
500  }
501 
503  ICE_MEMBER(ICEBOX_API) void _iceI_servicesStarted(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&, const ::Ice::StringSeq&, const ::Ice::Context&);
505 
511  void servicesStopped(const ::Ice::StringSeq& services, const ::Ice::Context& context = ::Ice::noExplicitContext)
512  {
513  _makePromiseOutgoing<void>(true, this, &ServiceObserverPrx::_iceI_servicesStopped, services, context).get();
514  }
515 
522  template<template<typename> class P = ::std::promise>
523  auto servicesStoppedAsync(const ::Ice::StringSeq& services, const ::Ice::Context& context = ::Ice::noExplicitContext)
524  -> decltype(::std::declval<P<void>>().get_future())
525  {
526  return _makePromiseOutgoing<void, P>(false, this, &ServiceObserverPrx::_iceI_servicesStopped, services, context);
527  }
528 
538  ::std::function<void()>
539  servicesStoppedAsync(const ::Ice::StringSeq& services,
540  ::std::function<void()> response,
541  ::std::function<void(::std::exception_ptr)> ex = nullptr,
542  ::std::function<void(bool)> sent = nullptr,
543  const ::Ice::Context& context = ::Ice::noExplicitContext)
544  {
545  return _makeLamdaOutgoing<void>(std::move(response), std::move(ex), std::move(sent), this, &IceBox::ServiceObserverPrx::_iceI_servicesStopped, services, context);
546  }
547 
549  ICE_MEMBER(ICEBOX_API) void _iceI_servicesStopped(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&, const ::Ice::StringSeq&, const ::Ice::Context&);
551 
556  ICE_MEMBER(ICEBOX_API) static const ::std::string& ice_staticId();
557 
558 protected:
559 
561  ServiceObserverPrx() = default;
562  friend ::std::shared_ptr<ServiceObserverPrx> IceInternal::createProxy<ServiceObserverPrx>();
563 
564  ICE_MEMBER(ICEBOX_API) virtual ::std::shared_ptr<::Ice::ObjectPrx> _newInstance() const override;
566 };
567 
573 class ICE_CLASS(ICEBOX_API) ServiceManagerPrx : public virtual ::Ice::Proxy<ServiceManagerPrx, ::Ice::ObjectPrx>
574 {
575 public:
576 
582  ::Ice::SliceChecksumDict getSliceChecksums(const ::Ice::Context& context = ::Ice::noExplicitContext)
583  {
584  return _makePromiseOutgoing<::Ice::SliceChecksumDict>(true, this, &ServiceManagerPrx::_iceI_getSliceChecksums, context).get();
585  }
586 
592  template<template<typename> class P = ::std::promise>
593  auto getSliceChecksumsAsync(const ::Ice::Context& context = ::Ice::noExplicitContext)
594  -> decltype(::std::declval<P<::Ice::SliceChecksumDict>>().get_future())
595  {
596  return _makePromiseOutgoing<::Ice::SliceChecksumDict, P>(false, this, &ServiceManagerPrx::_iceI_getSliceChecksums, context);
597  }
598 
607  ::std::function<void()>
608  getSliceChecksumsAsync(::std::function<void(::Ice::SliceChecksumDict)> response,
609  ::std::function<void(::std::exception_ptr)> ex = nullptr,
610  ::std::function<void(bool)> sent = nullptr,
611  const ::Ice::Context& context = ::Ice::noExplicitContext)
612  {
613  return _makeLamdaOutgoing<::Ice::SliceChecksumDict>(std::move(response), std::move(ex), std::move(sent), this, &IceBox::ServiceManagerPrx::_iceI_getSliceChecksums, context);
614  }
615 
617  ICE_MEMBER(ICEBOX_API) void _iceI_getSliceChecksums(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::Ice::SliceChecksumDict>>&, const ::Ice::Context&);
619 
627  void startService(const ::std::string& service, const ::Ice::Context& context = ::Ice::noExplicitContext)
628  {
629  _makePromiseOutgoing<void>(true, this, &ServiceManagerPrx::_iceI_startService, service, context).get();
630  }
631 
638  template<template<typename> class P = ::std::promise>
639  auto startServiceAsync(const ::std::string& service, const ::Ice::Context& context = ::Ice::noExplicitContext)
640  -> decltype(::std::declval<P<void>>().get_future())
641  {
642  return _makePromiseOutgoing<void, P>(false, this, &ServiceManagerPrx::_iceI_startService, service, context);
643  }
644 
654  ::std::function<void()>
655  startServiceAsync(const ::std::string& service,
656  ::std::function<void()> response,
657  ::std::function<void(::std::exception_ptr)> ex = nullptr,
658  ::std::function<void(bool)> sent = nullptr,
659  const ::Ice::Context& context = ::Ice::noExplicitContext)
660  {
661  return _makeLamdaOutgoing<void>(std::move(response), std::move(ex), std::move(sent), this, &IceBox::ServiceManagerPrx::_iceI_startService, service, context);
662  }
663 
665  ICE_MEMBER(ICEBOX_API) void _iceI_startService(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&, const ::std::string&, const ::Ice::Context&);
667 
675  void stopService(const ::std::string& service, const ::Ice::Context& context = ::Ice::noExplicitContext)
676  {
677  _makePromiseOutgoing<void>(true, this, &ServiceManagerPrx::_iceI_stopService, service, context).get();
678  }
679 
686  template<template<typename> class P = ::std::promise>
687  auto stopServiceAsync(const ::std::string& service, const ::Ice::Context& context = ::Ice::noExplicitContext)
688  -> decltype(::std::declval<P<void>>().get_future())
689  {
690  return _makePromiseOutgoing<void, P>(false, this, &ServiceManagerPrx::_iceI_stopService, service, context);
691  }
692 
702  ::std::function<void()>
703  stopServiceAsync(const ::std::string& service,
704  ::std::function<void()> response,
705  ::std::function<void(::std::exception_ptr)> ex = nullptr,
706  ::std::function<void(bool)> sent = nullptr,
707  const ::Ice::Context& context = ::Ice::noExplicitContext)
708  {
709  return _makeLamdaOutgoing<void>(std::move(response), std::move(ex), std::move(sent), this, &IceBox::ServiceManagerPrx::_iceI_stopService, service, context);
710  }
711 
713  ICE_MEMBER(ICEBOX_API) void _iceI_stopService(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&, const ::std::string&, const ::Ice::Context&);
715 
721  void addObserver(const ::std::shared_ptr<ServiceObserverPrx>& observer, const ::Ice::Context& context = ::Ice::noExplicitContext)
722  {
723  _makePromiseOutgoing<void>(true, this, &ServiceManagerPrx::_iceI_addObserver, observer, context).get();
724  }
725 
732  template<template<typename> class P = ::std::promise>
733  auto addObserverAsync(const ::std::shared_ptr<ServiceObserverPrx>& observer, const ::Ice::Context& context = ::Ice::noExplicitContext)
734  -> decltype(::std::declval<P<void>>().get_future())
735  {
736  return _makePromiseOutgoing<void, P>(false, this, &ServiceManagerPrx::_iceI_addObserver, observer, context);
737  }
738 
748  ::std::function<void()>
749  addObserverAsync(const ::std::shared_ptr<ServiceObserverPrx>& observer,
750  ::std::function<void()> response,
751  ::std::function<void(::std::exception_ptr)> ex = nullptr,
752  ::std::function<void(bool)> sent = nullptr,
753  const ::Ice::Context& context = ::Ice::noExplicitContext)
754  {
755  return _makeLamdaOutgoing<void>(std::move(response), std::move(ex), std::move(sent), this, &IceBox::ServiceManagerPrx::_iceI_addObserver, observer, context);
756  }
757 
759  ICE_MEMBER(ICEBOX_API) void _iceI_addObserver(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&, const ::std::shared_ptr<ServiceObserverPrx>&, const ::Ice::Context&);
761 
766  void shutdown(const ::Ice::Context& context = ::Ice::noExplicitContext)
767  {
768  _makePromiseOutgoing<void>(true, this, &ServiceManagerPrx::_iceI_shutdown, context).get();
769  }
770 
776  template<template<typename> class P = ::std::promise>
777  auto shutdownAsync(const ::Ice::Context& context = ::Ice::noExplicitContext)
778  -> decltype(::std::declval<P<void>>().get_future())
779  {
780  return _makePromiseOutgoing<void, P>(false, this, &ServiceManagerPrx::_iceI_shutdown, context);
781  }
782 
791  ::std::function<void()>
792  shutdownAsync(::std::function<void()> response,
793  ::std::function<void(::std::exception_ptr)> ex = nullptr,
794  ::std::function<void(bool)> sent = nullptr,
795  const ::Ice::Context& context = ::Ice::noExplicitContext)
796  {
797  return _makeLamdaOutgoing<void>(std::move(response), std::move(ex), std::move(sent), this, &IceBox::ServiceManagerPrx::_iceI_shutdown, context);
798  }
799 
801  ICE_MEMBER(ICEBOX_API) void _iceI_shutdown(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&, const ::Ice::Context&);
803 
808  ICE_MEMBER(ICEBOX_API) static const ::std::string& ice_staticId();
809 
810 protected:
811 
813  ServiceManagerPrx() = default;
814  friend ::std::shared_ptr<ServiceManagerPrx> IceInternal::createProxy<ServiceManagerPrx>();
815 
816  ICE_MEMBER(ICEBOX_API) virtual ::std::shared_ptr<::Ice::ObjectPrx> _newInstance() const override;
818 };
819 
820 }
821 
823 namespace Ice
824 {
825 
826 }
828 
830 namespace IceBox
831 {
832 
833 using ServicePtr = ::std::shared_ptr<Service>;
834 
835 using ServiceObserverPtr = ::std::shared_ptr<ServiceObserver>;
836 using ServiceObserverPrxPtr = ::std::shared_ptr<ServiceObserverPrx>;
837 
838 using ServiceManagerPtr = ::std::shared_ptr<ServiceManager>;
839 using ServiceManagerPrxPtr = ::std::shared_ptr<ServiceManagerPrx>;
840 
841 }
843 
844 #else // C++98 mapping
845 
846 namespace IceProxy
847 {
848 
849 namespace IceBox
850 {
851 
852 class ServiceObserver;
854 ICEBOX_API void _readProxy(::Ice::InputStream*, ::IceInternal::ProxyHandle< ServiceObserver>&);
855 ICEBOX_API ::IceProxy::Ice::Object* upCast(ServiceObserver*);
857 
858 class ServiceManager;
860 ICEBOX_API void _readProxy(::Ice::InputStream*, ::IceInternal::ProxyHandle< ServiceManager>&);
861 ICEBOX_API ::IceProxy::Ice::Object* upCast(ServiceManager*);
863 
864 }
865 
866 }
867 
868 namespace IceBox
869 {
870 
871 class Service;
873 ICEBOX_API ::Ice::LocalObject* upCast(Service*);
875 typedef ::IceInternal::Handle< Service> ServicePtr;
876 
877 class ServiceObserver;
879 ICEBOX_API ::Ice::Object* upCast(ServiceObserver*);
881 typedef ::IceInternal::Handle< ServiceObserver> ServiceObserverPtr;
882 typedef ::IceInternal::ProxyHandle< ::IceProxy::IceBox::ServiceObserver> ServiceObserverPrx;
883 typedef ServiceObserverPrx ServiceObserverPrxPtr;
885 ICEBOX_API void _icePatchObjectPtr(ServiceObserverPtr&, const ::Ice::ObjectPtr&);
887 
888 class ServiceManager;
890 ICEBOX_API ::Ice::Object* upCast(ServiceManager*);
892 typedef ::IceInternal::Handle< ServiceManager> ServiceManagerPtr;
893 typedef ::IceInternal::ProxyHandle< ::IceProxy::IceBox::ServiceManager> ServiceManagerPrx;
894 typedef ServiceManagerPrx ServiceManagerPrxPtr;
896 ICEBOX_API void _icePatchObjectPtr(ServiceManagerPtr&, const ::Ice::ObjectPtr&);
898 
899 }
900 
901 namespace IceBox
902 {
903 
911 class ICEBOX_API FailureException : public ::Ice::LocalException
912 {
913 public:
914 
920  FailureException(const char* file, int line);
928  FailureException(const char* file, int line, const ::std::string& reason);
929 
930 #ifdef ICE_CPP11_COMPILER
931  FailureException(const FailureException&) = default;
932  virtual ~FailureException();
933 #else
934  virtual ~FailureException() throw();
935 #endif
936 
941  virtual ::std::string ice_id() const;
946  virtual void ice_print(::std::ostream& stream) const;
951  virtual FailureException* ice_clone() const;
955  virtual void ice_throw() const;
956 
960  ::std::string reason;
961 };
962 
968 class ICEBOX_API AlreadyStartedException : public ::Ice::UserException
969 {
970 public:
971 
972  AlreadyStartedException() {}
973 
974 #ifdef ICE_CPP11_COMPILER
975  AlreadyStartedException(const AlreadyStartedException&) = default;
976  virtual ~AlreadyStartedException();
977 #else
978  virtual ~AlreadyStartedException() throw();
979 #endif
980 
985  virtual ::std::string ice_id() const;
990  virtual AlreadyStartedException* ice_clone() const;
994  virtual void ice_throw() const;
995 
996 protected:
997 
999  virtual void _writeImpl(::Ice::OutputStream*) const;
1000  virtual void _readImpl(::Ice::InputStream*);
1002 };
1003 
1005 static AlreadyStartedException _iceS_AlreadyStartedException_init;
1007 
1013 class ICEBOX_API AlreadyStoppedException : public ::Ice::UserException
1014 {
1015 public:
1016 
1017  AlreadyStoppedException() {}
1018 
1019 #ifdef ICE_CPP11_COMPILER
1020  AlreadyStoppedException(const AlreadyStoppedException&) = default;
1021  virtual ~AlreadyStoppedException();
1022 #else
1023  virtual ~AlreadyStoppedException() throw();
1024 #endif
1025 
1030  virtual ::std::string ice_id() const;
1035  virtual AlreadyStoppedException* ice_clone() const;
1039  virtual void ice_throw() const;
1040 
1041 protected:
1042 
1044  virtual void _writeImpl(::Ice::OutputStream*) const;
1045  virtual void _readImpl(::Ice::InputStream*);
1047 };
1048 
1054 class ICEBOX_API NoSuchServiceException : public ::Ice::UserException
1055 {
1056 public:
1057 
1058  NoSuchServiceException() {}
1059 
1060 #ifdef ICE_CPP11_COMPILER
1061  NoSuchServiceException(const NoSuchServiceException&) = default;
1062  virtual ~NoSuchServiceException();
1063 #else
1064  virtual ~NoSuchServiceException() throw();
1065 #endif
1066 
1071  virtual ::std::string ice_id() const;
1076  virtual NoSuchServiceException* ice_clone() const;
1080  virtual void ice_throw() const;
1081 
1082 protected:
1083 
1085  virtual void _writeImpl(::Ice::OutputStream*) const;
1086  virtual void _readImpl(::Ice::InputStream*);
1088 };
1089 
1090 }
1091 
1092 namespace IceBox
1093 {
1094 
1100 class Callback_ServiceObserver_servicesStarted_Base : public virtual ::IceInternal::CallbackBase { };
1101 typedef ::IceUtil::Handle< Callback_ServiceObserver_servicesStarted_Base> Callback_ServiceObserver_servicesStartedPtr;
1102 
1108 class Callback_ServiceObserver_servicesStopped_Base : public virtual ::IceInternal::CallbackBase { };
1109 typedef ::IceUtil::Handle< Callback_ServiceObserver_servicesStopped_Base> Callback_ServiceObserver_servicesStoppedPtr;
1110 
1116 class Callback_ServiceManager_getSliceChecksums_Base : public virtual ::IceInternal::CallbackBase { };
1117 typedef ::IceUtil::Handle< Callback_ServiceManager_getSliceChecksums_Base> Callback_ServiceManager_getSliceChecksumsPtr;
1118 
1124 class Callback_ServiceManager_startService_Base : public virtual ::IceInternal::CallbackBase { };
1125 typedef ::IceUtil::Handle< Callback_ServiceManager_startService_Base> Callback_ServiceManager_startServicePtr;
1126 
1132 class Callback_ServiceManager_stopService_Base : public virtual ::IceInternal::CallbackBase { };
1133 typedef ::IceUtil::Handle< Callback_ServiceManager_stopService_Base> Callback_ServiceManager_stopServicePtr;
1134 
1140 class Callback_ServiceManager_addObserver_Base : public virtual ::IceInternal::CallbackBase { };
1141 typedef ::IceUtil::Handle< Callback_ServiceManager_addObserver_Base> Callback_ServiceManager_addObserverPtr;
1142 
1148 class Callback_ServiceManager_shutdown_Base : public virtual ::IceInternal::CallbackBase { };
1149 typedef ::IceUtil::Handle< Callback_ServiceManager_shutdown_Base> Callback_ServiceManager_shutdownPtr;
1150 
1151 }
1152 
1153 namespace IceProxy
1154 {
1155 
1156 namespace IceBox
1157 {
1158 
1159 class ICE_CLASS(ICEBOX_API) ServiceObserver : public virtual ::Ice::Proxy<ServiceObserver, ::IceProxy::Ice::Object>
1160 {
1161 public:
1162 
1168  ICE_MEMBER(ICEBOX_API) void servicesStarted(const ::Ice::StringSeq& services, const ::Ice::Context& context = ::Ice::noExplicitContext)
1169  {
1170  end_servicesStarted(_iceI_begin_servicesStarted(services, context, ::IceInternal::dummyCallback, 0, true));
1171  }
1172 
1179  ::Ice::AsyncResultPtr begin_servicesStarted(const ::Ice::StringSeq& services, const ::Ice::Context& context = ::Ice::noExplicitContext)
1180  {
1181  return _iceI_begin_servicesStarted(services, context, ::IceInternal::dummyCallback, 0);
1182  }
1183 
1191  ::Ice::AsyncResultPtr begin_servicesStarted(const ::Ice::StringSeq& services, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1192  {
1193  return _iceI_begin_servicesStarted(services, ::Ice::noExplicitContext, cb, cookie);
1194  }
1195 
1204  ::Ice::AsyncResultPtr begin_servicesStarted(const ::Ice::StringSeq& services, const ::Ice::Context& context, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1205  {
1206  return _iceI_begin_servicesStarted(services, context, cb, cookie);
1207  }
1208 
1216  ::Ice::AsyncResultPtr begin_servicesStarted(const ::Ice::StringSeq& services, const ::IceBox::Callback_ServiceObserver_servicesStartedPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1217  {
1218  return _iceI_begin_servicesStarted(services, ::Ice::noExplicitContext, cb, cookie);
1219  }
1220 
1229  ::Ice::AsyncResultPtr begin_servicesStarted(const ::Ice::StringSeq& services, const ::Ice::Context& context, const ::IceBox::Callback_ServiceObserver_servicesStartedPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1230  {
1231  return _iceI_begin_servicesStarted(services, context, cb, cookie);
1232  }
1233 
1238  ICE_MEMBER(ICEBOX_API) void end_servicesStarted(const ::Ice::AsyncResultPtr& result);
1239 
1240 private:
1241 
1242  ICE_MEMBER(ICEBOX_API) ::Ice::AsyncResultPtr _iceI_begin_servicesStarted(const ::Ice::StringSeq&, const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
1243 
1244 public:
1245 
1251  ICE_MEMBER(ICEBOX_API) void servicesStopped(const ::Ice::StringSeq& services, const ::Ice::Context& context = ::Ice::noExplicitContext)
1252  {
1253  end_servicesStopped(_iceI_begin_servicesStopped(services, context, ::IceInternal::dummyCallback, 0, true));
1254  }
1255 
1262  ::Ice::AsyncResultPtr begin_servicesStopped(const ::Ice::StringSeq& services, const ::Ice::Context& context = ::Ice::noExplicitContext)
1263  {
1264  return _iceI_begin_servicesStopped(services, context, ::IceInternal::dummyCallback, 0);
1265  }
1266 
1274  ::Ice::AsyncResultPtr begin_servicesStopped(const ::Ice::StringSeq& services, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1275  {
1276  return _iceI_begin_servicesStopped(services, ::Ice::noExplicitContext, cb, cookie);
1277  }
1278 
1287  ::Ice::AsyncResultPtr begin_servicesStopped(const ::Ice::StringSeq& services, const ::Ice::Context& context, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1288  {
1289  return _iceI_begin_servicesStopped(services, context, cb, cookie);
1290  }
1291 
1299  ::Ice::AsyncResultPtr begin_servicesStopped(const ::Ice::StringSeq& services, const ::IceBox::Callback_ServiceObserver_servicesStoppedPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1300  {
1301  return _iceI_begin_servicesStopped(services, ::Ice::noExplicitContext, cb, cookie);
1302  }
1303 
1312  ::Ice::AsyncResultPtr begin_servicesStopped(const ::Ice::StringSeq& services, const ::Ice::Context& context, const ::IceBox::Callback_ServiceObserver_servicesStoppedPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1313  {
1314  return _iceI_begin_servicesStopped(services, context, cb, cookie);
1315  }
1316 
1321  ICE_MEMBER(ICEBOX_API) void end_servicesStopped(const ::Ice::AsyncResultPtr& result);
1322 
1323 private:
1324 
1325  ICE_MEMBER(ICEBOX_API) ::Ice::AsyncResultPtr _iceI_begin_servicesStopped(const ::Ice::StringSeq&, const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
1326 
1327 public:
1328 
1333  ICE_MEMBER(ICEBOX_API) static const ::std::string& ice_staticId();
1334 
1335 protected:
1337 
1338  ICE_MEMBER(ICEBOX_API) virtual ::IceProxy::Ice::Object* _newInstance() const;
1340 };
1341 
1342 class ICE_CLASS(ICEBOX_API) ServiceManager : public virtual ::Ice::Proxy<ServiceManager, ::IceProxy::Ice::Object>
1343 {
1344 public:
1345 
1351  ICE_MEMBER(ICEBOX_API) ::Ice::SliceChecksumDict getSliceChecksums(const ::Ice::Context& context = ::Ice::noExplicitContext)
1352  {
1353  return end_getSliceChecksums(_iceI_begin_getSliceChecksums(context, ::IceInternal::dummyCallback, 0, true));
1354  }
1355 
1361  ::Ice::AsyncResultPtr begin_getSliceChecksums(const ::Ice::Context& context = ::Ice::noExplicitContext)
1362  {
1363  return _iceI_begin_getSliceChecksums(context, ::IceInternal::dummyCallback, 0);
1364  }
1365 
1372  ::Ice::AsyncResultPtr begin_getSliceChecksums(const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1373  {
1374  return _iceI_begin_getSliceChecksums(::Ice::noExplicitContext, cb, cookie);
1375  }
1376 
1384  ::Ice::AsyncResultPtr begin_getSliceChecksums(const ::Ice::Context& context, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1385  {
1386  return _iceI_begin_getSliceChecksums(context, cb, cookie);
1387  }
1388 
1395  ::Ice::AsyncResultPtr begin_getSliceChecksums(const ::IceBox::Callback_ServiceManager_getSliceChecksumsPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1396  {
1397  return _iceI_begin_getSliceChecksums(::Ice::noExplicitContext, cb, cookie);
1398  }
1399 
1407  ::Ice::AsyncResultPtr begin_getSliceChecksums(const ::Ice::Context& context, const ::IceBox::Callback_ServiceManager_getSliceChecksumsPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1408  {
1409  return _iceI_begin_getSliceChecksums(context, cb, cookie);
1410  }
1411 
1417  ICE_MEMBER(ICEBOX_API) ::Ice::SliceChecksumDict end_getSliceChecksums(const ::Ice::AsyncResultPtr& result);
1418 
1419 private:
1420 
1421  ICE_MEMBER(ICEBOX_API) ::Ice::AsyncResultPtr _iceI_begin_getSliceChecksums(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
1422 
1423 public:
1424 
1432  ICE_MEMBER(ICEBOX_API) void startService(const ::std::string& service, const ::Ice::Context& context = ::Ice::noExplicitContext)
1433  {
1434  end_startService(_iceI_begin_startService(service, context, ::IceInternal::dummyCallback, 0, true));
1435  }
1436 
1443  ::Ice::AsyncResultPtr begin_startService(const ::std::string& service, const ::Ice::Context& context = ::Ice::noExplicitContext)
1444  {
1445  return _iceI_begin_startService(service, context, ::IceInternal::dummyCallback, 0);
1446  }
1447 
1455  ::Ice::AsyncResultPtr begin_startService(const ::std::string& service, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1456  {
1457  return _iceI_begin_startService(service, ::Ice::noExplicitContext, cb, cookie);
1458  }
1459 
1468  ::Ice::AsyncResultPtr begin_startService(const ::std::string& service, const ::Ice::Context& context, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1469  {
1470  return _iceI_begin_startService(service, context, cb, cookie);
1471  }
1472 
1480  ::Ice::AsyncResultPtr begin_startService(const ::std::string& service, const ::IceBox::Callback_ServiceManager_startServicePtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1481  {
1482  return _iceI_begin_startService(service, ::Ice::noExplicitContext, cb, cookie);
1483  }
1484 
1493  ::Ice::AsyncResultPtr begin_startService(const ::std::string& service, const ::Ice::Context& context, const ::IceBox::Callback_ServiceManager_startServicePtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1494  {
1495  return _iceI_begin_startService(service, context, cb, cookie);
1496  }
1497 
1504  ICE_MEMBER(ICEBOX_API) void end_startService(const ::Ice::AsyncResultPtr& result);
1505 
1506 private:
1507 
1508  ICE_MEMBER(ICEBOX_API) ::Ice::AsyncResultPtr _iceI_begin_startService(const ::std::string&, const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
1509 
1510 public:
1511 
1519  ICE_MEMBER(ICEBOX_API) void stopService(const ::std::string& service, const ::Ice::Context& context = ::Ice::noExplicitContext)
1520  {
1521  end_stopService(_iceI_begin_stopService(service, context, ::IceInternal::dummyCallback, 0, true));
1522  }
1523 
1530  ::Ice::AsyncResultPtr begin_stopService(const ::std::string& service, const ::Ice::Context& context = ::Ice::noExplicitContext)
1531  {
1532  return _iceI_begin_stopService(service, context, ::IceInternal::dummyCallback, 0);
1533  }
1534 
1542  ::Ice::AsyncResultPtr begin_stopService(const ::std::string& service, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1543  {
1544  return _iceI_begin_stopService(service, ::Ice::noExplicitContext, cb, cookie);
1545  }
1546 
1555  ::Ice::AsyncResultPtr begin_stopService(const ::std::string& service, const ::Ice::Context& context, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1556  {
1557  return _iceI_begin_stopService(service, context, cb, cookie);
1558  }
1559 
1567  ::Ice::AsyncResultPtr begin_stopService(const ::std::string& service, const ::IceBox::Callback_ServiceManager_stopServicePtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1568  {
1569  return _iceI_begin_stopService(service, ::Ice::noExplicitContext, cb, cookie);
1570  }
1571 
1580  ::Ice::AsyncResultPtr begin_stopService(const ::std::string& service, const ::Ice::Context& context, const ::IceBox::Callback_ServiceManager_stopServicePtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1581  {
1582  return _iceI_begin_stopService(service, context, cb, cookie);
1583  }
1584 
1591  ICE_MEMBER(ICEBOX_API) void end_stopService(const ::Ice::AsyncResultPtr& result);
1592 
1593 private:
1594 
1595  ICE_MEMBER(ICEBOX_API) ::Ice::AsyncResultPtr _iceI_begin_stopService(const ::std::string&, const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
1596 
1597 public:
1598 
1604  ICE_MEMBER(ICEBOX_API) void addObserver(const ::IceBox::ServiceObserverPrx& observer, const ::Ice::Context& context = ::Ice::noExplicitContext)
1605  {
1606  end_addObserver(_iceI_begin_addObserver(observer, context, ::IceInternal::dummyCallback, 0, true));
1607  }
1608 
1615  ::Ice::AsyncResultPtr begin_addObserver(const ::IceBox::ServiceObserverPrx& observer, const ::Ice::Context& context = ::Ice::noExplicitContext)
1616  {
1617  return _iceI_begin_addObserver(observer, context, ::IceInternal::dummyCallback, 0);
1618  }
1619 
1627  ::Ice::AsyncResultPtr begin_addObserver(const ::IceBox::ServiceObserverPrx& observer, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1628  {
1629  return _iceI_begin_addObserver(observer, ::Ice::noExplicitContext, cb, cookie);
1630  }
1631 
1640  ::Ice::AsyncResultPtr begin_addObserver(const ::IceBox::ServiceObserverPrx& observer, const ::Ice::Context& context, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1641  {
1642  return _iceI_begin_addObserver(observer, context, cb, cookie);
1643  }
1644 
1652  ::Ice::AsyncResultPtr begin_addObserver(const ::IceBox::ServiceObserverPrx& observer, const ::IceBox::Callback_ServiceManager_addObserverPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1653  {
1654  return _iceI_begin_addObserver(observer, ::Ice::noExplicitContext, cb, cookie);
1655  }
1656 
1665  ::Ice::AsyncResultPtr begin_addObserver(const ::IceBox::ServiceObserverPrx& observer, const ::Ice::Context& context, const ::IceBox::Callback_ServiceManager_addObserverPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1666  {
1667  return _iceI_begin_addObserver(observer, context, cb, cookie);
1668  }
1669 
1674  ICE_MEMBER(ICEBOX_API) void end_addObserver(const ::Ice::AsyncResultPtr& result);
1675 
1676 private:
1677 
1678  ICE_MEMBER(ICEBOX_API) ::Ice::AsyncResultPtr _iceI_begin_addObserver(const ::IceBox::ServiceObserverPrx&, const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
1679 
1680 public:
1681 
1686  ICE_MEMBER(ICEBOX_API) void shutdown(const ::Ice::Context& context = ::Ice::noExplicitContext)
1687  {
1688  end_shutdown(_iceI_begin_shutdown(context, ::IceInternal::dummyCallback, 0, true));
1689  }
1690 
1696  ::Ice::AsyncResultPtr begin_shutdown(const ::Ice::Context& context = ::Ice::noExplicitContext)
1697  {
1698  return _iceI_begin_shutdown(context, ::IceInternal::dummyCallback, 0);
1699  }
1700 
1707  ::Ice::AsyncResultPtr begin_shutdown(const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1708  {
1709  return _iceI_begin_shutdown(::Ice::noExplicitContext, cb, cookie);
1710  }
1711 
1719  ::Ice::AsyncResultPtr begin_shutdown(const ::Ice::Context& context, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1720  {
1721  return _iceI_begin_shutdown(context, cb, cookie);
1722  }
1723 
1730  ::Ice::AsyncResultPtr begin_shutdown(const ::IceBox::Callback_ServiceManager_shutdownPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1731  {
1732  return _iceI_begin_shutdown(::Ice::noExplicitContext, cb, cookie);
1733  }
1734 
1742  ::Ice::AsyncResultPtr begin_shutdown(const ::Ice::Context& context, const ::IceBox::Callback_ServiceManager_shutdownPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1743  {
1744  return _iceI_begin_shutdown(context, cb, cookie);
1745  }
1746 
1751  ICE_MEMBER(ICEBOX_API) void end_shutdown(const ::Ice::AsyncResultPtr& result);
1752 
1753 private:
1754 
1755  ICE_MEMBER(ICEBOX_API) ::Ice::AsyncResultPtr _iceI_begin_shutdown(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
1756 
1757 public:
1758 
1763  ICE_MEMBER(ICEBOX_API) static const ::std::string& ice_staticId();
1764 
1765 protected:
1767 
1768  ICE_MEMBER(ICEBOX_API) virtual ::IceProxy::Ice::Object* _newInstance() const;
1770 };
1771 
1772 }
1773 
1774 }
1775 
1776 namespace IceBox
1777 {
1778 
1783 class ICEBOX_API Service : public virtual ::Ice::LocalObject
1784 {
1785 public:
1786 
1787  typedef ServicePtr PointerType;
1788 
1789  virtual ~Service();
1790 
1791 #ifdef ICE_CPP11_COMPILER
1792  Service() = default;
1793  Service(const Service&) = default;
1794  Service& operator=(const Service&) = default;
1795 #endif
1796 
1812  virtual void start(const ::std::string& name, const ::Ice::CommunicatorPtr& communicator, const ::Ice::StringSeq& args) = 0;
1813 
1817  virtual void stop() = 0;
1818 };
1819 
1821 inline bool operator==(const Service& lhs, const Service& rhs)
1822 {
1823  return static_cast<const ::Ice::LocalObject&>(lhs) == static_cast<const ::Ice::LocalObject&>(rhs);
1824 }
1825 
1826 inline bool operator<(const Service& lhs, const Service& rhs)
1827 {
1828  return static_cast<const ::Ice::LocalObject&>(lhs) < static_cast<const ::Ice::LocalObject&>(rhs);
1829 }
1831 
1838 class ICEBOX_API ServiceObserver : public virtual ::Ice::Object
1839 {
1840 public:
1841 
1842  typedef ServiceObserverPrx ProxyType;
1843  typedef ServiceObserverPtr PointerType;
1844 
1845  virtual ~ServiceObserver();
1846 
1847 #ifdef ICE_CPP11_COMPILER
1848  ServiceObserver() = default;
1849  ServiceObserver(const ServiceObserver&) = default;
1850  ServiceObserver& operator=(const ServiceObserver&) = default;
1851 #endif
1852 
1859  virtual bool ice_isA(const ::std::string& id, const ::Ice::Current& current = ::Ice::emptyCurrent) const;
1860 
1866  virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& current = ::Ice::emptyCurrent) const;
1867 
1873  virtual const ::std::string& ice_id(const ::Ice::Current& current = ::Ice::emptyCurrent) const;
1874 
1879  static const ::std::string& ice_staticId();
1880 
1886  virtual void servicesStarted(const ::Ice::StringSeq& services, const ::Ice::Current& current = ::Ice::emptyCurrent) = 0;
1888  bool _iceD_servicesStarted(::IceInternal::Incoming&, const ::Ice::Current&);
1890 
1896  virtual void servicesStopped(const ::Ice::StringSeq& services, const ::Ice::Current& current = ::Ice::emptyCurrent) = 0;
1898  bool _iceD_servicesStopped(::IceInternal::Incoming&, const ::Ice::Current&);
1900 
1902  virtual bool _iceDispatch(::IceInternal::Incoming&, const ::Ice::Current&);
1904 
1905 protected:
1906 
1908  virtual void _iceWriteImpl(::Ice::OutputStream*) const;
1909  virtual void _iceReadImpl(::Ice::InputStream*);
1911 };
1912 
1914 inline bool operator==(const ServiceObserver& lhs, const ServiceObserver& rhs)
1915 {
1916  return static_cast<const ::Ice::Object&>(lhs) == static_cast<const ::Ice::Object&>(rhs);
1917 }
1918 
1919 inline bool operator<(const ServiceObserver& lhs, const ServiceObserver& rhs)
1920 {
1921  return static_cast<const ::Ice::Object&>(lhs) < static_cast<const ::Ice::Object&>(rhs);
1922 }
1924 
1930 class ICEBOX_API ServiceManager : public virtual ::Ice::Object
1931 {
1932 public:
1933 
1934  typedef ServiceManagerPrx ProxyType;
1935  typedef ServiceManagerPtr PointerType;
1936 
1937  virtual ~ServiceManager();
1938 
1939 #ifdef ICE_CPP11_COMPILER
1940  ServiceManager() = default;
1941  ServiceManager(const ServiceManager&) = default;
1942  ServiceManager& operator=(const ServiceManager&) = default;
1943 #endif
1944 
1951  virtual bool ice_isA(const ::std::string& id, const ::Ice::Current& current = ::Ice::emptyCurrent) const;
1952 
1958  virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& current = ::Ice::emptyCurrent) const;
1959 
1965  virtual const ::std::string& ice_id(const ::Ice::Current& current = ::Ice::emptyCurrent) const;
1966 
1971  static const ::std::string& ice_staticId();
1972 
1978  virtual ::Ice::SliceChecksumDict getSliceChecksums(const ::Ice::Current& current = ::Ice::emptyCurrent) const = 0;
1980  bool _iceD_getSliceChecksums(::IceInternal::Incoming&, const ::Ice::Current&) const;
1982 
1990  virtual void startService(const ::std::string& service, const ::Ice::Current& current = ::Ice::emptyCurrent) = 0;
1992  bool _iceD_startService(::IceInternal::Incoming&, const ::Ice::Current&);
1994 
2002  virtual void stopService(const ::std::string& service, const ::Ice::Current& current = ::Ice::emptyCurrent) = 0;
2004  bool _iceD_stopService(::IceInternal::Incoming&, const ::Ice::Current&);
2006 
2012  virtual void addObserver(const ServiceObserverPrx& observer, const ::Ice::Current& current = ::Ice::emptyCurrent) = 0;
2014  bool _iceD_addObserver(::IceInternal::Incoming&, const ::Ice::Current&);
2016 
2021  virtual void shutdown(const ::Ice::Current& current = ::Ice::emptyCurrent) = 0;
2023  bool _iceD_shutdown(::IceInternal::Incoming&, const ::Ice::Current&);
2025 
2027  virtual bool _iceDispatch(::IceInternal::Incoming&, const ::Ice::Current&);
2029 
2030 protected:
2031 
2033  virtual void _iceWriteImpl(::Ice::OutputStream*) const;
2034  virtual void _iceReadImpl(::Ice::InputStream*);
2036 };
2037 
2039 inline bool operator==(const ServiceManager& lhs, const ServiceManager& rhs)
2040 {
2041  return static_cast<const ::Ice::Object&>(lhs) == static_cast<const ::Ice::Object&>(rhs);
2042 }
2043 
2044 inline bool operator<(const ServiceManager& lhs, const ServiceManager& rhs)
2045 {
2046  return static_cast<const ::Ice::Object&>(lhs) < static_cast<const ::Ice::Object&>(rhs);
2047 }
2049 
2050 }
2051 
2053 namespace Ice
2054 {
2055 
2056 template<>
2057 struct StreamableTraits< ::IceBox::AlreadyStartedException>
2058 {
2059  static const StreamHelperCategory helper = StreamHelperCategoryUserException;
2060 };
2061 
2062 template<>
2063 struct StreamableTraits< ::IceBox::AlreadyStoppedException>
2064 {
2065  static const StreamHelperCategory helper = StreamHelperCategoryUserException;
2066 };
2067 
2068 template<>
2069 struct StreamableTraits< ::IceBox::NoSuchServiceException>
2070 {
2071  static const StreamHelperCategory helper = StreamHelperCategoryUserException;
2072 };
2073 
2074 }
2076 
2077 namespace IceBox
2078 {
2079 
2085 template<class T>
2086 class CallbackNC_ServiceObserver_servicesStarted : public Callback_ServiceObserver_servicesStarted_Base, public ::IceInternal::OnewayCallbackNC<T>
2087 {
2088 public:
2089 
2090  typedef IceUtil::Handle<T> TPtr;
2091 
2092  typedef void (T::*Exception)(const ::Ice::Exception&);
2093  typedef void (T::*Sent)(bool);
2094  typedef void (T::*Response)();
2095 
2096  CallbackNC_ServiceObserver_servicesStarted(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
2097  : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
2098  {
2099  }
2100 };
2101 
2110 template<class T> Callback_ServiceObserver_servicesStartedPtr
2111 newCallback_ServiceObserver_servicesStarted(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
2112 {
2113  return new CallbackNC_ServiceObserver_servicesStarted<T>(instance, cb, excb, sentcb);
2114 }
2115 
2123 template<class T> Callback_ServiceObserver_servicesStartedPtr
2124 newCallback_ServiceObserver_servicesStarted(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
2125 {
2126  return new CallbackNC_ServiceObserver_servicesStarted<T>(instance, 0, excb, sentcb);
2127 }
2128 
2137 template<class T> Callback_ServiceObserver_servicesStartedPtr
2138 newCallback_ServiceObserver_servicesStarted(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
2139 {
2140  return new CallbackNC_ServiceObserver_servicesStarted<T>(instance, cb, excb, sentcb);
2141 }
2142 
2150 template<class T> Callback_ServiceObserver_servicesStartedPtr
2151 newCallback_ServiceObserver_servicesStarted(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
2152 {
2153  return new CallbackNC_ServiceObserver_servicesStarted<T>(instance, 0, excb, sentcb);
2154 }
2155 
2161 template<class T, typename CT>
2162 class Callback_ServiceObserver_servicesStarted : public Callback_ServiceObserver_servicesStarted_Base, public ::IceInternal::OnewayCallback<T, CT>
2163 {
2164 public:
2165 
2166  typedef IceUtil::Handle<T> TPtr;
2167 
2168  typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
2169  typedef void (T::*Sent)(bool , const CT&);
2170  typedef void (T::*Response)(const CT&);
2171 
2172  Callback_ServiceObserver_servicesStarted(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
2173  : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
2174  {
2175  }
2176 };
2177 
2187 template<class T, typename CT> Callback_ServiceObserver_servicesStartedPtr
2188 newCallback_ServiceObserver_servicesStarted(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
2189 {
2190  return new Callback_ServiceObserver_servicesStarted<T, CT>(instance, cb, excb, sentcb);
2191 }
2192 
2201 template<class T, typename CT> Callback_ServiceObserver_servicesStartedPtr
2202 newCallback_ServiceObserver_servicesStarted(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
2203 {
2204  return new Callback_ServiceObserver_servicesStarted<T, CT>(instance, 0, excb, sentcb);
2205 }
2206 
2216 template<class T, typename CT> Callback_ServiceObserver_servicesStartedPtr
2217 newCallback_ServiceObserver_servicesStarted(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
2218 {
2219  return new Callback_ServiceObserver_servicesStarted<T, CT>(instance, cb, excb, sentcb);
2220 }
2221 
2230 template<class T, typename CT> Callback_ServiceObserver_servicesStartedPtr
2231 newCallback_ServiceObserver_servicesStarted(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
2232 {
2233  return new Callback_ServiceObserver_servicesStarted<T, CT>(instance, 0, excb, sentcb);
2234 }
2235 
2241 template<class T>
2242 class CallbackNC_ServiceObserver_servicesStopped : public Callback_ServiceObserver_servicesStopped_Base, public ::IceInternal::OnewayCallbackNC<T>
2243 {
2244 public:
2245 
2246  typedef IceUtil::Handle<T> TPtr;
2247 
2248  typedef void (T::*Exception)(const ::Ice::Exception&);
2249  typedef void (T::*Sent)(bool);
2250  typedef void (T::*Response)();
2251 
2252  CallbackNC_ServiceObserver_servicesStopped(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
2253  : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
2254  {
2255  }
2256 };
2257 
2266 template<class T> Callback_ServiceObserver_servicesStoppedPtr
2267 newCallback_ServiceObserver_servicesStopped(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
2268 {
2269  return new CallbackNC_ServiceObserver_servicesStopped<T>(instance, cb, excb, sentcb);
2270 }
2271 
2279 template<class T> Callback_ServiceObserver_servicesStoppedPtr
2280 newCallback_ServiceObserver_servicesStopped(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
2281 {
2282  return new CallbackNC_ServiceObserver_servicesStopped<T>(instance, 0, excb, sentcb);
2283 }
2284 
2293 template<class T> Callback_ServiceObserver_servicesStoppedPtr
2294 newCallback_ServiceObserver_servicesStopped(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
2295 {
2296  return new CallbackNC_ServiceObserver_servicesStopped<T>(instance, cb, excb, sentcb);
2297 }
2298 
2306 template<class T> Callback_ServiceObserver_servicesStoppedPtr
2307 newCallback_ServiceObserver_servicesStopped(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
2308 {
2309  return new CallbackNC_ServiceObserver_servicesStopped<T>(instance, 0, excb, sentcb);
2310 }
2311 
2317 template<class T, typename CT>
2318 class Callback_ServiceObserver_servicesStopped : public Callback_ServiceObserver_servicesStopped_Base, public ::IceInternal::OnewayCallback<T, CT>
2319 {
2320 public:
2321 
2322  typedef IceUtil::Handle<T> TPtr;
2323 
2324  typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
2325  typedef void (T::*Sent)(bool , const CT&);
2326  typedef void (T::*Response)(const CT&);
2327 
2328  Callback_ServiceObserver_servicesStopped(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
2329  : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
2330  {
2331  }
2332 };
2333 
2343 template<class T, typename CT> Callback_ServiceObserver_servicesStoppedPtr
2344 newCallback_ServiceObserver_servicesStopped(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
2345 {
2346  return new Callback_ServiceObserver_servicesStopped<T, CT>(instance, cb, excb, sentcb);
2347 }
2348 
2357 template<class T, typename CT> Callback_ServiceObserver_servicesStoppedPtr
2358 newCallback_ServiceObserver_servicesStopped(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
2359 {
2360  return new Callback_ServiceObserver_servicesStopped<T, CT>(instance, 0, excb, sentcb);
2361 }
2362 
2372 template<class T, typename CT> Callback_ServiceObserver_servicesStoppedPtr
2373 newCallback_ServiceObserver_servicesStopped(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
2374 {
2375  return new Callback_ServiceObserver_servicesStopped<T, CT>(instance, cb, excb, sentcb);
2376 }
2377 
2386 template<class T, typename CT> Callback_ServiceObserver_servicesStoppedPtr
2387 newCallback_ServiceObserver_servicesStopped(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
2388 {
2389  return new Callback_ServiceObserver_servicesStopped<T, CT>(instance, 0, excb, sentcb);
2390 }
2391 
2397 template<class T>
2398 class CallbackNC_ServiceManager_getSliceChecksums : public Callback_ServiceManager_getSliceChecksums_Base, public ::IceInternal::TwowayCallbackNC<T>
2399 {
2400 public:
2401 
2402  typedef IceUtil::Handle<T> TPtr;
2403 
2404  typedef void (T::*Exception)(const ::Ice::Exception&);
2405  typedef void (T::*Sent)(bool);
2406  typedef void (T::*Response)(const ::Ice::SliceChecksumDict&);
2407 
2408  CallbackNC_ServiceManager_getSliceChecksums(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
2409  : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
2410  {
2411  }
2412 
2414  virtual void completed(const ::Ice::AsyncResultPtr& result) const
2415  {
2416  ServiceManagerPrx proxy = ServiceManagerPrx::uncheckedCast(result->getProxy());
2417  ::Ice::SliceChecksumDict ret;
2418  try
2419  {
2420  ret = proxy->end_getSliceChecksums(result);
2421  }
2422  catch(const ::Ice::Exception& ex)
2423  {
2424  ::IceInternal::CallbackNC<T>::exception(result, ex);
2425  return;
2426  }
2427  if(_response)
2428  {
2429  (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
2430  }
2431  }
2433 
2434 private:
2435 
2436  Response _response;
2437 };
2438 
2447 template<class T> Callback_ServiceManager_getSliceChecksumsPtr
2448 newCallback_ServiceManager_getSliceChecksums(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::SliceChecksumDict&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
2449 {
2450  return new CallbackNC_ServiceManager_getSliceChecksums<T>(instance, cb, excb, sentcb);
2451 }
2452 
2461 template<class T> Callback_ServiceManager_getSliceChecksumsPtr
2462 newCallback_ServiceManager_getSliceChecksums(T* instance, void (T::*cb)(const ::Ice::SliceChecksumDict&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
2463 {
2464  return new CallbackNC_ServiceManager_getSliceChecksums<T>(instance, cb, excb, sentcb);
2465 }
2466 
2472 template<class T, typename CT>
2473 class Callback_ServiceManager_getSliceChecksums : public Callback_ServiceManager_getSliceChecksums_Base, public ::IceInternal::TwowayCallback<T, CT>
2474 {
2475 public:
2476 
2477  typedef IceUtil::Handle<T> TPtr;
2478 
2479  typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
2480  typedef void (T::*Sent)(bool , const CT&);
2481  typedef void (T::*Response)(const ::Ice::SliceChecksumDict&, const CT&);
2482 
2483  Callback_ServiceManager_getSliceChecksums(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
2484  : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
2485  {
2486  }
2487 
2489  virtual void completed(const ::Ice::AsyncResultPtr& result) const
2490  {
2491  ServiceManagerPrx proxy = ServiceManagerPrx::uncheckedCast(result->getProxy());
2492  ::Ice::SliceChecksumDict ret;
2493  try
2494  {
2495  ret = proxy->end_getSliceChecksums(result);
2496  }
2497  catch(const ::Ice::Exception& ex)
2498  {
2499  ::IceInternal::Callback<T, CT>::exception(result, ex);
2500  return;
2501  }
2502  if(_response)
2503  {
2504  (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret, CT::dynamicCast(result->getCookie()));
2505  }
2506  }
2508 
2509 private:
2510 
2511  Response _response;
2512 };
2513 
2523 template<class T, typename CT> Callback_ServiceManager_getSliceChecksumsPtr
2524 newCallback_ServiceManager_getSliceChecksums(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::SliceChecksumDict&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
2525 {
2526  return new Callback_ServiceManager_getSliceChecksums<T, CT>(instance, cb, excb, sentcb);
2527 }
2528 
2538 template<class T, typename CT> Callback_ServiceManager_getSliceChecksumsPtr
2539 newCallback_ServiceManager_getSliceChecksums(T* instance, void (T::*cb)(const ::Ice::SliceChecksumDict&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
2540 {
2541  return new Callback_ServiceManager_getSliceChecksums<T, CT>(instance, cb, excb, sentcb);
2542 }
2543 
2549 template<class T>
2550 class CallbackNC_ServiceManager_startService : public Callback_ServiceManager_startService_Base, public ::IceInternal::TwowayCallbackNC<T>
2551 {
2552 public:
2553 
2554  typedef IceUtil::Handle<T> TPtr;
2555 
2556  typedef void (T::*Exception)(const ::Ice::Exception&);
2557  typedef void (T::*Sent)(bool);
2558  typedef void (T::*Response)();
2559 
2560  CallbackNC_ServiceManager_startService(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
2561  : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
2562  {
2563  }
2564 
2566  virtual void completed(const ::Ice::AsyncResultPtr& result) const
2567  {
2568  ServiceManagerPrx proxy = ServiceManagerPrx::uncheckedCast(result->getProxy());
2569  try
2570  {
2571  proxy->end_startService(result);
2572  }
2573  catch(const ::Ice::Exception& ex)
2574  {
2575  ::IceInternal::CallbackNC<T>::exception(result, ex);
2576  return;
2577  }
2578  if(_response)
2579  {
2580  (::IceInternal::CallbackNC<T>::_callback.get()->*_response)();
2581  }
2582  }
2584 
2585 private:
2586 
2587  Response _response;
2588 };
2589 
2598 template<class T> Callback_ServiceManager_startServicePtr
2599 newCallback_ServiceManager_startService(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
2600 {
2601  return new CallbackNC_ServiceManager_startService<T>(instance, cb, excb, sentcb);
2602 }
2603 
2611 template<class T> Callback_ServiceManager_startServicePtr
2612 newCallback_ServiceManager_startService(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
2613 {
2614  return new CallbackNC_ServiceManager_startService<T>(instance, 0, excb, sentcb);
2615 }
2616 
2625 template<class T> Callback_ServiceManager_startServicePtr
2626 newCallback_ServiceManager_startService(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
2627 {
2628  return new CallbackNC_ServiceManager_startService<T>(instance, cb, excb, sentcb);
2629 }
2630 
2638 template<class T> Callback_ServiceManager_startServicePtr
2639 newCallback_ServiceManager_startService(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
2640 {
2641  return new CallbackNC_ServiceManager_startService<T>(instance, 0, excb, sentcb);
2642 }
2643 
2649 template<class T, typename CT>
2650 class Callback_ServiceManager_startService : public Callback_ServiceManager_startService_Base, public ::IceInternal::TwowayCallback<T, CT>
2651 {
2652 public:
2653 
2654  typedef IceUtil::Handle<T> TPtr;
2655 
2656  typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
2657  typedef void (T::*Sent)(bool , const CT&);
2658  typedef void (T::*Response)(const CT&);
2659 
2660  Callback_ServiceManager_startService(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
2661  : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
2662  {
2663  }
2664 
2666  virtual void completed(const ::Ice::AsyncResultPtr& result) const
2667  {
2668  ServiceManagerPrx proxy = ServiceManagerPrx::uncheckedCast(result->getProxy());
2669  try
2670  {
2671  proxy->end_startService(result);
2672  }
2673  catch(const ::Ice::Exception& ex)
2674  {
2675  ::IceInternal::Callback<T, CT>::exception(result, ex);
2676  return;
2677  }
2678  if(_response)
2679  {
2680  (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(CT::dynamicCast(result->getCookie()));
2681  }
2682  }
2684 
2685 private:
2686 
2687  Response _response;
2688 };
2689 
2699 template<class T, typename CT> Callback_ServiceManager_startServicePtr
2700 newCallback_ServiceManager_startService(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
2701 {
2702  return new Callback_ServiceManager_startService<T, CT>(instance, cb, excb, sentcb);
2703 }
2704 
2713 template<class T, typename CT> Callback_ServiceManager_startServicePtr
2714 newCallback_ServiceManager_startService(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
2715 {
2716  return new Callback_ServiceManager_startService<T, CT>(instance, 0, excb, sentcb);
2717 }
2718 
2728 template<class T, typename CT> Callback_ServiceManager_startServicePtr
2729 newCallback_ServiceManager_startService(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
2730 {
2731  return new Callback_ServiceManager_startService<T, CT>(instance, cb, excb, sentcb);
2732 }
2733 
2742 template<class T, typename CT> Callback_ServiceManager_startServicePtr
2743 newCallback_ServiceManager_startService(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
2744 {
2745  return new Callback_ServiceManager_startService<T, CT>(instance, 0, excb, sentcb);
2746 }
2747 
2753 template<class T>
2754 class CallbackNC_ServiceManager_stopService : public Callback_ServiceManager_stopService_Base, public ::IceInternal::TwowayCallbackNC<T>
2755 {
2756 public:
2757 
2758  typedef IceUtil::Handle<T> TPtr;
2759 
2760  typedef void (T::*Exception)(const ::Ice::Exception&);
2761  typedef void (T::*Sent)(bool);
2762  typedef void (T::*Response)();
2763 
2764  CallbackNC_ServiceManager_stopService(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
2765  : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
2766  {
2767  }
2768 
2770  virtual void completed(const ::Ice::AsyncResultPtr& result) const
2771  {
2772  ServiceManagerPrx proxy = ServiceManagerPrx::uncheckedCast(result->getProxy());
2773  try
2774  {
2775  proxy->end_stopService(result);
2776  }
2777  catch(const ::Ice::Exception& ex)
2778  {
2779  ::IceInternal::CallbackNC<T>::exception(result, ex);
2780  return;
2781  }
2782  if(_response)
2783  {
2784  (::IceInternal::CallbackNC<T>::_callback.get()->*_response)();
2785  }
2786  }
2788 
2789 private:
2790 
2791  Response _response;
2792 };
2793 
2802 template<class T> Callback_ServiceManager_stopServicePtr
2803 newCallback_ServiceManager_stopService(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
2804 {
2805  return new CallbackNC_ServiceManager_stopService<T>(instance, cb, excb, sentcb);
2806 }
2807 
2815 template<class T> Callback_ServiceManager_stopServicePtr
2816 newCallback_ServiceManager_stopService(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
2817 {
2818  return new CallbackNC_ServiceManager_stopService<T>(instance, 0, excb, sentcb);
2819 }
2820 
2829 template<class T> Callback_ServiceManager_stopServicePtr
2830 newCallback_ServiceManager_stopService(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
2831 {
2832  return new CallbackNC_ServiceManager_stopService<T>(instance, cb, excb, sentcb);
2833 }
2834 
2842 template<class T> Callback_ServiceManager_stopServicePtr
2843 newCallback_ServiceManager_stopService(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
2844 {
2845  return new CallbackNC_ServiceManager_stopService<T>(instance, 0, excb, sentcb);
2846 }
2847 
2853 template<class T, typename CT>
2854 class Callback_ServiceManager_stopService : public Callback_ServiceManager_stopService_Base, public ::IceInternal::TwowayCallback<T, CT>
2855 {
2856 public:
2857 
2858  typedef IceUtil::Handle<T> TPtr;
2859 
2860  typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
2861  typedef void (T::*Sent)(bool , const CT&);
2862  typedef void (T::*Response)(const CT&);
2863 
2864  Callback_ServiceManager_stopService(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
2865  : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
2866  {
2867  }
2868 
2870  virtual void completed(const ::Ice::AsyncResultPtr& result) const
2871  {
2872  ServiceManagerPrx proxy = ServiceManagerPrx::uncheckedCast(result->getProxy());
2873  try
2874  {
2875  proxy->end_stopService(result);
2876  }
2877  catch(const ::Ice::Exception& ex)
2878  {
2879  ::IceInternal::Callback<T, CT>::exception(result, ex);
2880  return;
2881  }
2882  if(_response)
2883  {
2884  (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(CT::dynamicCast(result->getCookie()));
2885  }
2886  }
2888 
2889 private:
2890 
2891  Response _response;
2892 };
2893 
2903 template<class T, typename CT> Callback_ServiceManager_stopServicePtr
2904 newCallback_ServiceManager_stopService(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
2905 {
2906  return new Callback_ServiceManager_stopService<T, CT>(instance, cb, excb, sentcb);
2907 }
2908 
2917 template<class T, typename CT> Callback_ServiceManager_stopServicePtr
2918 newCallback_ServiceManager_stopService(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
2919 {
2920  return new Callback_ServiceManager_stopService<T, CT>(instance, 0, excb, sentcb);
2921 }
2922 
2932 template<class T, typename CT> Callback_ServiceManager_stopServicePtr
2933 newCallback_ServiceManager_stopService(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
2934 {
2935  return new Callback_ServiceManager_stopService<T, CT>(instance, cb, excb, sentcb);
2936 }
2937 
2946 template<class T, typename CT> Callback_ServiceManager_stopServicePtr
2947 newCallback_ServiceManager_stopService(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
2948 {
2949  return new Callback_ServiceManager_stopService<T, CT>(instance, 0, excb, sentcb);
2950 }
2951 
2957 template<class T>
2958 class CallbackNC_ServiceManager_addObserver : public Callback_ServiceManager_addObserver_Base, public ::IceInternal::OnewayCallbackNC<T>
2959 {
2960 public:
2961 
2962  typedef IceUtil::Handle<T> TPtr;
2963 
2964  typedef void (T::*Exception)(const ::Ice::Exception&);
2965  typedef void (T::*Sent)(bool);
2966  typedef void (T::*Response)();
2967 
2968  CallbackNC_ServiceManager_addObserver(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
2969  : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
2970  {
2971  }
2972 };
2973 
2982 template<class T> Callback_ServiceManager_addObserverPtr
2983 newCallback_ServiceManager_addObserver(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
2984 {
2985  return new CallbackNC_ServiceManager_addObserver<T>(instance, cb, excb, sentcb);
2986 }
2987 
2995 template<class T> Callback_ServiceManager_addObserverPtr
2996 newCallback_ServiceManager_addObserver(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
2997 {
2998  return new CallbackNC_ServiceManager_addObserver<T>(instance, 0, excb, sentcb);
2999 }
3000 
3009 template<class T> Callback_ServiceManager_addObserverPtr
3010 newCallback_ServiceManager_addObserver(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
3011 {
3012  return new CallbackNC_ServiceManager_addObserver<T>(instance, cb, excb, sentcb);
3013 }
3014 
3022 template<class T> Callback_ServiceManager_addObserverPtr
3023 newCallback_ServiceManager_addObserver(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
3024 {
3025  return new CallbackNC_ServiceManager_addObserver<T>(instance, 0, excb, sentcb);
3026 }
3027 
3033 template<class T, typename CT>
3034 class Callback_ServiceManager_addObserver : public Callback_ServiceManager_addObserver_Base, public ::IceInternal::OnewayCallback<T, CT>
3035 {
3036 public:
3037 
3038  typedef IceUtil::Handle<T> TPtr;
3039 
3040  typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
3041  typedef void (T::*Sent)(bool , const CT&);
3042  typedef void (T::*Response)(const CT&);
3043 
3044  Callback_ServiceManager_addObserver(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
3045  : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
3046  {
3047  }
3048 };
3049 
3059 template<class T, typename CT> Callback_ServiceManager_addObserverPtr
3060 newCallback_ServiceManager_addObserver(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
3061 {
3062  return new Callback_ServiceManager_addObserver<T, CT>(instance, cb, excb, sentcb);
3063 }
3064 
3073 template<class T, typename CT> Callback_ServiceManager_addObserverPtr
3074 newCallback_ServiceManager_addObserver(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
3075 {
3076  return new Callback_ServiceManager_addObserver<T, CT>(instance, 0, excb, sentcb);
3077 }
3078 
3088 template<class T, typename CT> Callback_ServiceManager_addObserverPtr
3089 newCallback_ServiceManager_addObserver(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
3090 {
3091  return new Callback_ServiceManager_addObserver<T, CT>(instance, cb, excb, sentcb);
3092 }
3093 
3102 template<class T, typename CT> Callback_ServiceManager_addObserverPtr
3103 newCallback_ServiceManager_addObserver(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
3104 {
3105  return new Callback_ServiceManager_addObserver<T, CT>(instance, 0, excb, sentcb);
3106 }
3107 
3113 template<class T>
3114 class CallbackNC_ServiceManager_shutdown : public Callback_ServiceManager_shutdown_Base, public ::IceInternal::OnewayCallbackNC<T>
3115 {
3116 public:
3117 
3118  typedef IceUtil::Handle<T> TPtr;
3119 
3120  typedef void (T::*Exception)(const ::Ice::Exception&);
3121  typedef void (T::*Sent)(bool);
3122  typedef void (T::*Response)();
3123 
3124  CallbackNC_ServiceManager_shutdown(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
3125  : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
3126  {
3127  }
3128 };
3129 
3138 template<class T> Callback_ServiceManager_shutdownPtr
3139 newCallback_ServiceManager_shutdown(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
3140 {
3141  return new CallbackNC_ServiceManager_shutdown<T>(instance, cb, excb, sentcb);
3142 }
3143 
3151 template<class T> Callback_ServiceManager_shutdownPtr
3152 newCallback_ServiceManager_shutdown(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
3153 {
3154  return new CallbackNC_ServiceManager_shutdown<T>(instance, 0, excb, sentcb);
3155 }
3156 
3165 template<class T> Callback_ServiceManager_shutdownPtr
3166 newCallback_ServiceManager_shutdown(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
3167 {
3168  return new CallbackNC_ServiceManager_shutdown<T>(instance, cb, excb, sentcb);
3169 }
3170 
3178 template<class T> Callback_ServiceManager_shutdownPtr
3179 newCallback_ServiceManager_shutdown(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
3180 {
3181  return new CallbackNC_ServiceManager_shutdown<T>(instance, 0, excb, sentcb);
3182 }
3183 
3189 template<class T, typename CT>
3190 class Callback_ServiceManager_shutdown : public Callback_ServiceManager_shutdown_Base, public ::IceInternal::OnewayCallback<T, CT>
3191 {
3192 public:
3193 
3194  typedef IceUtil::Handle<T> TPtr;
3195 
3196  typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
3197  typedef void (T::*Sent)(bool , const CT&);
3198  typedef void (T::*Response)(const CT&);
3199 
3200  Callback_ServiceManager_shutdown(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
3201  : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
3202  {
3203  }
3204 };
3205 
3215 template<class T, typename CT> Callback_ServiceManager_shutdownPtr
3216 newCallback_ServiceManager_shutdown(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
3217 {
3218  return new Callback_ServiceManager_shutdown<T, CT>(instance, cb, excb, sentcb);
3219 }
3220 
3229 template<class T, typename CT> Callback_ServiceManager_shutdownPtr
3230 newCallback_ServiceManager_shutdown(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
3231 {
3232  return new Callback_ServiceManager_shutdown<T, CT>(instance, 0, excb, sentcb);
3233 }
3234 
3244 template<class T, typename CT> Callback_ServiceManager_shutdownPtr
3245 newCallback_ServiceManager_shutdown(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
3246 {
3247  return new Callback_ServiceManager_shutdown<T, CT>(instance, cb, excb, sentcb);
3248 }
3249 
3258 template<class T, typename CT> Callback_ServiceManager_shutdownPtr
3259 newCallback_ServiceManager_shutdown(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
3260 {
3261  return new Callback_ServiceManager_shutdown<T, CT>(instance, 0, excb, sentcb);
3262 }
3263 
3264 }
3265 
3266 #endif
3267 
3268 #include <IceUtil/PopDisableWarnings.h>
3269 #endif
IceBox::AlreadyStoppedException::ice_staticId
static const ::std::string & ice_staticId()
Obtains the Slice type ID of this exception.
CommunicatorF.h
IceBox::ServiceObserverPrx::servicesStoppedAsync
auto servicesStoppedAsync(const ::Ice::StringSeq &services, const ::Ice::Context &context=::Ice::noExplicitContext) -> decltype(::std::declval< P< void >>().get_future())
Receives the names of the services that were stopped.
Definition: IceBox.h:523
IceBox::ServiceManager::stopService
virtual void stopService(::std::string service, const ::Ice::Current &current)=0
Stop an individual service.
Ice::LocalObjectPtr
IceInternal::Handle< LocalObject > LocalObjectPtr
Definition: LocalObjectF.h:17
Optional.h
Ice::Context
::std::map<::std::string, ::std::string > Context
A request context.
Definition: Current.h:68
IceBox::ServiceObserver
An Observer interface implemented by admin clients interested in the status of services.
Definition: IceBox.h:290
Ice::InputStream
Interface for input streams used to extract Slice types from a sequence of bytes.
Definition: InputStream.h:50
IceBox::FailureException::FailureException
FailureException(const char *file, int line, const ::std::string &reason)
One-shot constructor to initialize all data members.
Definition: IceBox.h:112
IceBox::NoSuchServiceException::ice_staticId
static const ::std::string & ice_staticId()
Obtains the Slice type ID of this exception.
IceBox::ServiceManagerPrx::addObserverAsync
auto addObserverAsync(const ::std::shared_ptr< ServiceObserverPrx > &observer, const ::Ice::Context &context=::Ice::noExplicitContext) -> decltype(::std::declval< P< void >>().get_future())
Registers a new observer with the ServiceManager.
Definition: IceBox.h:733
IceBox::AlreadyStartedException::ice_staticId
static const ::std::string & ice_staticId()
Obtains the Slice type ID of this exception.
IceBox::FailureException::reason
::std::string reason
The reason for the failure.
Definition: IceBox.h:140
IceBox::FailureException::ice_print
virtual void ice_print(::std::ostream &stream) const override
Prints this exception to the given stream.
Ice::emptyCurrent
const Current emptyCurrent
A default-initialized Current instance.
IceBox::ServiceManager::ice_id
virtual ::std::string ice_id(const ::Ice::Current &current) const override
Obtains a Slice type ID representing the most-derived interface supported by this object.
IceBox::NoSuchServiceException::~NoSuchServiceException
virtual ~NoSuchServiceException()
IceBox::ServiceManagerPrx::getSliceChecksums
::Ice::SliceChecksumDict getSliceChecksums(const ::Ice::Context &context=::Ice::noExplicitContext)
Returns the checksums for the IceBox Slice definitions.
Definition: IceBox.h:582
IceBox::NoSuchServiceException::NoSuchServiceException
NoSuchServiceException(const NoSuchServiceException &)=default
IceBox::NoSuchServiceException::ice_tuple
std::tuple ice_tuple() const
Obtains a tuple containing all of the exception's data members.
Definition: IceBox.h:228
Ice::LocalExceptionHelper
Helper template for the implementation of Ice::LocalException.
Definition: ExceptionHelpers.h:23
StreamHelpers.h
IceBox::ServiceManagerPrx::stopService
void stopService(const ::std::string &service, const ::Ice::Context &context=::Ice::noExplicitContext)
Stop an individual service.
Definition: IceBox.h:675
Config.h
Ice::Object
The base class for servants.
Definition: Object.h:91
Ice::operator==
bool operator==(const C &lhs, const C &rhs)
Relational operator for generated structs and classes.
Definition: Comparable.h:184
IceBox::ServiceObserver::servicesStarted
virtual void servicesStarted(::Ice::StringSeq services, const ::Ice::Current &current)=0
Receives the names of the services that were started.
Ice::Exception
IceUtil::Exception Exception
Definition: Exception.h:20
IceBox::FailureException::~FailureException
virtual ~FailureException()
GCObject.h
IceBox::ServiceManagerPrx::getSliceChecksumsAsync
::std::function< void()> getSliceChecksumsAsync(::std::function< void(::Ice::SliceChecksumDict)> response, ::std::function< void(::std::exception_ptr)> ex=nullptr, ::std::function< void(bool)> sent=nullptr, const ::Ice::Context &context=::Ice::noExplicitContext)
Returns the checksums for the IceBox Slice definitions.
Definition: IceBox.h:608
PropertiesF.h
IceBox::ServiceManager::startService
virtual void startService(::std::string service, const ::Ice::Current &current)=0
Start an individual service.
IceBox::NoSuchServiceException
This exception is thrown if a service name does not refer to an existing service.
Definition: IceBox.h:215
Ice::SliceChecksumDict
::std::map<::std::string, ::std::string > SliceChecksumDict
A mapping from type IDs to Slice checksums.
Definition: SliceChecksumDict.h:63
Incoming.h
IceBox::ServiceManager::ice_isA
virtual bool ice_isA(::std::string id, const ::Ice::Current &current) const override
Determines whether this object supports an interface with the given Slice type ID.
IceBox::FailureException::FailureException
FailureException(const char *file, int line)
The file and line number are required for all local exceptions.
Definition: IceBox.h:101
IceBox::NoSuchServiceException::NoSuchServiceException
NoSuchServiceException()=default
Ice::UserExceptionHelper
Helper template for the implementation of Ice::UserException.
Definition: ExceptionHelpers.h:39
ICE_MEMBER
#define ICE_MEMBER(API)
Definition: Config.h:177
IceBox::ServiceObserver::ice_id
virtual ::std::string ice_id(const ::Ice::Current &current) const override
Obtains a Slice type ID representing the most-derived interface supported by this object.
IceBox::ServiceManager::getSliceChecksums
virtual ::Ice::SliceChecksumDict getSliceChecksums(const ::Ice::Current &current) const =0
Returns the checksums for the IceBox Slice definitions.
IceBox::ServiceManagerPrx::getSliceChecksumsAsync
auto getSliceChecksumsAsync(const ::Ice::Context &context=::Ice::noExplicitContext) -> decltype(::std::declval< P<::Ice::SliceChecksumDict >>().get_future())
Returns the checksums for the IceBox Slice definitions.
Definition: IceBox.h:593
IceBox::ServiceObserverPrx::servicesStarted
void servicesStarted(const ::Ice::StringSeq &services, const ::Ice::Context &context=::Ice::noExplicitContext)
Receives the names of the services that were started.
Definition: IceBox.h:465
IceBox::AlreadyStartedException::ice_tuple
std::tuple ice_tuple() const
Obtains a tuple containing all of the exception's data members.
Definition: IceBox.h:162
FactoryTableInit.h
IceBox::Service
An application service managed by a ServiceManager.
Definition: IceBox.h:250
IceBox::ServiceObserver::ice_isA
virtual bool ice_isA(::std::string id, const ::Ice::Current &current) const override
Determines whether this object supports an interface with the given Slice type ID.
IceBox::ServiceManagerPrx::shutdownAsync
auto shutdownAsync(const ::Ice::Context &context=::Ice::noExplicitContext) -> decltype(::std::declval< P< void >>().get_future())
Shut down all services.
Definition: IceBox.h:777
IceBox::ServiceManagerPrx::startServiceAsync
::std::function< void()> startServiceAsync(const ::std::string &service, ::std::function< void()> response, ::std::function< void(::std::exception_ptr)> ex=nullptr, ::std::function< void(bool)> sent=nullptr, const ::Ice::Context &context=::Ice::noExplicitContext)
Start an individual service.
Definition: IceBox.h:655
IceBox::AlreadyStoppedException::AlreadyStoppedException
AlreadyStoppedException(const AlreadyStoppedException &)=default
IceBox::AlreadyStoppedException
This exception is thrown if an attempt is made to stop an already-stopped service.
Definition: IceBox.h:184
IceBox::ServiceManagerPrx
Administers a set of Service instances.
Definition: IceBox.h:574
LocalObject.h
IceBox::FailureException::ice_tuple
std::tuple< const ::std::string & > ice_tuple() const
Obtains a tuple containing all of the exception's data members.
Definition: IceBox.h:121
PushDisableWarnings.h
IceBox::ServiceManagerPrx::addObserverAsync
::std::function< void()> addObserverAsync(const ::std::shared_ptr< ServiceObserverPrx > &observer, ::std::function< void()> response, ::std::function< void(::std::exception_ptr)> ex=nullptr, ::std::function< void(bool)> sent=nullptr, const ::Ice::Context &context=::Ice::noExplicitContext)
Registers a new observer with the ServiceManager.
Definition: IceBox.h:749
IceBox::ServiceManager::ice_ids
virtual ::std::vector<::std::string > ice_ids(const ::Ice::Current &current) const override
Obtains a list of the Slice type IDs representing the interfaces supported by this object.
IceBox::Service::stop
virtual void stop()=0
Stop the service.
ProxyF.h
IceBox::ServiceManagerPrx::ice_staticId
static const ::std::string & ice_staticId()
Obtains the Slice type ID of this interface.
Ice::operator<
bool operator<(const C &lhs, const C &rhs)
Relational operator for generated structs and classes.
Definition: Comparable.h:136
IceBox::ServiceObserverPrx
An Observer interface implemented by admin clients interested in the status of services.
Definition: IceBox.h:457
IceBox::ServiceManager::shutdown
virtual void shutdown(const ::Ice::Current &current)=0
Shut down all services.
IceBox::AlreadyStartedException
This exception is thrown if an attempt is made to start an already-started service.
Definition: IceBox.h:149
IceBox::ServiceManagerPrx::startServiceAsync
auto startServiceAsync(const ::std::string &service, const ::Ice::Context &context=::Ice::noExplicitContext) -> decltype(::std::declval< P< void >>().get_future())
Start an individual service.
Definition: IceBox.h:639
IceBox::ServiceObserver::ice_ids
virtual ::std::vector<::std::string > ice_ids(const ::Ice::Current &current) const override
Obtains a list of the Slice type IDs representing the interfaces supported by this object.
IceBox::AlreadyStartedException::AlreadyStartedException
AlreadyStartedException(const AlreadyStartedException &)=default
IceBox::ServiceManagerPrx::startService
void startService(const ::std::string &service, const ::Ice::Context &context=::Ice::noExplicitContext)
Start an individual service.
Definition: IceBox.h:627
Object.h
IceBox::ServiceObserver::ice_staticId
static const ::std::string & ice_staticId()
Obtains the Slice type ID corresponding to this class.
IceBox::AlreadyStoppedException::ice_tuple
std::tuple ice_tuple() const
Obtains a tuple containing all of the exception's data members.
Definition: IceBox.h:197
Proxy.h
IceBox::Service::~Service
virtual ~Service()
UndefSysMacros.h
IceBox::FailureException::FailureException
FailureException(const FailureException &)=default
Ice::OutputStream
Interface for output streams used to create a sequence of bytes from Slice types.
Definition: OutputStream.h:28
ObjectF.h
IceBox::ServiceManager::addObserver
virtual void addObserver(::std::shared_ptr< ServiceObserverPrx > observer, const ::Ice::Current &current)=0
Registers a new observer with the ServiceManager.
IceBox::ServiceObserver::servicesStopped
virtual void servicesStopped(::Ice::StringSeq services, const ::Ice::Current &current)=0
Receives the names of the services that were stopped.
Ice::StringSeq
::std::vector<::std::string > StringSeq
A sequence of strings.
Definition: BuiltinSequences.h:96
Ice
Definition: BuiltinSequences.h:56
IceBox::FailureException
This exception is a general failure notification.
Definition: IceBox.h:89
IceBox::ServiceManagerPrx::shutdown
void shutdown(const ::Ice::Context &context=::Ice::noExplicitContext)
Shut down all services.
Definition: IceBox.h:766
IceBox::AlreadyStoppedException::~AlreadyStoppedException
virtual ~AlreadyStoppedException()
IceBox::AlreadyStartedException::~AlreadyStartedException
virtual ~AlreadyStartedException()
IceBox::ServiceObserverPrx::servicesStartedAsync
auto servicesStartedAsync(const ::Ice::StringSeq &services, const ::Ice::Context &context=::Ice::noExplicitContext) -> decltype(::std::declval< P< void >>().get_future())
Receives the names of the services that were started.
Definition: IceBox.h:477
IceBox::ServiceObserverPrx::servicesStopped
void servicesStopped(const ::Ice::StringSeq &services, const ::Ice::Context &context=::Ice::noExplicitContext)
Receives the names of the services that were stopped.
Definition: IceBox.h:511
IceUtil::Handle
Definition: Handle.h:143
ExceptionHelpers.h
IceBox::Service::start
virtual void start(const ::std::string &name, const ::std::shared_ptr<::Ice::Communicator > &communicator, const ::Ice::StringSeq &args)=0
Start the service.
Ice::LocalException
Base class for all Ice run-time exceptions.
Definition: Exception.h:29
IceBox::AlreadyStartedException::AlreadyStartedException
AlreadyStartedException()=default
Ice::uncheckedCast
::std::shared_ptr< P > uncheckedCast(const ::std::shared_ptr< T > &b)
Downcasts a proxy without confirming the target object's type via a remote invocation.
Definition: Proxy.h:1549
ICEBOX_API
#define ICEBOX_API
Definition: IceBox.h:61
Comparable.h
BuiltinSequences.h
IceBox::ServiceManagerPrx::stopServiceAsync
::std::function< void()> stopServiceAsync(const ::std::string &service, ::std::function< void()> response, ::std::function< void(::std::exception_ptr)> ex=nullptr, ::std::function< void(bool)> sent=nullptr, const ::Ice::Context &context=::Ice::noExplicitContext)
Stop an individual service.
Definition: IceBox.h:703
ScopedArray.h
IceBox::ServiceObserverPrx::ice_staticId
static const ::std::string & ice_staticId()
Obtains the Slice type ID of this interface.
IceBox::ServiceManagerPrx::addObserver
void addObserver(const ::std::shared_ptr< ServiceObserverPrx > &observer, const ::Ice::Context &context=::Ice::noExplicitContext)
Registers a new observer with the ServiceManager.
Definition: IceBox.h:721
SliceChecksumDict.h
Ice::Proxy
Helper template that supplies proxy factory functions.
Definition: Proxy.h:1204
IceBox
Definition: IceBox.h:68
IceBox::AlreadyStoppedException::AlreadyStoppedException
AlreadyStoppedException()=default
Exception.h
ValueF.h
IceBox::ServiceObserverPrx::servicesStoppedAsync
::std::function< void()> servicesStoppedAsync(const ::Ice::StringSeq &services, ::std::function< void()> response, ::std::function< void(::std::exception_ptr)> ex=nullptr, ::std::function< void(bool)> sent=nullptr, const ::Ice::Context &context=::Ice::noExplicitContext)
Receives the names of the services that were stopped.
Definition: IceBox.h:539
Ice::noExplicitContext
const Context noExplicitContext
Marker value used to indicate that no explicit context was passed to a proxy invocation.
IceBox::ServiceManagerPrx::shutdownAsync
::std::function< void()> shutdownAsync(::std::function< void()> response, ::std::function< void(::std::exception_ptr)> ex=nullptr, ::std::function< void(bool)> sent=nullptr, const ::Ice::Context &context=::Ice::noExplicitContext)
Shut down all services.
Definition: IceBox.h:792
Value.h
IceBox::ServiceManager::ice_staticId
static const ::std::string & ice_staticId()
Obtains the Slice type ID corresponding to this class.
IceBox::ServiceManagerPrx::stopServiceAsync
auto stopServiceAsync(const ::std::string &service, const ::Ice::Context &context=::Ice::noExplicitContext) -> decltype(::std::declval< P< void >>().get_future())
Stop an individual service.
Definition: IceBox.h:687
IceBox::ServiceManager
Administers a set of Service instances.
Definition: IceBox.h:354
Ice::UserException
Base class for all Ice user exceptions.
Definition: Exception.h:68
IceBox::ServiceObserverPrx::servicesStartedAsync
::std::function< void()> servicesStartedAsync(const ::Ice::StringSeq &services, ::std::function< void()> response, ::std::function< void(::std::exception_ptr)> ex=nullptr, ::std::function< void(bool)> sent=nullptr, const ::Ice::Context &context=::Ice::noExplicitContext)
Receives the names of the services that were started.
Definition: IceBox.h:493
PopDisableWarnings.h
IceBox::FailureException::ice_staticId
static const ::std::string & ice_staticId()
Obtains the Slice type ID of this exception.
Generated by doxygen 1.8.20