Ice 3.7 C++11 API Reference
RemoteLogger.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 `RemoteLogger.ice'
10 //
11 // Warning: do not edit this file.
12 //
13 // </auto-generated>
14 //
15 
16 #ifndef __Ice_RemoteLogger_h__
17 #define __Ice_RemoteLogger_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 <IceUtil/UndefSysMacros.h>
38 #include <list>
39 
40 #ifndef ICE_IGNORE_VERSION
41 # if ICE_INT_VERSION / 100 != 307
42 # error Ice version mismatch!
43 # endif
44 # if ICE_INT_VERSION % 100 >= 50
45 # error Beta header file detected
46 # endif
47 # if ICE_INT_VERSION % 100 < 10
48 # error Ice patch level mismatch!
49 # endif
50 #endif
51 
52 #ifndef ICE_API
53 # if defined(ICE_STATIC_LIBS)
54 # define ICE_API
55 # elif defined(ICE_API_EXPORTS)
56 # define ICE_API ICE_DECLSPEC_EXPORT
57 # else
58 # define ICE_API ICE_DECLSPEC_IMPORT
59 # endif
60 #endif
61 
62 #ifdef ICE_CPP11_MAPPING // C++11 mapping
63 
64 namespace Ice
65 {
66 
67 class RemoteLogger;
68 class RemoteLoggerPrx;
69 class LoggerAdmin;
70 class LoggerAdminPrx;
71 
72 }
73 
74 namespace Ice
75 {
76 
80 enum class LogMessageType : unsigned char
81 {
85  PrintMessage,
89  TraceMessage,
93  WarningMessage,
97  ErrorMessage
98 };
99 
103 using LogMessageTypeSeq = ::std::vector<LogMessageType>;
104 
109 struct LogMessage
110 {
114  ::Ice::LogMessageType type;
119  long long int timestamp;
124  ::std::string traceCategory;
128  ::std::string message;
129 
134  std::tuple<const ::Ice::LogMessageType&, const long long int&, const ::std::string&, const ::std::string&> ice_tuple() const
135  {
136  return std::tie(type, timestamp, traceCategory, message);
137  }
138 };
139 
143 using LogMessageSeq = std::list<LogMessage>;
144 
149 class ICE_CLASS(ICE_API) RemoteLoggerAlreadyAttachedException : public UserExceptionHelper<RemoteLoggerAlreadyAttachedException, UserException>
150 {
151 public:
152 
153  ICE_MEMBER(ICE_API) virtual ~RemoteLoggerAlreadyAttachedException();
154 
155  RemoteLoggerAlreadyAttachedException(const RemoteLoggerAlreadyAttachedException&) = default;
156 
157  RemoteLoggerAlreadyAttachedException() = default;
158 
163  std::tuple<> ice_tuple() const
164  {
165  return std::tie();
166  }
167 
172  ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
173 };
174 
176 static RemoteLoggerAlreadyAttachedException _iceS_RemoteLoggerAlreadyAttachedException_init;
178 
179 using Ice::operator<;
180 using Ice::operator<=;
181 using Ice::operator>;
182 using Ice::operator>=;
183 using Ice::operator==;
184 using Ice::operator!=;
185 
186 }
187 
188 namespace Ice
189 {
190 
197 class ICE_API RemoteLogger : public virtual Object
198 {
199 public:
200 
201  using ProxyType = RemoteLoggerPrx;
202 
209  virtual bool ice_isA(::std::string id, const Current& current) const override;
210 
216  virtual ::std::vector<::std::string> ice_ids(const Current& current) const override;
217 
223  virtual ::std::string ice_id(const Current& current) const override;
224 
229  static const ::std::string& ice_staticId();
230 
237  virtual void init(::std::string prefix, LogMessageSeq logMessages, const Current& current) = 0;
239  bool _iceD_init(::IceInternal::Incoming&, const Current&);
241 
247  virtual void log(LogMessage message, const Current& current) = 0;
249  bool _iceD_log(::IceInternal::Incoming&, const Current&);
251 
253  virtual bool _iceDispatch(::IceInternal::Incoming&, const Current&) override;
255 };
256 
262 class ICE_API LoggerAdmin : public virtual Object
263 {
264 public:
265 
266  using ProxyType = LoggerAdminPrx;
267 
274  virtual bool ice_isA(::std::string id, const Current& current) const override;
275 
281  virtual ::std::vector<::std::string> ice_ids(const Current& current) const override;
282 
288  virtual ::std::string ice_id(const Current& current) const override;
289 
294  static const ::std::string& ice_staticId();
295 
311  virtual void attachRemoteLogger(::std::shared_ptr<RemoteLoggerPrx> prx, LogMessageTypeSeq messageTypes, StringSeq traceCategories, int messageMax, const Current& current) = 0;
313  bool _iceD_attachRemoteLogger(::IceInternal::Incoming&, const Current&);
315 
322  virtual bool detachRemoteLogger(::std::shared_ptr<RemoteLoggerPrx> prx, const Current& current) = 0;
324  bool _iceD_detachRemoteLogger(::IceInternal::Incoming&, const Current&);
326 
330  struct GetLogResult
331  {
333  LogMessageSeq returnValue;
335  ::std::string prefix;
336  };
337 
351  virtual LogMessageSeq getLog(LogMessageTypeSeq messageTypes, StringSeq traceCategories, int messageMax, ::std::string& prefix, const Current& current) = 0;
353  bool _iceD_getLog(::IceInternal::Incoming&, const Current&);
355 
357  virtual bool _iceDispatch(::IceInternal::Incoming&, const Current&) override;
359 };
360 
361 }
362 
363 namespace Ice
364 {
365 
372 class ICE_CLASS(ICE_API) RemoteLoggerPrx : public virtual Proxy<RemoteLoggerPrx, ObjectPrx>
373 {
374 public:
375 
382  void init(const ::std::string& prefix, const LogMessageSeq& logMessages, const Context& context = noExplicitContext)
383  {
384  _makePromiseOutgoing<void>(true, this, &RemoteLoggerPrx::_iceI_init, prefix, logMessages, context).get();
385  }
386 
394  template<template<typename> class P = ::std::promise>
395  auto initAsync(const ::std::string& prefix, const LogMessageSeq& logMessages, const Context& context = noExplicitContext)
396  -> decltype(::std::declval<P<void>>().get_future())
397  {
398  return _makePromiseOutgoing<void, P>(false, this, &RemoteLoggerPrx::_iceI_init, prefix, logMessages, context);
399  }
400 
411  ::std::function<void()>
412  initAsync(const ::std::string& prefix, const LogMessageSeq& logMessages,
413  ::std::function<void()> response,
414  ::std::function<void(::std::exception_ptr)> ex = nullptr,
415  ::std::function<void(bool)> sent = nullptr,
416  const Context& context = noExplicitContext)
417  {
418  return _makeLamdaOutgoing<void>(std::move(response), std::move(ex), std::move(sent), this, &Ice::RemoteLoggerPrx::_iceI_init, prefix, logMessages, context);
419  }
420 
422  ICE_MEMBER(ICE_API) void _iceI_init(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&, const ::std::string&, const LogMessageSeq&, const Context&);
424 
430  void log(const LogMessage& message, const Context& context = noExplicitContext)
431  {
432  _makePromiseOutgoing<void>(true, this, &RemoteLoggerPrx::_iceI_log, message, context).get();
433  }
434 
441  template<template<typename> class P = ::std::promise>
442  auto logAsync(const LogMessage& message, const Context& context = noExplicitContext)
443  -> decltype(::std::declval<P<void>>().get_future())
444  {
445  return _makePromiseOutgoing<void, P>(false, this, &RemoteLoggerPrx::_iceI_log, message, context);
446  }
447 
457  ::std::function<void()>
458  logAsync(const LogMessage& message,
459  ::std::function<void()> response,
460  ::std::function<void(::std::exception_ptr)> ex = nullptr,
461  ::std::function<void(bool)> sent = nullptr,
462  const Context& context = noExplicitContext)
463  {
464  return _makeLamdaOutgoing<void>(std::move(response), std::move(ex), std::move(sent), this, &Ice::RemoteLoggerPrx::_iceI_log, message, context);
465  }
466 
468  ICE_MEMBER(ICE_API) void _iceI_log(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&, const LogMessage&, const Context&);
470 
475  ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
476 
477 protected:
478 
480  RemoteLoggerPrx() = default;
481  friend ::std::shared_ptr<RemoteLoggerPrx> IceInternal::createProxy<RemoteLoggerPrx>();
482 
483  ICE_MEMBER(ICE_API) virtual ::std::shared_ptr<ObjectPrx> _newInstance() const override;
485 };
486 
492 class ICE_CLASS(ICE_API) LoggerAdminPrx : public virtual Proxy<LoggerAdminPrx, ObjectPrx>
493 {
494 public:
495 
511  void attachRemoteLogger(const ::std::shared_ptr<RemoteLoggerPrx>& prx, const LogMessageTypeSeq& messageTypes, const StringSeq& traceCategories, int messageMax, const Context& context = noExplicitContext)
512  {
513  _makePromiseOutgoing<void>(true, this, &LoggerAdminPrx::_iceI_attachRemoteLogger, prx, messageTypes, traceCategories, messageMax, context).get();
514  }
515 
530  template<template<typename> class P = ::std::promise>
531  auto attachRemoteLoggerAsync(const ::std::shared_ptr<RemoteLoggerPrx>& prx, const LogMessageTypeSeq& messageTypes, const StringSeq& traceCategories, int messageMax, const Context& context = noExplicitContext)
532  -> decltype(::std::declval<P<void>>().get_future())
533  {
534  return _makePromiseOutgoing<void, P>(false, this, &LoggerAdminPrx::_iceI_attachRemoteLogger, prx, messageTypes, traceCategories, messageMax, context);
535  }
536 
554  ::std::function<void()>
555  attachRemoteLoggerAsync(const ::std::shared_ptr<RemoteLoggerPrx>& prx, const LogMessageTypeSeq& messageTypes, const StringSeq& traceCategories, int messageMax,
556  ::std::function<void()> response,
557  ::std::function<void(::std::exception_ptr)> ex = nullptr,
558  ::std::function<void(bool)> sent = nullptr,
559  const Context& context = noExplicitContext)
560  {
561  return _makeLamdaOutgoing<void>(std::move(response), std::move(ex), std::move(sent), this, &Ice::LoggerAdminPrx::_iceI_attachRemoteLogger, prx, messageTypes, traceCategories, messageMax, context);
562  }
563 
565  ICE_MEMBER(ICE_API) void _iceI_attachRemoteLogger(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&, const ::std::shared_ptr<RemoteLoggerPrx>&, const LogMessageTypeSeq&, const StringSeq&, int, const Context&);
567 
574  bool detachRemoteLogger(const ::std::shared_ptr<RemoteLoggerPrx>& prx, const Context& context = noExplicitContext)
575  {
576  return _makePromiseOutgoing<bool>(true, this, &LoggerAdminPrx::_iceI_detachRemoteLogger, prx, context).get();
577  }
578 
585  template<template<typename> class P = ::std::promise>
586  auto detachRemoteLoggerAsync(const ::std::shared_ptr<RemoteLoggerPrx>& prx, const Context& context = noExplicitContext)
587  -> decltype(::std::declval<P<bool>>().get_future())
588  {
589  return _makePromiseOutgoing<bool, P>(false, this, &LoggerAdminPrx::_iceI_detachRemoteLogger, prx, context);
590  }
591 
601  ::std::function<void()>
602  detachRemoteLoggerAsync(const ::std::shared_ptr<RemoteLoggerPrx>& prx,
603  ::std::function<void(bool)> response,
604  ::std::function<void(::std::exception_ptr)> ex = nullptr,
605  ::std::function<void(bool)> sent = nullptr,
606  const Context& context = noExplicitContext)
607  {
608  return _makeLamdaOutgoing<bool>(std::move(response), std::move(ex), std::move(sent), this, &Ice::LoggerAdminPrx::_iceI_detachRemoteLogger, prx, context);
609  }
610 
612  ICE_MEMBER(ICE_API) void _iceI_detachRemoteLogger(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<bool>>&, const ::std::shared_ptr<RemoteLoggerPrx>&, const Context&);
614 
628  LogMessageSeq getLog(const LogMessageTypeSeq& messageTypes, const StringSeq& traceCategories, int messageMax, ::std::string& prefix, const Context& context = noExplicitContext)
629  {
630  auto _result = _makePromiseOutgoing<LoggerAdmin::GetLogResult>(true, this, &LoggerAdminPrx::_iceI_getLog, messageTypes, traceCategories, messageMax, context).get();
631  prefix = ::std::move(_result.prefix);
632  return ::std::move(_result.returnValue);
633  }
634 
647  template<template<typename> class P = ::std::promise>
648  auto getLogAsync(const LogMessageTypeSeq& messageTypes, const StringSeq& traceCategories, int messageMax, const Context& context = noExplicitContext)
649  -> decltype(::std::declval<P<LoggerAdmin::GetLogResult>>().get_future())
650  {
651  return _makePromiseOutgoing<LoggerAdmin::GetLogResult, P>(false, this, &LoggerAdminPrx::_iceI_getLog, messageTypes, traceCategories, messageMax, context);
652  }
653 
669  ::std::function<void()>
670  getLogAsync(const LogMessageTypeSeq& messageTypes, const StringSeq& traceCategories, int messageMax,
671  ::std::function<void(::Ice::LogMessageSeq, ::std::string)> response,
672  ::std::function<void(::std::exception_ptr)> ex = nullptr,
673  ::std::function<void(bool)> sent = nullptr,
674  const Context& context = noExplicitContext)
675  {
676  auto _responseCb = [response](LoggerAdmin::GetLogResult&& _result)
677  {
678  response(::std::move(_result.returnValue), ::std::move(_result.prefix));
679  };
680  return _makeLamdaOutgoing<LoggerAdmin::GetLogResult>(std::move(_responseCb), std::move(ex), std::move(sent), this, &Ice::LoggerAdminPrx::_iceI_getLog, messageTypes, traceCategories, messageMax, context);
681  }
682 
684  ICE_MEMBER(ICE_API) void _iceI_getLog(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<LoggerAdmin::GetLogResult>>&, const LogMessageTypeSeq&, const StringSeq&, int, const Context&);
686 
691  ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
692 
693 protected:
694 
696  LoggerAdminPrx() = default;
697  friend ::std::shared_ptr<LoggerAdminPrx> IceInternal::createProxy<LoggerAdminPrx>();
698 
699  ICE_MEMBER(ICE_API) virtual ::std::shared_ptr<ObjectPrx> _newInstance() const override;
701 };
702 
703 }
704 
706 namespace Ice
707 {
708 
709 template<>
710 struct StreamableTraits< ::Ice::LogMessageType>
711 {
712  static const StreamHelperCategory helper = StreamHelperCategoryEnum;
713  static const int minValue = 0;
714  static const int maxValue = 3;
715  static const int minWireSize = 1;
716  static const bool fixedLength = false;
717 };
718 
719 template<>
720 struct StreamableTraits<::Ice::LogMessage>
721 {
722  static const StreamHelperCategory helper = StreamHelperCategoryStruct;
723  static const int minWireSize = 11;
724  static const bool fixedLength = false;
725 };
726 
727 template<typename S>
728 struct StreamReader<::Ice::LogMessage, S>
729 {
730  static void read(S* istr, ::Ice::LogMessage& v)
731  {
732  istr->readAll(v.type, v.timestamp, v.traceCategory, v.message);
733  }
734 };
735 
736 }
738 
740 namespace Ice
741 {
742 
743 using RemoteLoggerPtr = ::std::shared_ptr<RemoteLogger>;
744 using RemoteLoggerPrxPtr = ::std::shared_ptr<RemoteLoggerPrx>;
745 
746 using LoggerAdminPtr = ::std::shared_ptr<LoggerAdmin>;
747 using LoggerAdminPrxPtr = ::std::shared_ptr<LoggerAdminPrx>;
748 
749 }
751 
752 #else // C++98 mapping
753 
754 namespace IceProxy
755 {
756 
757 namespace Ice
758 {
759 
760 class RemoteLogger;
762 ICE_API void _readProxy(::Ice::InputStream*, ::IceInternal::ProxyHandle< RemoteLogger>&);
763 ICE_API ::IceProxy::Ice::Object* upCast(RemoteLogger*);
765 
766 class LoggerAdmin;
768 ICE_API void _readProxy(::Ice::InputStream*, ::IceInternal::ProxyHandle< LoggerAdmin>&);
769 ICE_API ::IceProxy::Ice::Object* upCast(LoggerAdmin*);
771 
772 }
773 
774 }
775 
776 namespace Ice
777 {
778 
779 class RemoteLogger;
781 ICE_API Object* upCast(RemoteLogger*);
783 typedef ::IceInternal::Handle< RemoteLogger> RemoteLoggerPtr;
784 typedef ::IceInternal::ProxyHandle< ::IceProxy::Ice::RemoteLogger> RemoteLoggerPrx;
785 typedef RemoteLoggerPrx RemoteLoggerPrxPtr;
787 ICE_API void _icePatchObjectPtr(RemoteLoggerPtr&, const ObjectPtr&);
789 
790 class LoggerAdmin;
792 ICE_API Object* upCast(LoggerAdmin*);
794 typedef ::IceInternal::Handle< LoggerAdmin> LoggerAdminPtr;
795 typedef ::IceInternal::ProxyHandle< ::IceProxy::Ice::LoggerAdmin> LoggerAdminPrx;
796 typedef LoggerAdminPrx LoggerAdminPrxPtr;
798 ICE_API void _icePatchObjectPtr(LoggerAdminPtr&, const ObjectPtr&);
800 
801 }
802 
803 namespace Ice
804 {
805 
809 enum LogMessageType
810 {
814  PrintMessage,
818  TraceMessage,
822  WarningMessage,
826  ErrorMessage
827 };
828 
832 typedef ::std::vector<LogMessageType> LogMessageTypeSeq;
833 
838 struct LogMessage
839 {
843  ::Ice::LogMessageType type;
848  ::Ice::Long timestamp;
853  ::std::string traceCategory;
857  ::std::string message;
858 
859  bool operator==(const LogMessage& rhs_) const
860  {
861  if(this == &rhs_)
862  {
863  return true;
864  }
865  if(type != rhs_.type)
866  {
867  return false;
868  }
869  if(timestamp != rhs_.timestamp)
870  {
871  return false;
872  }
873  if(traceCategory != rhs_.traceCategory)
874  {
875  return false;
876  }
877  if(message != rhs_.message)
878  {
879  return false;
880  }
881  return true;
882  }
883 
884  bool operator<(const LogMessage& rhs_) const
885  {
886  if(this == &rhs_)
887  {
888  return false;
889  }
890  if(type < rhs_.type)
891  {
892  return true;
893  }
894  else if(rhs_.type < type)
895  {
896  return false;
897  }
898  if(timestamp < rhs_.timestamp)
899  {
900  return true;
901  }
902  else if(rhs_.timestamp < timestamp)
903  {
904  return false;
905  }
906  if(traceCategory < rhs_.traceCategory)
907  {
908  return true;
909  }
910  else if(rhs_.traceCategory < traceCategory)
911  {
912  return false;
913  }
914  if(message < rhs_.message)
915  {
916  return true;
917  }
918  else if(rhs_.message < message)
919  {
920  return false;
921  }
922  return false;
923  }
924 
925  bool operator!=(const LogMessage& rhs_) const
926  {
927  return !operator==(rhs_);
928  }
929  bool operator<=(const LogMessage& rhs_) const
930  {
931  return operator<(rhs_) || operator==(rhs_);
932  }
933  bool operator>(const LogMessage& rhs_) const
934  {
935  return !operator<(rhs_) && !operator==(rhs_);
936  }
937  bool operator>=(const LogMessage& rhs_) const
938  {
939  return !operator<(rhs_);
940  }
941 };
942 
946 typedef std::list<LogMessage> LogMessageSeq;
947 
952 class ICE_API RemoteLoggerAlreadyAttachedException : public UserException
953 {
954 public:
955 
956  RemoteLoggerAlreadyAttachedException() {}
957 
958 #ifdef ICE_CPP11_COMPILER
959  RemoteLoggerAlreadyAttachedException(const RemoteLoggerAlreadyAttachedException&) = default;
960  virtual ~RemoteLoggerAlreadyAttachedException();
961 #else
962  virtual ~RemoteLoggerAlreadyAttachedException() throw();
963 #endif
964 
969  virtual ::std::string ice_id() const;
974  virtual RemoteLoggerAlreadyAttachedException* ice_clone() const;
978  virtual void ice_throw() const;
979 
980 protected:
981 
983  virtual void _writeImpl(OutputStream*) const;
984  virtual void _readImpl(InputStream*);
986 };
987 
989 static RemoteLoggerAlreadyAttachedException _iceS_RemoteLoggerAlreadyAttachedException_init;
991 
992 }
993 
994 namespace Ice
995 {
996 
1002 class Callback_RemoteLogger_init_Base : public virtual ::IceInternal::CallbackBase { };
1003 typedef ::IceUtil::Handle< Callback_RemoteLogger_init_Base> Callback_RemoteLogger_initPtr;
1004 
1010 class Callback_RemoteLogger_log_Base : public virtual ::IceInternal::CallbackBase { };
1011 typedef ::IceUtil::Handle< Callback_RemoteLogger_log_Base> Callback_RemoteLogger_logPtr;
1012 
1018 class Callback_LoggerAdmin_attachRemoteLogger_Base : public virtual ::IceInternal::CallbackBase { };
1019 typedef ::IceUtil::Handle< Callback_LoggerAdmin_attachRemoteLogger_Base> Callback_LoggerAdmin_attachRemoteLoggerPtr;
1020 
1026 class Callback_LoggerAdmin_detachRemoteLogger_Base : public virtual ::IceInternal::CallbackBase { };
1027 typedef ::IceUtil::Handle< Callback_LoggerAdmin_detachRemoteLogger_Base> Callback_LoggerAdmin_detachRemoteLoggerPtr;
1028 
1034 class Callback_LoggerAdmin_getLog_Base : public virtual ::IceInternal::CallbackBase { };
1035 typedef ::IceUtil::Handle< Callback_LoggerAdmin_getLog_Base> Callback_LoggerAdmin_getLogPtr;
1036 
1037 }
1038 
1039 namespace IceProxy
1040 {
1041 
1042 namespace Ice
1043 {
1044 
1045 class ICE_CLASS(ICE_API) RemoteLogger : public virtual ::Ice::Proxy<RemoteLogger, ::IceProxy::Ice::Object>
1046 {
1047 public:
1048 
1055  ICE_MEMBER(ICE_API) void init(const ::std::string& prefix, const ::Ice::LogMessageSeq& logMessages, const ::Ice::Context& context = ::Ice::noExplicitContext)
1056  {
1057  end_init(_iceI_begin_init(prefix, logMessages, context, ::IceInternal::dummyCallback, 0, true));
1058  }
1059 
1067  ::Ice::AsyncResultPtr begin_init(const ::std::string& prefix, const ::Ice::LogMessageSeq& logMessages, const ::Ice::Context& context = ::Ice::noExplicitContext)
1068  {
1069  return _iceI_begin_init(prefix, logMessages, context, ::IceInternal::dummyCallback, 0);
1070  }
1071 
1080  ::Ice::AsyncResultPtr begin_init(const ::std::string& prefix, const ::Ice::LogMessageSeq& logMessages, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1081  {
1082  return _iceI_begin_init(prefix, logMessages, ::Ice::noExplicitContext, cb, cookie);
1083  }
1084 
1094  ::Ice::AsyncResultPtr begin_init(const ::std::string& prefix, const ::Ice::LogMessageSeq& logMessages, const ::Ice::Context& context, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1095  {
1096  return _iceI_begin_init(prefix, logMessages, context, cb, cookie);
1097  }
1098 
1107  ::Ice::AsyncResultPtr begin_init(const ::std::string& prefix, const ::Ice::LogMessageSeq& logMessages, const ::Ice::Callback_RemoteLogger_initPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1108  {
1109  return _iceI_begin_init(prefix, logMessages, ::Ice::noExplicitContext, cb, cookie);
1110  }
1111 
1121  ::Ice::AsyncResultPtr begin_init(const ::std::string& prefix, const ::Ice::LogMessageSeq& logMessages, const ::Ice::Context& context, const ::Ice::Callback_RemoteLogger_initPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1122  {
1123  return _iceI_begin_init(prefix, logMessages, context, cb, cookie);
1124  }
1125 
1130  ICE_MEMBER(ICE_API) void end_init(const ::Ice::AsyncResultPtr& result);
1131 
1132 private:
1133 
1134  ICE_MEMBER(ICE_API) ::Ice::AsyncResultPtr _iceI_begin_init(const ::std::string&, const ::Ice::LogMessageSeq&, const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
1135 
1136 public:
1137 
1143  ICE_MEMBER(ICE_API) void log(const ::Ice::LogMessage& message, const ::Ice::Context& context = ::Ice::noExplicitContext)
1144  {
1145  end_log(_iceI_begin_log(message, context, ::IceInternal::dummyCallback, 0, true));
1146  }
1147 
1154  ::Ice::AsyncResultPtr begin_log(const ::Ice::LogMessage& message, const ::Ice::Context& context = ::Ice::noExplicitContext)
1155  {
1156  return _iceI_begin_log(message, context, ::IceInternal::dummyCallback, 0);
1157  }
1158 
1166  ::Ice::AsyncResultPtr begin_log(const ::Ice::LogMessage& message, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1167  {
1168  return _iceI_begin_log(message, ::Ice::noExplicitContext, cb, cookie);
1169  }
1170 
1179  ::Ice::AsyncResultPtr begin_log(const ::Ice::LogMessage& message, const ::Ice::Context& context, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1180  {
1181  return _iceI_begin_log(message, context, cb, cookie);
1182  }
1183 
1191  ::Ice::AsyncResultPtr begin_log(const ::Ice::LogMessage& message, const ::Ice::Callback_RemoteLogger_logPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1192  {
1193  return _iceI_begin_log(message, ::Ice::noExplicitContext, cb, cookie);
1194  }
1195 
1204  ::Ice::AsyncResultPtr begin_log(const ::Ice::LogMessage& message, const ::Ice::Context& context, const ::Ice::Callback_RemoteLogger_logPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1205  {
1206  return _iceI_begin_log(message, context, cb, cookie);
1207  }
1208 
1213  ICE_MEMBER(ICE_API) void end_log(const ::Ice::AsyncResultPtr& result);
1214 
1215 private:
1216 
1217  ICE_MEMBER(ICE_API) ::Ice::AsyncResultPtr _iceI_begin_log(const ::Ice::LogMessage&, const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
1218 
1219 public:
1220 
1225  ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
1226 
1227 protected:
1229 
1230  ICE_MEMBER(ICE_API) virtual ::IceProxy::Ice::Object* _newInstance() const;
1232 };
1233 
1234 class ICE_CLASS(ICE_API) LoggerAdmin : public virtual ::Ice::Proxy<LoggerAdmin, ::IceProxy::Ice::Object>
1235 {
1236 public:
1237 
1253  ICE_MEMBER(ICE_API) void attachRemoteLogger(const ::Ice::RemoteLoggerPrx& prx, const ::Ice::LogMessageTypeSeq& messageTypes, const ::Ice::StringSeq& traceCategories, ::Ice::Int messageMax, const ::Ice::Context& context = ::Ice::noExplicitContext)
1254  {
1255  end_attachRemoteLogger(_iceI_begin_attachRemoteLogger(prx, messageTypes, traceCategories, messageMax, context, ::IceInternal::dummyCallback, 0, true));
1256  }
1257 
1272  ::Ice::AsyncResultPtr begin_attachRemoteLogger(const ::Ice::RemoteLoggerPrx& prx, const ::Ice::LogMessageTypeSeq& messageTypes, const ::Ice::StringSeq& traceCategories, ::Ice::Int messageMax, const ::Ice::Context& context = ::Ice::noExplicitContext)
1273  {
1274  return _iceI_begin_attachRemoteLogger(prx, messageTypes, traceCategories, messageMax, context, ::IceInternal::dummyCallback, 0);
1275  }
1276 
1292  ::Ice::AsyncResultPtr begin_attachRemoteLogger(const ::Ice::RemoteLoggerPrx& prx, const ::Ice::LogMessageTypeSeq& messageTypes, const ::Ice::StringSeq& traceCategories, ::Ice::Int messageMax, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1293  {
1294  return _iceI_begin_attachRemoteLogger(prx, messageTypes, traceCategories, messageMax, ::Ice::noExplicitContext, cb, cookie);
1295  }
1296 
1313  ::Ice::AsyncResultPtr begin_attachRemoteLogger(const ::Ice::RemoteLoggerPrx& prx, const ::Ice::LogMessageTypeSeq& messageTypes, const ::Ice::StringSeq& traceCategories, ::Ice::Int messageMax, const ::Ice::Context& context, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1314  {
1315  return _iceI_begin_attachRemoteLogger(prx, messageTypes, traceCategories, messageMax, context, cb, cookie);
1316  }
1317 
1333  ::Ice::AsyncResultPtr begin_attachRemoteLogger(const ::Ice::RemoteLoggerPrx& prx, const ::Ice::LogMessageTypeSeq& messageTypes, const ::Ice::StringSeq& traceCategories, ::Ice::Int messageMax, const ::Ice::Callback_LoggerAdmin_attachRemoteLoggerPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1334  {
1335  return _iceI_begin_attachRemoteLogger(prx, messageTypes, traceCategories, messageMax, ::Ice::noExplicitContext, cb, cookie);
1336  }
1337 
1354  ::Ice::AsyncResultPtr begin_attachRemoteLogger(const ::Ice::RemoteLoggerPrx& prx, const ::Ice::LogMessageTypeSeq& messageTypes, const ::Ice::StringSeq& traceCategories, ::Ice::Int messageMax, const ::Ice::Context& context, const ::Ice::Callback_LoggerAdmin_attachRemoteLoggerPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1355  {
1356  return _iceI_begin_attachRemoteLogger(prx, messageTypes, traceCategories, messageMax, context, cb, cookie);
1357  }
1358 
1365  ICE_MEMBER(ICE_API) void end_attachRemoteLogger(const ::Ice::AsyncResultPtr& result);
1366 
1367 private:
1368 
1369  ICE_MEMBER(ICE_API) ::Ice::AsyncResultPtr _iceI_begin_attachRemoteLogger(const ::Ice::RemoteLoggerPrx&, const ::Ice::LogMessageTypeSeq&, const ::Ice::StringSeq&, ::Ice::Int, const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
1370 
1371 public:
1372 
1379  ICE_MEMBER(ICE_API) bool detachRemoteLogger(const ::Ice::RemoteLoggerPrx& prx, const ::Ice::Context& context = ::Ice::noExplicitContext)
1380  {
1381  return end_detachRemoteLogger(_iceI_begin_detachRemoteLogger(prx, context, ::IceInternal::dummyCallback, 0, true));
1382  }
1383 
1390  ::Ice::AsyncResultPtr begin_detachRemoteLogger(const ::Ice::RemoteLoggerPrx& prx, const ::Ice::Context& context = ::Ice::noExplicitContext)
1391  {
1392  return _iceI_begin_detachRemoteLogger(prx, context, ::IceInternal::dummyCallback, 0);
1393  }
1394 
1402  ::Ice::AsyncResultPtr begin_detachRemoteLogger(const ::Ice::RemoteLoggerPrx& prx, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1403  {
1404  return _iceI_begin_detachRemoteLogger(prx, ::Ice::noExplicitContext, cb, cookie);
1405  }
1406 
1415  ::Ice::AsyncResultPtr begin_detachRemoteLogger(const ::Ice::RemoteLoggerPrx& prx, const ::Ice::Context& context, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1416  {
1417  return _iceI_begin_detachRemoteLogger(prx, context, cb, cookie);
1418  }
1419 
1427  ::Ice::AsyncResultPtr begin_detachRemoteLogger(const ::Ice::RemoteLoggerPrx& prx, const ::Ice::Callback_LoggerAdmin_detachRemoteLoggerPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1428  {
1429  return _iceI_begin_detachRemoteLogger(prx, ::Ice::noExplicitContext, cb, cookie);
1430  }
1431 
1440  ::Ice::AsyncResultPtr begin_detachRemoteLogger(const ::Ice::RemoteLoggerPrx& prx, const ::Ice::Context& context, const ::Ice::Callback_LoggerAdmin_detachRemoteLoggerPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1441  {
1442  return _iceI_begin_detachRemoteLogger(prx, context, cb, cookie);
1443  }
1444 
1450  ICE_MEMBER(ICE_API) bool end_detachRemoteLogger(const ::Ice::AsyncResultPtr& result);
1451 
1452 private:
1453 
1454  ICE_MEMBER(ICE_API) ::Ice::AsyncResultPtr _iceI_begin_detachRemoteLogger(const ::Ice::RemoteLoggerPrx&, const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
1455 
1456 public:
1457 
1471  ICE_MEMBER(ICE_API) ::Ice::LogMessageSeq getLog(const ::Ice::LogMessageTypeSeq& messageTypes, const ::Ice::StringSeq& traceCategories, ::Ice::Int messageMax, ::std::string& prefix, const ::Ice::Context& context = ::Ice::noExplicitContext)
1472  {
1473  return end_getLog(prefix, _iceI_begin_getLog(messageTypes, traceCategories, messageMax, context, ::IceInternal::dummyCallback, 0, true));
1474  }
1475 
1488  ::Ice::AsyncResultPtr begin_getLog(const ::Ice::LogMessageTypeSeq& messageTypes, const ::Ice::StringSeq& traceCategories, ::Ice::Int messageMax, const ::Ice::Context& context = ::Ice::noExplicitContext)
1489  {
1490  return _iceI_begin_getLog(messageTypes, traceCategories, messageMax, context, ::IceInternal::dummyCallback, 0);
1491  }
1492 
1506  ::Ice::AsyncResultPtr begin_getLog(const ::Ice::LogMessageTypeSeq& messageTypes, const ::Ice::StringSeq& traceCategories, ::Ice::Int messageMax, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1507  {
1508  return _iceI_begin_getLog(messageTypes, traceCategories, messageMax, ::Ice::noExplicitContext, cb, cookie);
1509  }
1510 
1525  ::Ice::AsyncResultPtr begin_getLog(const ::Ice::LogMessageTypeSeq& messageTypes, const ::Ice::StringSeq& traceCategories, ::Ice::Int messageMax, const ::Ice::Context& context, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1526  {
1527  return _iceI_begin_getLog(messageTypes, traceCategories, messageMax, context, cb, cookie);
1528  }
1529 
1543  ::Ice::AsyncResultPtr begin_getLog(const ::Ice::LogMessageTypeSeq& messageTypes, const ::Ice::StringSeq& traceCategories, ::Ice::Int messageMax, const ::Ice::Callback_LoggerAdmin_getLogPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1544  {
1545  return _iceI_begin_getLog(messageTypes, traceCategories, messageMax, ::Ice::noExplicitContext, cb, cookie);
1546  }
1547 
1562  ::Ice::AsyncResultPtr begin_getLog(const ::Ice::LogMessageTypeSeq& messageTypes, const ::Ice::StringSeq& traceCategories, ::Ice::Int messageMax, const ::Ice::Context& context, const ::Ice::Callback_LoggerAdmin_getLogPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
1563  {
1564  return _iceI_begin_getLog(messageTypes, traceCategories, messageMax, context, cb, cookie);
1565  }
1566 
1573  ICE_MEMBER(ICE_API) ::Ice::LogMessageSeq end_getLog(::std::string& prefix, const ::Ice::AsyncResultPtr& result);
1575 
1576  ICE_MEMBER(ICE_API) void _iceI_end_getLog(::std::string& iceP_prefix, ::Ice::LogMessageSeq& ret, const ::Ice::AsyncResultPtr&);
1578 
1579 private:
1580 
1581  ICE_MEMBER(ICE_API) ::Ice::AsyncResultPtr _iceI_begin_getLog(const ::Ice::LogMessageTypeSeq&, const ::Ice::StringSeq&, ::Ice::Int, const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
1582 
1583 public:
1584 
1589  ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
1590 
1591 protected:
1593 
1594  ICE_MEMBER(ICE_API) virtual ::IceProxy::Ice::Object* _newInstance() const;
1596 };
1597 
1598 }
1599 
1600 }
1601 
1602 namespace Ice
1603 {
1604 
1611 class ICE_API RemoteLogger : public virtual Object
1612 {
1613 public:
1614 
1615  typedef RemoteLoggerPrx ProxyType;
1616  typedef RemoteLoggerPtr PointerType;
1617 
1618  virtual ~RemoteLogger();
1619 
1620 #ifdef ICE_CPP11_COMPILER
1621  RemoteLogger() = default;
1622  RemoteLogger(const RemoteLogger&) = default;
1623  RemoteLogger& operator=(const RemoteLogger&) = default;
1624 #endif
1625 
1632  virtual bool ice_isA(const ::std::string& id, const Current& current = emptyCurrent) const;
1633 
1639  virtual ::std::vector< ::std::string> ice_ids(const Current& current = emptyCurrent) const;
1640 
1646  virtual const ::std::string& ice_id(const Current& current = emptyCurrent) const;
1647 
1652  static const ::std::string& ice_staticId();
1653 
1660  virtual void init(const ::std::string& prefix, const LogMessageSeq& logMessages, const Current& current = emptyCurrent) = 0;
1662  bool _iceD_init(::IceInternal::Incoming&, const ::Ice::Current&);
1664 
1670  virtual void log(const LogMessage& message, const Current& current = emptyCurrent) = 0;
1672  bool _iceD_log(::IceInternal::Incoming&, const ::Ice::Current&);
1674 
1676  virtual bool _iceDispatch(::IceInternal::Incoming&, const Current&);
1678 
1679 protected:
1680 
1682  virtual void _iceWriteImpl(OutputStream*) const;
1683  virtual void _iceReadImpl(InputStream*);
1685 };
1686 
1688 inline bool operator==(const RemoteLogger& lhs, const RemoteLogger& rhs)
1689 {
1690  return static_cast<const Object&>(lhs) == static_cast<const Object&>(rhs);
1691 }
1692 
1693 inline bool operator<(const RemoteLogger& lhs, const RemoteLogger& rhs)
1694 {
1695  return static_cast<const Object&>(lhs) < static_cast<const Object&>(rhs);
1696 }
1698 
1704 class ICE_API LoggerAdmin : public virtual Object
1705 {
1706 public:
1707 
1708  typedef LoggerAdminPrx ProxyType;
1709  typedef LoggerAdminPtr PointerType;
1710 
1711  virtual ~LoggerAdmin();
1712 
1713 #ifdef ICE_CPP11_COMPILER
1714  LoggerAdmin() = default;
1715  LoggerAdmin(const LoggerAdmin&) = default;
1716  LoggerAdmin& operator=(const LoggerAdmin&) = default;
1717 #endif
1718 
1725  virtual bool ice_isA(const ::std::string& id, const Current& current = emptyCurrent) const;
1726 
1732  virtual ::std::vector< ::std::string> ice_ids(const Current& current = emptyCurrent) const;
1733 
1739  virtual const ::std::string& ice_id(const Current& current = emptyCurrent) const;
1740 
1745  static const ::std::string& ice_staticId();
1746 
1762  virtual void attachRemoteLogger(const RemoteLoggerPrx& prx, const LogMessageTypeSeq& messageTypes, const StringSeq& traceCategories, Int messageMax, const Current& current = emptyCurrent) = 0;
1764  bool _iceD_attachRemoteLogger(::IceInternal::Incoming&, const ::Ice::Current&);
1766 
1773  virtual bool detachRemoteLogger(const RemoteLoggerPrx& prx, const Current& current = emptyCurrent) = 0;
1775  bool _iceD_detachRemoteLogger(::IceInternal::Incoming&, const ::Ice::Current&);
1777 
1791  virtual LogMessageSeq getLog(const LogMessageTypeSeq& messageTypes, const StringSeq& traceCategories, Int messageMax, ::std::string& prefix, const Current& current = emptyCurrent) = 0;
1793  bool _iceD_getLog(::IceInternal::Incoming&, const ::Ice::Current&);
1795 
1797  virtual bool _iceDispatch(::IceInternal::Incoming&, const Current&);
1799 
1800 protected:
1801 
1803  virtual void _iceWriteImpl(OutputStream*) const;
1804  virtual void _iceReadImpl(InputStream*);
1806 };
1807 
1809 inline bool operator==(const LoggerAdmin& lhs, const LoggerAdmin& rhs)
1810 {
1811  return static_cast<const Object&>(lhs) == static_cast<const Object&>(rhs);
1812 }
1813 
1814 inline bool operator<(const LoggerAdmin& lhs, const LoggerAdmin& rhs)
1815 {
1816  return static_cast<const Object&>(lhs) < static_cast<const Object&>(rhs);
1817 }
1819 
1820 }
1821 
1823 namespace Ice
1824 {
1825 
1826 template<>
1827 struct StreamableTraits< ::Ice::LogMessageType>
1828 {
1829  static const StreamHelperCategory helper = StreamHelperCategoryEnum;
1830  static const int minValue = 0;
1831  static const int maxValue = 3;
1832  static const int minWireSize = 1;
1833  static const bool fixedLength = false;
1834 };
1835 
1836 template<>
1837 struct StreamableTraits< ::Ice::LogMessage>
1838 {
1839  static const StreamHelperCategory helper = StreamHelperCategoryStruct;
1840  static const int minWireSize = 11;
1841  static const bool fixedLength = false;
1842 };
1843 
1844 template<typename S>
1845 struct StreamWriter< ::Ice::LogMessage, S>
1846 {
1847  static void write(S* ostr, const ::Ice::LogMessage& v)
1848  {
1849  ostr->write(v.type);
1850  ostr->write(v.timestamp);
1851  ostr->write(v.traceCategory);
1852  ostr->write(v.message);
1853  }
1854 };
1855 
1856 template<typename S>
1857 struct StreamReader< ::Ice::LogMessage, S>
1858 {
1859  static void read(S* istr, ::Ice::LogMessage& v)
1860  {
1861  istr->read(v.type);
1862  istr->read(v.timestamp);
1863  istr->read(v.traceCategory);
1864  istr->read(v.message);
1865  }
1866 };
1867 
1868 template<>
1869 struct StreamableTraits< ::Ice::RemoteLoggerAlreadyAttachedException>
1870 {
1871  static const StreamHelperCategory helper = StreamHelperCategoryUserException;
1872 };
1873 
1874 }
1876 
1877 namespace Ice
1878 {
1879 
1885 template<class T>
1886 class CallbackNC_RemoteLogger_init : public Callback_RemoteLogger_init_Base, public ::IceInternal::OnewayCallbackNC<T>
1887 {
1888 public:
1889 
1890  typedef IceUtil::Handle<T> TPtr;
1891 
1892  typedef void (T::*Exception)(const ::Ice::Exception&);
1893  typedef void (T::*Sent)(bool);
1894  typedef void (T::*Response)();
1895 
1896  CallbackNC_RemoteLogger_init(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
1897  : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
1898  {
1899  }
1900 };
1901 
1910 template<class T> Callback_RemoteLogger_initPtr
1911 newCallback_RemoteLogger_init(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
1912 {
1913  return new CallbackNC_RemoteLogger_init<T>(instance, cb, excb, sentcb);
1914 }
1915 
1923 template<class T> Callback_RemoteLogger_initPtr
1924 newCallback_RemoteLogger_init(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
1925 {
1926  return new CallbackNC_RemoteLogger_init<T>(instance, 0, excb, sentcb);
1927 }
1928 
1937 template<class T> Callback_RemoteLogger_initPtr
1938 newCallback_RemoteLogger_init(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
1939 {
1940  return new CallbackNC_RemoteLogger_init<T>(instance, cb, excb, sentcb);
1941 }
1942 
1950 template<class T> Callback_RemoteLogger_initPtr
1951 newCallback_RemoteLogger_init(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
1952 {
1953  return new CallbackNC_RemoteLogger_init<T>(instance, 0, excb, sentcb);
1954 }
1955 
1961 template<class T, typename CT>
1962 class Callback_RemoteLogger_init : public Callback_RemoteLogger_init_Base, public ::IceInternal::OnewayCallback<T, CT>
1963 {
1964 public:
1965 
1966  typedef IceUtil::Handle<T> TPtr;
1967 
1968  typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
1969  typedef void (T::*Sent)(bool , const CT&);
1970  typedef void (T::*Response)(const CT&);
1971 
1972  Callback_RemoteLogger_init(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
1973  : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
1974  {
1975  }
1976 };
1977 
1987 template<class T, typename CT> Callback_RemoteLogger_initPtr
1988 newCallback_RemoteLogger_init(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)
1989 {
1990  return new Callback_RemoteLogger_init<T, CT>(instance, cb, excb, sentcb);
1991 }
1992 
2001 template<class T, typename CT> Callback_RemoteLogger_initPtr
2002 newCallback_RemoteLogger_init(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
2003 {
2004  return new Callback_RemoteLogger_init<T, CT>(instance, 0, excb, sentcb);
2005 }
2006 
2016 template<class T, typename CT> Callback_RemoteLogger_initPtr
2017 newCallback_RemoteLogger_init(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
2018 {
2019  return new Callback_RemoteLogger_init<T, CT>(instance, cb, excb, sentcb);
2020 }
2021 
2030 template<class T, typename CT> Callback_RemoteLogger_initPtr
2031 newCallback_RemoteLogger_init(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
2032 {
2033  return new Callback_RemoteLogger_init<T, CT>(instance, 0, excb, sentcb);
2034 }
2035 
2041 template<class T>
2042 class CallbackNC_RemoteLogger_log : public Callback_RemoteLogger_log_Base, public ::IceInternal::OnewayCallbackNC<T>
2043 {
2044 public:
2045 
2046  typedef IceUtil::Handle<T> TPtr;
2047 
2048  typedef void (T::*Exception)(const ::Ice::Exception&);
2049  typedef void (T::*Sent)(bool);
2050  typedef void (T::*Response)();
2051 
2052  CallbackNC_RemoteLogger_log(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
2053  : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
2054  {
2055  }
2056 };
2057 
2066 template<class T> Callback_RemoteLogger_logPtr
2067 newCallback_RemoteLogger_log(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
2068 {
2069  return new CallbackNC_RemoteLogger_log<T>(instance, cb, excb, sentcb);
2070 }
2071 
2079 template<class T> Callback_RemoteLogger_logPtr
2080 newCallback_RemoteLogger_log(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
2081 {
2082  return new CallbackNC_RemoteLogger_log<T>(instance, 0, excb, sentcb);
2083 }
2084 
2093 template<class T> Callback_RemoteLogger_logPtr
2094 newCallback_RemoteLogger_log(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
2095 {
2096  return new CallbackNC_RemoteLogger_log<T>(instance, cb, excb, sentcb);
2097 }
2098 
2106 template<class T> Callback_RemoteLogger_logPtr
2107 newCallback_RemoteLogger_log(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
2108 {
2109  return new CallbackNC_RemoteLogger_log<T>(instance, 0, excb, sentcb);
2110 }
2111 
2117 template<class T, typename CT>
2118 class Callback_RemoteLogger_log : public Callback_RemoteLogger_log_Base, public ::IceInternal::OnewayCallback<T, CT>
2119 {
2120 public:
2121 
2122  typedef IceUtil::Handle<T> TPtr;
2123 
2124  typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
2125  typedef void (T::*Sent)(bool , const CT&);
2126  typedef void (T::*Response)(const CT&);
2127 
2128  Callback_RemoteLogger_log(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
2129  : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
2130  {
2131  }
2132 };
2133 
2143 template<class T, typename CT> Callback_RemoteLogger_logPtr
2144 newCallback_RemoteLogger_log(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)
2145 {
2146  return new Callback_RemoteLogger_log<T, CT>(instance, cb, excb, sentcb);
2147 }
2148 
2157 template<class T, typename CT> Callback_RemoteLogger_logPtr
2158 newCallback_RemoteLogger_log(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
2159 {
2160  return new Callback_RemoteLogger_log<T, CT>(instance, 0, excb, sentcb);
2161 }
2162 
2172 template<class T, typename CT> Callback_RemoteLogger_logPtr
2173 newCallback_RemoteLogger_log(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
2174 {
2175  return new Callback_RemoteLogger_log<T, CT>(instance, cb, excb, sentcb);
2176 }
2177 
2186 template<class T, typename CT> Callback_RemoteLogger_logPtr
2187 newCallback_RemoteLogger_log(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
2188 {
2189  return new Callback_RemoteLogger_log<T, CT>(instance, 0, excb, sentcb);
2190 }
2191 
2197 template<class T>
2198 class CallbackNC_LoggerAdmin_attachRemoteLogger : public Callback_LoggerAdmin_attachRemoteLogger_Base, public ::IceInternal::TwowayCallbackNC<T>
2199 {
2200 public:
2201 
2202  typedef IceUtil::Handle<T> TPtr;
2203 
2204  typedef void (T::*Exception)(const ::Ice::Exception&);
2205  typedef void (T::*Sent)(bool);
2206  typedef void (T::*Response)();
2207 
2208  CallbackNC_LoggerAdmin_attachRemoteLogger(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
2209  : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
2210  {
2211  }
2212 
2214  virtual void completed(const AsyncResultPtr& result) const
2215  {
2216  LoggerAdminPrx proxy = LoggerAdminPrx::uncheckedCast(result->getProxy());
2217  try
2218  {
2219  proxy->end_attachRemoteLogger(result);
2220  }
2221  catch(const ::Ice::Exception& ex)
2222  {
2223  ::IceInternal::CallbackNC<T>::exception(result, ex);
2224  return;
2225  }
2226  if(_response)
2227  {
2228  (::IceInternal::CallbackNC<T>::_callback.get()->*_response)();
2229  }
2230  }
2232 
2233 private:
2234 
2235  Response _response;
2236 };
2237 
2246 template<class T> Callback_LoggerAdmin_attachRemoteLoggerPtr
2247 newCallback_LoggerAdmin_attachRemoteLogger(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
2248 {
2249  return new CallbackNC_LoggerAdmin_attachRemoteLogger<T>(instance, cb, excb, sentcb);
2250 }
2251 
2259 template<class T> Callback_LoggerAdmin_attachRemoteLoggerPtr
2260 newCallback_LoggerAdmin_attachRemoteLogger(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
2261 {
2262  return new CallbackNC_LoggerAdmin_attachRemoteLogger<T>(instance, 0, excb, sentcb);
2263 }
2264 
2273 template<class T> Callback_LoggerAdmin_attachRemoteLoggerPtr
2274 newCallback_LoggerAdmin_attachRemoteLogger(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
2275 {
2276  return new CallbackNC_LoggerAdmin_attachRemoteLogger<T>(instance, cb, excb, sentcb);
2277 }
2278 
2286 template<class T> Callback_LoggerAdmin_attachRemoteLoggerPtr
2287 newCallback_LoggerAdmin_attachRemoteLogger(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
2288 {
2289  return new CallbackNC_LoggerAdmin_attachRemoteLogger<T>(instance, 0, excb, sentcb);
2290 }
2291 
2297 template<class T, typename CT>
2298 class Callback_LoggerAdmin_attachRemoteLogger : public Callback_LoggerAdmin_attachRemoteLogger_Base, public ::IceInternal::TwowayCallback<T, CT>
2299 {
2300 public:
2301 
2302  typedef IceUtil::Handle<T> TPtr;
2303 
2304  typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
2305  typedef void (T::*Sent)(bool , const CT&);
2306  typedef void (T::*Response)(const CT&);
2307 
2308  Callback_LoggerAdmin_attachRemoteLogger(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
2309  : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
2310  {
2311  }
2312 
2314  virtual void completed(const AsyncResultPtr& result) const
2315  {
2316  LoggerAdminPrx proxy = LoggerAdminPrx::uncheckedCast(result->getProxy());
2317  try
2318  {
2319  proxy->end_attachRemoteLogger(result);
2320  }
2321  catch(const ::Ice::Exception& ex)
2322  {
2323  ::IceInternal::Callback<T, CT>::exception(result, ex);
2324  return;
2325  }
2326  if(_response)
2327  {
2328  (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(CT::dynamicCast(result->getCookie()));
2329  }
2330  }
2332 
2333 private:
2334 
2335  Response _response;
2336 };
2337 
2347 template<class T, typename CT> Callback_LoggerAdmin_attachRemoteLoggerPtr
2348 newCallback_LoggerAdmin_attachRemoteLogger(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)
2349 {
2350  return new Callback_LoggerAdmin_attachRemoteLogger<T, CT>(instance, cb, excb, sentcb);
2351 }
2352 
2361 template<class T, typename CT> Callback_LoggerAdmin_attachRemoteLoggerPtr
2362 newCallback_LoggerAdmin_attachRemoteLogger(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
2363 {
2364  return new Callback_LoggerAdmin_attachRemoteLogger<T, CT>(instance, 0, excb, sentcb);
2365 }
2366 
2376 template<class T, typename CT> Callback_LoggerAdmin_attachRemoteLoggerPtr
2377 newCallback_LoggerAdmin_attachRemoteLogger(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
2378 {
2379  return new Callback_LoggerAdmin_attachRemoteLogger<T, CT>(instance, cb, excb, sentcb);
2380 }
2381 
2390 template<class T, typename CT> Callback_LoggerAdmin_attachRemoteLoggerPtr
2391 newCallback_LoggerAdmin_attachRemoteLogger(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
2392 {
2393  return new Callback_LoggerAdmin_attachRemoteLogger<T, CT>(instance, 0, excb, sentcb);
2394 }
2395 
2401 template<class T>
2402 class CallbackNC_LoggerAdmin_detachRemoteLogger : public Callback_LoggerAdmin_detachRemoteLogger_Base, public ::IceInternal::TwowayCallbackNC<T>
2403 {
2404 public:
2405 
2406  typedef IceUtil::Handle<T> TPtr;
2407 
2408  typedef void (T::*Exception)(const ::Ice::Exception&);
2409  typedef void (T::*Sent)(bool);
2410  typedef void (T::*Response)(bool);
2411 
2412  CallbackNC_LoggerAdmin_detachRemoteLogger(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
2413  : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
2414  {
2415  }
2416 
2418  virtual void completed(const AsyncResultPtr& result) const
2419  {
2420  LoggerAdminPrx proxy = LoggerAdminPrx::uncheckedCast(result->getProxy());
2421  bool ret;
2422  try
2423  {
2424  ret = proxy->end_detachRemoteLogger(result);
2425  }
2426  catch(const ::Ice::Exception& ex)
2427  {
2428  ::IceInternal::CallbackNC<T>::exception(result, ex);
2429  return;
2430  }
2431  if(_response)
2432  {
2433  (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
2434  }
2435  }
2437 
2438 private:
2439 
2440  Response _response;
2441 };
2442 
2451 template<class T> Callback_LoggerAdmin_detachRemoteLoggerPtr
2452 newCallback_LoggerAdmin_detachRemoteLogger(const IceUtil::Handle<T>& instance, void (T::*cb)(bool), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
2453 {
2454  return new CallbackNC_LoggerAdmin_detachRemoteLogger<T>(instance, cb, excb, sentcb);
2455 }
2456 
2465 template<class T> Callback_LoggerAdmin_detachRemoteLoggerPtr
2466 newCallback_LoggerAdmin_detachRemoteLogger(T* instance, void (T::*cb)(bool), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
2467 {
2468  return new CallbackNC_LoggerAdmin_detachRemoteLogger<T>(instance, cb, excb, sentcb);
2469 }
2470 
2476 template<class T, typename CT>
2477 class Callback_LoggerAdmin_detachRemoteLogger : public Callback_LoggerAdmin_detachRemoteLogger_Base, public ::IceInternal::TwowayCallback<T, CT>
2478 {
2479 public:
2480 
2481  typedef IceUtil::Handle<T> TPtr;
2482 
2483  typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
2484  typedef void (T::*Sent)(bool , const CT&);
2485  typedef void (T::*Response)(bool, const CT&);
2486 
2487  Callback_LoggerAdmin_detachRemoteLogger(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
2488  : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
2489  {
2490  }
2491 
2493  virtual void completed(const AsyncResultPtr& result) const
2494  {
2495  LoggerAdminPrx proxy = LoggerAdminPrx::uncheckedCast(result->getProxy());
2496  bool ret;
2497  try
2498  {
2499  ret = proxy->end_detachRemoteLogger(result);
2500  }
2501  catch(const ::Ice::Exception& ex)
2502  {
2503  ::IceInternal::Callback<T, CT>::exception(result, ex);
2504  return;
2505  }
2506  if(_response)
2507  {
2508  (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret, CT::dynamicCast(result->getCookie()));
2509  }
2510  }
2512 
2513 private:
2514 
2515  Response _response;
2516 };
2517 
2527 template<class T, typename CT> Callback_LoggerAdmin_detachRemoteLoggerPtr
2528 newCallback_LoggerAdmin_detachRemoteLogger(const IceUtil::Handle<T>& instance, void (T::*cb)(bool, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
2529 {
2530  return new Callback_LoggerAdmin_detachRemoteLogger<T, CT>(instance, cb, excb, sentcb);
2531 }
2532 
2542 template<class T, typename CT> Callback_LoggerAdmin_detachRemoteLoggerPtr
2543 newCallback_LoggerAdmin_detachRemoteLogger(T* instance, void (T::*cb)(bool, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
2544 {
2545  return new Callback_LoggerAdmin_detachRemoteLogger<T, CT>(instance, cb, excb, sentcb);
2546 }
2547 
2553 template<class T>
2554 class CallbackNC_LoggerAdmin_getLog : public Callback_LoggerAdmin_getLog_Base, public ::IceInternal::TwowayCallbackNC<T>
2555 {
2556 public:
2557 
2558  typedef IceUtil::Handle<T> TPtr;
2559 
2560  typedef void (T::*Exception)(const ::Ice::Exception&);
2561  typedef void (T::*Sent)(bool);
2562  typedef void (T::*Response)(const LogMessageSeq&, const ::std::string&);
2563 
2564  CallbackNC_LoggerAdmin_getLog(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
2565  : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
2566  {
2567  }
2568 
2570  virtual void completed(const AsyncResultPtr& result) const
2571  {
2572  LoggerAdminPrx proxy = LoggerAdminPrx::uncheckedCast(result->getProxy());
2573  ::std::string iceP_prefix;
2574  LogMessageSeq ret;
2575  try
2576  {
2577  ret = proxy->end_getLog(iceP_prefix, result);
2578  }
2579  catch(const ::Ice::Exception& ex)
2580  {
2581  ::IceInternal::CallbackNC<T>::exception(result, ex);
2582  return;
2583  }
2584  if(_response)
2585  {
2586  (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret, iceP_prefix);
2587  }
2588  }
2590 
2591 private:
2592 
2593  Response _response;
2594 };
2595 
2604 template<class T> Callback_LoggerAdmin_getLogPtr
2605 newCallback_LoggerAdmin_getLog(const IceUtil::Handle<T>& instance, void (T::*cb)(const LogMessageSeq&, const ::std::string&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
2606 {
2607  return new CallbackNC_LoggerAdmin_getLog<T>(instance, cb, excb, sentcb);
2608 }
2609 
2618 template<class T> Callback_LoggerAdmin_getLogPtr
2619 newCallback_LoggerAdmin_getLog(T* instance, void (T::*cb)(const LogMessageSeq&, const ::std::string&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
2620 {
2621  return new CallbackNC_LoggerAdmin_getLog<T>(instance, cb, excb, sentcb);
2622 }
2623 
2629 template<class T, typename CT>
2630 class Callback_LoggerAdmin_getLog : public Callback_LoggerAdmin_getLog_Base, public ::IceInternal::TwowayCallback<T, CT>
2631 {
2632 public:
2633 
2634  typedef IceUtil::Handle<T> TPtr;
2635 
2636  typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
2637  typedef void (T::*Sent)(bool , const CT&);
2638  typedef void (T::*Response)(const LogMessageSeq&, const ::std::string&, const CT&);
2639 
2640  Callback_LoggerAdmin_getLog(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
2641  : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
2642  {
2643  }
2644 
2646  virtual void completed(const AsyncResultPtr& result) const
2647  {
2648  LoggerAdminPrx proxy = LoggerAdminPrx::uncheckedCast(result->getProxy());
2649  ::std::string iceP_prefix;
2650  LogMessageSeq ret;
2651  try
2652  {
2653  ret = proxy->end_getLog(iceP_prefix, result);
2654  }
2655  catch(const ::Ice::Exception& ex)
2656  {
2657  ::IceInternal::Callback<T, CT>::exception(result, ex);
2658  return;
2659  }
2660  if(_response)
2661  {
2662  (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret, iceP_prefix, CT::dynamicCast(result->getCookie()));
2663  }
2664  }
2666 
2667 private:
2668 
2669  Response _response;
2670 };
2671 
2681 template<class T, typename CT> Callback_LoggerAdmin_getLogPtr
2682 newCallback_LoggerAdmin_getLog(const IceUtil::Handle<T>& instance, void (T::*cb)(const LogMessageSeq&, const ::std::string&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
2683 {
2684  return new Callback_LoggerAdmin_getLog<T, CT>(instance, cb, excb, sentcb);
2685 }
2686 
2696 template<class T, typename CT> Callback_LoggerAdmin_getLogPtr
2697 newCallback_LoggerAdmin_getLog(T* instance, void (T::*cb)(const LogMessageSeq&, const ::std::string&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
2698 {
2699  return new Callback_LoggerAdmin_getLog<T, CT>(instance, cb, excb, sentcb);
2700 }
2701 
2702 }
2703 
2704 #endif
2705 
2706 #include <IceUtil/PopDisableWarnings.h>
2707 #endif
Ice::operator!=
bool operator!=(const C &lhs, const C &rhs)
Relational operator for generated structs and classes.
Definition: Comparable.h:196
Ice::LoggerAdminPrx::detachRemoteLoggerAsync
::std::function< void()> detachRemoteLoggerAsync(const ::std::shared_ptr< RemoteLoggerPrx > &prx, ::std::function< void(bool)> response, ::std::function< void(::std::exception_ptr)> ex=nullptr, ::std::function< void(bool)> sent=nullptr, const Context &context=noExplicitContext)
Detaches a RemoteLogger object from the local logger.
Definition: RemoteLogger.h:602
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
Ice::InputStream
Interface for input streams used to extract Slice types from a sequence of bytes.
Definition: InputStream.h:50
Ice::LoggerAdmin::attachRemoteLogger
virtual void attachRemoteLogger(::std::shared_ptr< RemoteLoggerPrx > prx, LogMessageTypeSeq messageTypes, StringSeq traceCategories, int messageMax, const Current &current)=0
Attaches a RemoteLogger object to the local logger.
Ice::LogMessage::traceCategory
::std::string traceCategory
For a message of type trace, the trace category of this log message; otherwise, the empty string.
Definition: RemoteLogger.h:124
Ice::LoggerAdmin::ice_isA
virtual bool ice_isA(::std::string id, const Current &current) const override
Determines whether this object supports an interface with the given Slice type ID.
Ice::emptyCurrent
const Current emptyCurrent
A default-initialized Current instance.
Ice::RemoteLoggerPrx::initAsync
::std::function< void()> initAsync(const ::std::string &prefix, const LogMessageSeq &logMessages, ::std::function< void()> response, ::std::function< void(::std::exception_ptr)> ex=nullptr, ::std::function< void(bool)> sent=nullptr, const Context &context=noExplicitContext)
init is called by attachRemoteLogger when a RemoteLogger proxy is attached.
Definition: RemoteLogger.h:412
Ice::LoggerAdmin::ice_id
virtual ::std::string ice_id(const Current &current) const override
Obtains a Slice type ID representing the most-derived interface supported by this object.
Ice::RemoteLogger::ice_ids
virtual ::std::vector<::std::string > ice_ids(const Current &current) const override
Obtains a list of the Slice type IDs representing the interfaces supported by this object.
Ice::RemoteLoggerPrx::init
void init(const ::std::string &prefix, const LogMessageSeq &logMessages, const Context &context=noExplicitContext)
init is called by attachRemoteLogger when a RemoteLogger proxy is attached.
Definition: RemoteLogger.h:382
Ice::LoggerAdminPrx::getLog
LogMessageSeq getLog(const LogMessageTypeSeq &messageTypes, const StringSeq &traceCategories, int messageMax, ::std::string &prefix, const Context &context=noExplicitContext)
Retrieves log messages recently logged.
Definition: RemoteLogger.h:628
StreamHelpers.h
Ice::LogMessage::timestamp
long long int timestamp
The date and time when the Logger received this message, expressed as the number of microseconds sinc...
Definition: RemoteLogger.h:119
Ice::RemoteLoggerAlreadyAttachedException::RemoteLoggerAlreadyAttachedException
RemoteLoggerAlreadyAttachedException(const RemoteLoggerAlreadyAttachedException &)=default
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
Ice::Exception
IceUtil::Exception Exception
Definition: Exception.h:20
Ice::RemoteLogger::ice_staticId
static const ::std::string & ice_staticId()
Obtains the Slice type ID corresponding to this class.
Ice::upCast
IceUtil::Shared * upCast(::Ice::LocalObject *)
GCObject.h
Ice::RemoteLogger::log
virtual void log(LogMessage message, const Current &current)=0
Log a LogMessage.
Ice::RemoteLoggerPrx::ice_staticId
static const ::std::string & ice_staticId()
Obtains the Slice type ID of this interface.
Incoming.h
Ice::LoggerAdmin::ice_staticId
static const ::std::string & ice_staticId()
Obtains the Slice type ID corresponding to this class.
Ice::RemoteLogger::ice_id
virtual ::std::string ice_id(const Current &current) const override
Obtains a Slice type ID representing the most-derived interface supported by this object.
ICE_API
#define ICE_API
Definition: Config.h:197
Ice::LoggerAdmin::getLog
virtual LogMessageSeq getLog(LogMessageTypeSeq messageTypes, StringSeq traceCategories, int messageMax, ::std::string &prefix, const Current &current)=0
Retrieves log messages recently logged.
Ice::UserExceptionHelper
Helper template for the implementation of Ice::UserException.
Definition: ExceptionHelpers.h:39
ICE_MEMBER
#define ICE_MEMBER(API)
Definition: Config.h:177
Ice::operator<=
bool operator<=(const C &lhs, const C &rhs)
Relational operator for generated structs and classes.
Definition: Comparable.h:148
FactoryTableInit.h
Ice::LoggerAdmin::GetLogResult::prefix
::std::string prefix
The prefix of the associated local logger.
Definition: RemoteLogger.h:335
Ice::LoggerAdminPrx::attachRemoteLoggerAsync
::std::function< void()> attachRemoteLoggerAsync(const ::std::shared_ptr< RemoteLoggerPrx > &prx, const LogMessageTypeSeq &messageTypes, const StringSeq &traceCategories, int messageMax, ::std::function< void()> response, ::std::function< void(::std::exception_ptr)> ex=nullptr, ::std::function< void(bool)> sent=nullptr, const Context &context=noExplicitContext)
Attaches a RemoteLogger object to the local logger.
Definition: RemoteLogger.h:555
Ice::LoggerAdminPrx::detachRemoteLoggerAsync
auto detachRemoteLoggerAsync(const ::std::shared_ptr< RemoteLoggerPrx > &prx, const Context &context=noExplicitContext) -> decltype(::std::declval< P< bool >>().get_future())
Detaches a RemoteLogger object from the local logger.
Definition: RemoteLogger.h:586
Ice::RemoteLogger::ice_isA
virtual bool ice_isA(::std::string id, const Current &current) const override
Determines whether this object supports an interface with the given Slice type ID.
Ice::RemoteLoggerPrx::logAsync
auto logAsync(const LogMessage &message, const Context &context=noExplicitContext) -> decltype(::std::declval< P< void >>().get_future())
Log a LogMessage.
Definition: RemoteLogger.h:442
Ice::operator>=
bool operator>=(const C &lhs, const C &rhs)
Relational operator for generated structs and classes.
Definition: Comparable.h:172
Ice::LogMessageTypeSeq
::std::vector< LogMessageType > LogMessageTypeSeq
A sequence of LogMessageType.
Definition: RemoteLogger.h:103
LocalObject.h
PushDisableWarnings.h
Ice::LoggerAdminPrx::attachRemoteLogger
void attachRemoteLogger(const ::std::shared_ptr< RemoteLoggerPrx > &prx, const LogMessageTypeSeq &messageTypes, const StringSeq &traceCategories, int messageMax, const Context &context=noExplicitContext)
Attaches a RemoteLogger object to the local logger.
Definition: RemoteLogger.h:511
ProxyF.h
Ice::operator<
bool operator<(const C &lhs, const C &rhs)
Relational operator for generated structs and classes.
Definition: Comparable.h:136
Ice::LoggerAdminPrx
The interface of the admin object that allows an Ice application the attach its RemoteLogger to the L...
Definition: RemoteLogger.h:493
Ice::LoggerAdminPrx::getLogAsync
auto getLogAsync(const LogMessageTypeSeq &messageTypes, const StringSeq &traceCategories, int messageMax, const Context &context=noExplicitContext) -> decltype(::std::declval< P< LoggerAdmin::GetLogResult >>().get_future())
Retrieves log messages recently logged.
Definition: RemoteLogger.h:648
Ice::LogMessage::type
::Ice::LogMessageType type
The type of message sent to the Logger.
Definition: RemoteLogger.h:114
Ice::RemoteLogger
The Ice remote logger interface.
Definition: RemoteLogger.h:198
Ice::RemoteLoggerPrx::initAsync
auto initAsync(const ::std::string &prefix, const LogMessageSeq &logMessages, const Context &context=noExplicitContext) -> decltype(::std::declval< P< void >>().get_future())
init is called by attachRemoteLogger when a RemoteLogger proxy is attached.
Definition: RemoteLogger.h:395
Object.h
Proxy.h
UndefSysMacros.h
Ice::RemoteLoggerPrx::logAsync
::std::function< void()> logAsync(const LogMessage &message, ::std::function< void()> response, ::std::function< void(::std::exception_ptr)> ex=nullptr, ::std::function< void(bool)> sent=nullptr, const Context &context=noExplicitContext)
Log a LogMessage.
Definition: RemoteLogger.h:458
Ice::LoggerAdminPrx::detachRemoteLogger
bool detachRemoteLogger(const ::std::shared_ptr< RemoteLoggerPrx > &prx, const Context &context=noExplicitContext)
Detaches a RemoteLogger object from the local logger.
Definition: RemoteLogger.h:574
Ice::RemoteLoggerAlreadyAttachedException::RemoteLoggerAlreadyAttachedException
RemoteLoggerAlreadyAttachedException()=default
ObjectF.h
Ice::operator>
bool operator>(const C &lhs, const C &rhs)
Relational operator for generated structs and classes.
Definition: Comparable.h:160
Ice::LoggerAdminPrx::getLogAsync
::std::function< void()> getLogAsync(const LogMessageTypeSeq &messageTypes, const StringSeq &traceCategories, int messageMax, ::std::function< void(::Ice::LogMessageSeq, ::std::string)> response, ::std::function< void(::std::exception_ptr)> ex=nullptr, ::std::function< void(bool)> sent=nullptr, const Context &context=noExplicitContext)
Retrieves log messages recently logged.
Definition: RemoteLogger.h:670
Ice::Long
long long int Long
The mapping for the Slice long type.
Definition: Config.h:57
Ice::StringSeq
::std::vector<::std::string > StringSeq
A sequence of strings.
Definition: BuiltinSequences.h:96
Ice
Definition: BuiltinSequences.h:56
Ice::LoggerAdmin::GetLogResult::returnValue
LogMessageSeq returnValue
The Log messages.
Definition: RemoteLogger.h:333
Ice::LoggerAdmin::detachRemoteLogger
virtual bool detachRemoteLogger(::std::shared_ptr< RemoteLoggerPrx > prx, const Current &current)=0
Detaches a RemoteLogger object from the local logger.
Ice::LoggerAdminPrx::ice_staticId
static const ::std::string & ice_staticId()
Obtains the Slice type ID of this interface.
Ice::LogMessage::ice_tuple
std::tuple< const ::Ice::LogMessageType &, const long long int &, const ::std::string &, const ::std::string & > ice_tuple() const
Obtains a tuple containing all of the struct's data members.
Definition: RemoteLogger.h:134
Ice::LogMessageType::PrintMessage
@ PrintMessage
The Logger received a print message.
IceUtil::Handle
Definition: Handle.h:143
Ice::RemoteLoggerPrx
The Ice remote logger interface.
Definition: RemoteLogger.h:373
ExceptionHelpers.h
Ice::LogMessage
A complete log message.
Definition: RemoteLogger.h:110
Ice::RemoteLoggerAlreadyAttachedException::ice_tuple
std::tuple ice_tuple() const
Obtains a tuple containing all of the exception's data members.
Definition: RemoteLogger.h:163
Ice::LoggerAdmin
The interface of the admin object that allows an Ice application the attach its RemoteLogger to the L...
Definition: RemoteLogger.h:263
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
Ice::RemoteLogger::init
virtual void init(::std::string prefix, LogMessageSeq logMessages, const Current &current)=0
init is called by attachRemoteLogger when a RemoteLogger proxy is attached.
Comparable.h
BuiltinSequences.h
Ice::LogMessageType
LogMessageType
An enumeration representing the different types of log messages.
Definition: RemoteLogger.h:81
ScopedArray.h
Ice::LoggerAdminPrx::attachRemoteLoggerAsync
auto attachRemoteLoggerAsync(const ::std::shared_ptr< RemoteLoggerPrx > &prx, const LogMessageTypeSeq &messageTypes, const StringSeq &traceCategories, int messageMax, const Context &context=noExplicitContext) -> decltype(::std::declval< P< void >>().get_future())
Attaches a RemoteLogger object to the local logger.
Definition: RemoteLogger.h:531
Ice::LogMessageSeq
std::list< LogMessage > LogMessageSeq
A sequence of LogMessage.
Definition: RemoteLogger.h:143
Ice::Current
Information about the current method invocation for servers.
Definition: Current.h:120
Ice::Proxy
Helper template that supplies proxy factory functions.
Definition: Proxy.h:1204
Exception.h
ValueF.h
Ice::LogMessage::message
::std::string message
The log message itself.
Definition: RemoteLogger.h:128
Ice::RemoteLoggerAlreadyAttachedException::~RemoteLoggerAlreadyAttachedException
virtual ~RemoteLoggerAlreadyAttachedException()
Ice::Int
int Int
The mapping for the Slice int type.
Definition: Config.h:54
Ice::noExplicitContext
const Context noExplicitContext
Marker value used to indicate that no explicit context was passed to a proxy invocation.
Ice::LoggerAdmin::ice_ids
virtual ::std::vector<::std::string > ice_ids(const Current &current) const override
Obtains a list of the Slice type IDs representing the interfaces supported by this object.
Value.h
Ice::RemoteLoggerAlreadyAttachedException::ice_staticId
static const ::std::string & ice_staticId()
Obtains the Slice type ID of this exception.
Ice::LoggerAdmin::GetLogResult
Encapsulates the results of a call to getLog.
Definition: RemoteLogger.h:331
Ice::RemoteLoggerAlreadyAttachedException
Thrown when the provided RemoteLogger was previously attached to a LoggerAdmin.
Definition: RemoteLogger.h:150
PopDisableWarnings.h
Ice::RemoteLoggerPrx::log
void log(const LogMessage &message, const Context &context=noExplicitContext)
Log a LogMessage.
Definition: RemoteLogger.h:430
Generated by doxygen 1.8.20