zeroc-ice 3.7.0 → 3.7.5

data/ext/ice/cpp/include/generated/Ice/PropertiesF.h

@@ -1,13 +1,8 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
 //
-// **********************************************************************
-//
-// Ice version 3.7.0
+// Ice version 3.7.5
 //
 // <auto-generated>
 //
@@ -38,10 +33,10 @@
 #   if ICE_INT_VERSION / 100 != 307
 #       error Ice version mismatch!
 #   endif
-#   if ICE_INT_VERSION % 100 > 50
+#   if ICE_INT_VERSION % 100 >= 50
 #       error Beta header file detected
 #   endif
-#   if ICE_INT_VERSION % 100 < 0
+#   if ICE_INT_VERSION % 100 < 5
 #       error Ice patch level mismatch!
 #   endif
 #endif
@@ -67,11 +62,14 @@ class PropertiesAdminPrx;
 
 }
 
+/// \cond STREAM
 namespace Ice
 {
 
 }
+/// \endcond
 
+/// \cond INTERNAL
 namespace Ice
 {
 
@@ -81,6 +79,7 @@ using PropertiesAdminPtr = ::std::shared_ptr<PropertiesAdmin>;
 using PropertiesAdminPrxPtr = ::std::shared_ptr<PropertiesAdminPrx>;
 
 }
+/// \endcond
 
 #else // C++98 mapping
 
@@ -91,8 +90,10 @@ namespace Ice
 {
 
 class PropertiesAdmin;
-ICE_API void _readProxy(::Ice::InputStream*, ::IceInternal::ProxyHandle< ::IceProxy::Ice::PropertiesAdmin>&);
-ICE_API ::IceProxy::Ice::Object* upCast(::IceProxy::Ice::PropertiesAdmin*);
+/// \cond INTERNAL
+ICE_API void _readProxy(::Ice::InputStream*, ::IceInternal::ProxyHandle< PropertiesAdmin>&);
+ICE_API ::IceProxy::Ice::Object* upCast(PropertiesAdmin*);
+/// \endcond
 
 }
 
@@ -102,22 +103,30 @@ namespace Ice
 {
 
 class Properties;
-ICE_API ::Ice::LocalObject* upCast(::Ice::Properties*);
-typedef ::IceInternal::Handle< ::Ice::Properties> PropertiesPtr;
+/// \cond INTERNAL
+ICE_API LocalObject* upCast(Properties*);
+/// \endcond
+typedef ::IceInternal::Handle< Properties> PropertiesPtr;
 
 class PropertiesAdmin;
-ICE_API ::Ice::Object* upCast(::Ice::PropertiesAdmin*);
-typedef ::IceInternal::Handle< ::Ice::PropertiesAdmin> PropertiesAdminPtr;
+/// \cond INTERNAL
+ICE_API Object* upCast(PropertiesAdmin*);
+/// \endcond
+typedef ::IceInternal::Handle< PropertiesAdmin> PropertiesAdminPtr;
 typedef ::IceInternal::ProxyHandle< ::IceProxy::Ice::PropertiesAdmin> PropertiesAdminPrx;
 typedef PropertiesAdminPrx PropertiesAdminPrxPtr;
-ICE_API void _icePatchObjectPtr(PropertiesAdminPtr&, const ::Ice::ObjectPtr&);
+/// \cond INTERNAL
+ICE_API void _icePatchObjectPtr(PropertiesAdminPtr&, const ObjectPtr&);
+/// \endcond
 
 }
 
+/// \cond STREAM
 namespace Ice
 {
 
 }
+/// \endcond
 
 #endif
 

data/ext/ice/cpp/include/generated/Ice/RemoteLogger.h

@@ -1,13 +1,8 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
 //
-// **********************************************************************
-//
-// Ice version 3.7.0
+// Ice version 3.7.5
 //
 // <auto-generated>
 //
@@ -46,10 +41,10 @@
 #   if ICE_INT_VERSION / 100 != 307
 #       error Ice version mismatch!
 #   endif
-#   if ICE_INT_VERSION % 100 > 50
+#   if ICE_INT_VERSION % 100 >= 50
 #       error Beta header file detected
 #   endif
-#   if ICE_INT_VERSION % 100 < 0
+#   if ICE_INT_VERSION % 100 < 5
 #       error Ice patch level mismatch!
 #   endif
 #endif
@@ -79,32 +74,79 @@ class LoggerAdminPrx;
 namespace Ice
 {
 
+/**
+ * An enumeration representing the different types of log messages.
+ */
 enum class LogMessageType : unsigned char
 {
+    /**
+     * The {@link Logger} received a print message.
+     */
     PrintMessage,
+    /**
+     * The {@link Logger} received a trace message.
+     */
     TraceMessage,
+    /**
+     * The {@link Logger} received a warning message.
+     */
     WarningMessage,
+    /**
+     * The {@link Logger} received an error message.
+     */
     ErrorMessage
 };
 
-using LogMessageTypeSeq = ::std::vector<::Ice::LogMessageType>;
+/**
+ * A sequence of {@link LogMessageType}
+ */
+using LogMessageTypeSeq = ::std::vector<LogMessageType>;
 
+/**
+ * A complete log message.
+ * \headerfile Ice/Ice.h
+ */
 struct LogMessage
 {
+    /**
+     * The type of message sent to the {@link Logger}.
+     */
     ::Ice::LogMessageType type;
+    /**
+     * The date and time when the {@link Logger} received this message, expressed
+     * as the number of microseconds since the Unix Epoch (00:00:00 UTC on 1 January 1970)
+     */
     long long int timestamp;
+    /**
+     * For a message of type trace, the trace category of this log message;
+     * otherwise, the empty string.
+     */
     ::std::string traceCategory;
+    /**
+     * The log message itself.
+     */
     ::std::string message;
 
+    /**
+     * Obtains a tuple containing all of the struct's data members.
+     * @return The data members in a tuple.
+     */
     std::tuple<const ::Ice::LogMessageType&, const long long int&, const ::std::string&, const ::std::string&> ice_tuple() const
     {
         return std::tie(type, timestamp, traceCategory, message);
     }
 };
 
+/**
+ * A sequence of {@link LogMessage}.
+ */
 using LogMessageSeq = std::list<LogMessage>;
 
-class ICE_CLASS(ICE_API) RemoteLoggerAlreadyAttachedException : public ::Ice::UserExceptionHelper<RemoteLoggerAlreadyAttachedException, ::Ice::UserException>
+/**
+ * Thrown when the provided RemoteLogger was previously attached to a LoggerAdmin.
+ * \headerfile Ice/Ice.h
+ */
+class ICE_CLASS(ICE_API) RemoteLoggerAlreadyAttachedException : public UserExceptionHelper<RemoteLoggerAlreadyAttachedException, UserException>
 {
 public:
 
@@ -114,15 +156,25 @@ public:
 
     RemoteLoggerAlreadyAttachedException() = default;
 
+    /**
+     * Obtains a tuple containing all of the exception's data members.
+     * @return The data members in a tuple.
+     */
     std::tuple<> ice_tuple() const
     {
         return std::tie();
     }
 
+    /**
+     * Obtains the Slice type ID of this exception.
+     * @return The fully-scoped type ID.
+     */
     ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
 };
 
+/// \cond INTERNAL
 static RemoteLoggerAlreadyAttachedException _iceS_RemoteLoggerAlreadyAttachedException_init;
+/// \endcond
 
 using Ice::operator<;
 using Ice::operator<=;
@@ -136,55 +188,174 @@ using Ice::operator!=;
 namespace Ice
 {
 
-class ICE_API RemoteLogger : public virtual ::Ice::Object
+/**
+ * The Ice remote logger interface. An application can implement a
+ * RemoteLogger to receive the log messages sent to the local {@link Logger}
+ * of another Ice application.
+ * \headerfile Ice/Ice.h
+ */
+class ICE_API RemoteLogger : public virtual Object
 {
 public:
 
     using ProxyType = RemoteLoggerPrx;
 
-    virtual bool ice_isA(::std::string, const ::Ice::Current&) const override;
-    virtual ::std::vector<::std::string> ice_ids(const ::Ice::Current&) const override;
-    virtual ::std::string ice_id(const ::Ice::Current&) const override;
-
+    /**
+     * Determines whether this object supports an interface with the given Slice type ID.
+     * @param id The fully-scoped Slice type ID.
+     * @param current The Current object for the invocation.
+     * @return True if this object supports the interface, false, otherwise.
+     */
+    virtual bool ice_isA(::std::string id, const Current& current) const override;
+
+    /**
+     * Obtains a list of the Slice type IDs representing the interfaces supported by this object.
+     * @param current The Current object for the invocation.
+     * @return A list of fully-scoped type IDs.
+     */
+    virtual ::std::vector<::std::string> ice_ids(const Current& current) const override;
+
+    /**
+     * Obtains a Slice type ID representing the most-derived interface supported by this object.
+     * @param current The Current object for the invocation.
+     * @return A fully-scoped type ID.
+     */
+    virtual ::std::string ice_id(const Current& current) const override;
+
+    /**
+     * Obtains the Slice type ID corresponding to this class.
+     * @return A fully-scoped type ID.
+     */
     static const ::std::string& ice_staticId();
 
-    virtual void init(::std::string, ::Ice::LogMessageSeq, const ::Ice::Current&) = 0;
-    bool _iceD_init(::IceInternal::Incoming&, const ::Ice::Current&);
-
-    virtual void log(::Ice::LogMessage, const ::Ice::Current&) = 0;
-    bool _iceD_log(::IceInternal::Incoming&, const ::Ice::Current&);
-
-    virtual bool _iceDispatch(::IceInternal::Incoming&, const ::Ice::Current&) override;
+    /**
+     * init is called by attachRemoteLogger when a RemoteLogger proxy is attached.
+     * @param prefix The prefix of the associated local Logger.
+     * @param logMessages Old log messages generated before "now".
+     * @param current The Current object for the invocation.
+     */
+    virtual void init(::std::string prefix, LogMessageSeq logMessages, const Current& current) = 0;
+    /// \cond INTERNAL
+    bool _iceD_init(::IceInternal::Incoming&, const Current&);
+    /// \endcond
+
+    /**
+     * Log a LogMessage. Note that log may be called by LoggerAdmin before init.
+     * @param message The message to log.
+     * @param current The Current object for the invocation.
+     */
+    virtual void log(LogMessage message, const Current& current) = 0;
+    /// \cond INTERNAL
+    bool _iceD_log(::IceInternal::Incoming&, const Current&);
+    /// \endcond
+
+    /// \cond INTERNAL
+    virtual bool _iceDispatch(::IceInternal::Incoming&, const Current&) override;
+    /// \endcond
 };
 
-class ICE_API LoggerAdmin : public virtual ::Ice::Object
+/**
+ * The interface of the admin object that allows an Ice application the attach its
+ * {@link RemoteLogger} to the {@link Logger} of this admin object's Ice communicator.
+ * \headerfile Ice/Ice.h
+ */
+class ICE_API LoggerAdmin : public virtual Object
 {
 public:
 
     using ProxyType = LoggerAdminPrx;
 
-    virtual bool ice_isA(::std::string, const ::Ice::Current&) const override;
-    virtual ::std::vector<::std::string> ice_ids(const ::Ice::Current&) const override;
-    virtual ::std::string ice_id(const ::Ice::Current&) const override;
-
+    /**
+     * Determines whether this object supports an interface with the given Slice type ID.
+     * @param id The fully-scoped Slice type ID.
+     * @param current The Current object for the invocation.
+     * @return True if this object supports the interface, false, otherwise.
+     */
+    virtual bool ice_isA(::std::string id, const Current& current) const override;
+
+    /**
+     * Obtains a list of the Slice type IDs representing the interfaces supported by this object.
+     * @param current The Current object for the invocation.
+     * @return A list of fully-scoped type IDs.
+     */
+    virtual ::std::vector<::std::string> ice_ids(const Current& current) const override;
+
+    /**
+     * Obtains a Slice type ID representing the most-derived interface supported by this object.
+     * @param current The Current object for the invocation.
+     * @return A fully-scoped type ID.
+     */
+    virtual ::std::string ice_id(const Current& current) const override;
+
+    /**
+     * Obtains the Slice type ID corresponding to this class.
+     * @return A fully-scoped type ID.
+     */
     static const ::std::string& ice_staticId();
 
-    virtual void attachRemoteLogger(::std::shared_ptr<::Ice::RemoteLoggerPrx>, ::Ice::LogMessageTypeSeq, ::Ice::StringSeq, int, const ::Ice::Current&) = 0;
-    bool _iceD_attachRemoteLogger(::IceInternal::Incoming&, const ::Ice::Current&);
-
-    virtual bool detachRemoteLogger(::std::shared_ptr<::Ice::RemoteLoggerPrx>, const ::Ice::Current&) = 0;
-    bool _iceD_detachRemoteLogger(::IceInternal::Incoming&, const ::Ice::Current&);
-
+    /**
+     * Attaches a RemoteLogger object to the local logger.
+     * attachRemoteLogger calls init on the provided RemoteLogger proxy.
+     * @param prx A proxy to the remote logger.
+     * @param messageTypes The list of message types that the remote logger wishes to receive.
+     * An empty list means no filtering (send all message types).
+     * @param traceCategories The categories of traces that the remote logger wishes to receive.
+     * This parameter is ignored if messageTypes is not empty and does not include trace.
+     * An empty list means no filtering (send all trace categories).
+     * @param messageMax The maximum number of log messages (of all types) to be provided
+     * to init. A negative value requests all messages available.
+     * @param current The Current object for the invocation.
+     * @throws Ice::RemoteLoggerAlreadyAttachedException Raised if this remote logger is already
+     * attached to this admin object.
+     */
+    virtual void attachRemoteLogger(::std::shared_ptr<RemoteLoggerPrx> prx, LogMessageTypeSeq messageTypes, StringSeq traceCategories, int messageMax, const Current& current) = 0;
+    /// \cond INTERNAL
+    bool _iceD_attachRemoteLogger(::IceInternal::Incoming&, const Current&);
+    /// \endcond
+
+    /**
+     * Detaches a RemoteLogger object from the local logger.
+     * @param prx A proxy to the remote logger.
+     * @param current The Current object for the invocation.
+     * @return True if the provided remote logger proxy was detached, and false otherwise.
+     */
+    virtual bool detachRemoteLogger(::std::shared_ptr<RemoteLoggerPrx> prx, const Current& current) = 0;
+    /// \cond INTERNAL
+    bool _iceD_detachRemoteLogger(::IceInternal::Incoming&, const Current&);
+    /// \endcond
+
+    /**
+     * Encapsulates the results of a call to getLog.
+     */
     struct GetLogResult
     {
-        ::Ice::LogMessageSeq returnValue;
+        /** The Log messages. */
+        LogMessageSeq returnValue;
+        /** The prefix of the associated local logger. */
         ::std::string prefix;
     };
 
-    virtual ::Ice::LogMessageSeq getLog(::Ice::LogMessageTypeSeq, ::Ice::StringSeq, int, ::std::string&, const ::Ice::Current&) = 0;
-    bool _iceD_getLog(::IceInternal::Incoming&, const ::Ice::Current&);
-
-    virtual bool _iceDispatch(::IceInternal::Incoming&, const ::Ice::Current&) override;
+    /**
+     * Retrieves log messages recently logged.
+     * @param messageTypes The list of message types that the caller wishes to receive.
+     * An empty list means no filtering (send all message types).
+     * @param traceCategories The categories of traces that caller wish to receive.
+     * This parameter is ignored if messageTypes is not empty and does not include trace.
+     * An empty list means no filtering (send all trace categories).
+     * @param messageMax The maximum number of log messages (of all types) to be returned.
+     * A negative value requests all messages available.
+     * @param prefix The prefix of the associated local logger.
+     * @param current The Current object for the invocation.
+     * @return The Log messages.
+     */
+    virtual LogMessageSeq getLog(LogMessageTypeSeq messageTypes, StringSeq traceCategories, int messageMax, ::std::string& prefix, const Current& current) = 0;
+    /// \cond INTERNAL
+    bool _iceD_getLog(::IceInternal::Incoming&, const Current&);
+    /// \endcond
+
+    /// \cond INTERNAL
+    virtual bool _iceDispatch(::IceInternal::Incoming&, const Current&) override;
+    /// \endcond
 };
 
 }
@@ -192,162 +363,346 @@ public:
 namespace Ice
 {
 
-class ICE_CLASS(ICE_API) RemoteLoggerPrx : public virtual ::Ice::Proxy<RemoteLoggerPrx, ::Ice::ObjectPrx>
+/**
+ * The Ice remote logger interface. An application can implement a
+ * RemoteLogger to receive the log messages sent to the local {@link Logger}
+ * of another Ice application.
+ * \headerfile Ice/Ice.h
+ */
+class ICE_CLASS(ICE_API) RemoteLoggerPrx : public virtual Proxy<RemoteLoggerPrx, ObjectPrx>
 {
 public:
 
-    void init(const ::std::string& iceP_prefix, const ::Ice::LogMessageSeq& iceP_logMessages, const ::Ice::Context& context = Ice::noExplicitContext)
+    /**
+     * init is called by attachRemoteLogger when a RemoteLogger proxy is attached.
+     * @param prefix The prefix of the associated local Logger.
+     * @param logMessages Old log messages generated before "now".
+     * @param context The Context map to send with the invocation.
+     */
+    void init(const ::std::string& prefix, const LogMessageSeq& logMessages, const Context& context = noExplicitContext)
     {
-        _makePromiseOutgoing<void>(true, this, &Ice::RemoteLoggerPrx::_iceI_init, iceP_prefix, iceP_logMessages, context).get();
+        _makePromiseOutgoing<void>(true, this, &RemoteLoggerPrx::_iceI_init, prefix, logMessages, context).get();
     }
 
+    /**
+     * init is called by attachRemoteLogger when a RemoteLogger proxy is attached.
+     * @param prefix The prefix of the associated local Logger.
+     * @param logMessages Old log messages generated before "now".
+     * @param context The Context map to send with the invocation.
+     * @return The future object for the invocation.
+     */
     template<template<typename> class P = ::std::promise>
-    auto initAsync(const ::std::string& iceP_prefix, const ::Ice::LogMessageSeq& iceP_logMessages, const ::Ice::Context& context = Ice::noExplicitContext)
+    auto initAsync(const ::std::string& prefix, const LogMessageSeq& logMessages, const Context& context = noExplicitContext)
         -> decltype(::std::declval<P<void>>().get_future())
     {
-        return _makePromiseOutgoing<void, P>(false, this, &Ice::RemoteLoggerPrx::_iceI_init, iceP_prefix, iceP_logMessages, context);
+        return _makePromiseOutgoing<void, P>(false, this, &RemoteLoggerPrx::_iceI_init, prefix, logMessages, context);
     }
 
+    /**
+     * init is called by attachRemoteLogger when a RemoteLogger proxy is attached.
+     * @param prefix The prefix of the associated local Logger.
+     * @param logMessages Old log messages generated before "now".
+     * @param response The response callback.
+     * @param ex The exception callback.
+     * @param sent The sent callback.
+     * @param context The Context map to send with the invocation.
+     * @return A function that can be called to cancel the invocation locally.
+     */
     ::std::function<void()>
-    initAsync(const ::std::string& iceP_prefix, const ::Ice::LogMessageSeq& iceP_logMessages,
+    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 ::Ice::Context& context = Ice::noExplicitContext)
+              const Context& context = noExplicitContext)
     {
-        return _makeLamdaOutgoing<void>(response, ex, sent, this, &Ice::RemoteLoggerPrx::_iceI_init, iceP_prefix, iceP_logMessages, context);
+        return _makeLamdaOutgoing<void>(std::move(response), std::move(ex), std::move(sent), this, &Ice::RemoteLoggerPrx::_iceI_init, prefix, logMessages, context);
     }
 
-    ICE_MEMBER(ICE_API) void _iceI_init(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&, const ::std::string&, const ::Ice::LogMessageSeq&, const ::Ice::Context&);
+    /// \cond INTERNAL
+    ICE_MEMBER(ICE_API) void _iceI_init(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&, const ::std::string&, const LogMessageSeq&, const Context&);
+    /// \endcond
 
-    void log(const ::Ice::LogMessage& iceP_message, const ::Ice::Context& context = Ice::noExplicitContext)
+    /**
+     * Log a LogMessage. Note that log may be called by LoggerAdmin before init.
+     * @param message The message to log.
+     * @param context The Context map to send with the invocation.
+     */
+    void log(const LogMessage& message, const Context& context = noExplicitContext)
     {
-        _makePromiseOutgoing<void>(true, this, &Ice::RemoteLoggerPrx::_iceI_log, iceP_message, context).get();
+        _makePromiseOutgoing<void>(true, this, &RemoteLoggerPrx::_iceI_log, message, context).get();
     }
 
+    /**
+     * Log a LogMessage. Note that log may be called by LoggerAdmin before init.
+     * @param message The message to log.
+     * @param context The Context map to send with the invocation.
+     * @return The future object for the invocation.
+     */
     template<template<typename> class P = ::std::promise>
-    auto logAsync(const ::Ice::LogMessage& iceP_message, const ::Ice::Context& context = Ice::noExplicitContext)
+    auto logAsync(const LogMessage& message, const Context& context = noExplicitContext)
         -> decltype(::std::declval<P<void>>().get_future())
     {
-        return _makePromiseOutgoing<void, P>(false, this, &Ice::RemoteLoggerPrx::_iceI_log, iceP_message, context);
+        return _makePromiseOutgoing<void, P>(false, this, &RemoteLoggerPrx::_iceI_log, message, context);
     }
 
+    /**
+     * Log a LogMessage. Note that log may be called by LoggerAdmin before init.
+     * @param message The message to log.
+     * @param response The response callback.
+     * @param ex The exception callback.
+     * @param sent The sent callback.
+     * @param context The Context map to send with the invocation.
+     * @return A function that can be called to cancel the invocation locally.
+     */
     ::std::function<void()>
-    logAsync(const ::Ice::LogMessage& iceP_message,
+    logAsync(const LogMessage& message,
              ::std::function<void()> response,
              ::std::function<void(::std::exception_ptr)> ex = nullptr,
              ::std::function<void(bool)> sent = nullptr,
-             const ::Ice::Context& context = Ice::noExplicitContext)
+             const Context& context = noExplicitContext)
     {
-        return _makeLamdaOutgoing<void>(response, ex, sent, this, &Ice::RemoteLoggerPrx::_iceI_log, iceP_message, context);
+        return _makeLamdaOutgoing<void>(std::move(response), std::move(ex), std::move(sent), this, &Ice::RemoteLoggerPrx::_iceI_log, message, context);
     }
 
-    ICE_MEMBER(ICE_API) void _iceI_log(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&, const ::Ice::LogMessage&, const ::Ice::Context&);
+    /// \cond INTERNAL
+    ICE_MEMBER(ICE_API) void _iceI_log(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&, const LogMessage&, const Context&);
+    /// \endcond
 
+    /**
+     * Obtains the Slice type ID of this interface.
+     * @return The fully-scoped type ID.
+     */
     ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
 
 protected:
 
+    /// \cond INTERNAL
     RemoteLoggerPrx() = default;
     friend ::std::shared_ptr<RemoteLoggerPrx> IceInternal::createProxy<RemoteLoggerPrx>();
 
-    ICE_MEMBER(ICE_API) virtual ::std::shared_ptr<::Ice::ObjectPrx> _newInstance() const override;
+    ICE_MEMBER(ICE_API) virtual ::std::shared_ptr<ObjectPrx> _newInstance() const override;
+    /// \endcond
 };
 
-class ICE_CLASS(ICE_API) LoggerAdminPrx : public virtual ::Ice::Proxy<LoggerAdminPrx, ::Ice::ObjectPrx>
+/**
+ * The interface of the admin object that allows an Ice application the attach its
+ * {@link RemoteLogger} to the {@link Logger} of this admin object's Ice communicator.
+ * \headerfile Ice/Ice.h
+ */
+class ICE_CLASS(ICE_API) LoggerAdminPrx : public virtual Proxy<LoggerAdminPrx, ObjectPrx>
 {
 public:
 
-    void attachRemoteLogger(const ::std::shared_ptr<::Ice::RemoteLoggerPrx>& iceP_prx, const ::Ice::LogMessageTypeSeq& iceP_messageTypes, const ::Ice::StringSeq& iceP_traceCategories, int iceP_messageMax, const ::Ice::Context& context = Ice::noExplicitContext)
-    {
-        _makePromiseOutgoing<void>(true, this, &Ice::LoggerAdminPrx::_iceI_attachRemoteLogger, iceP_prx, iceP_messageTypes, iceP_traceCategories, iceP_messageMax, context).get();
-    }
-
+    /**
+     * Attaches a RemoteLogger object to the local logger.
+     * attachRemoteLogger calls init on the provided RemoteLogger proxy.
+     * @param prx A proxy to the remote logger.
+     * @param messageTypes The list of message types that the remote logger wishes to receive.
+     * An empty list means no filtering (send all message types).
+     * @param traceCategories The categories of traces that the remote logger wishes to receive.
+     * This parameter is ignored if messageTypes is not empty and does not include trace.
+     * An empty list means no filtering (send all trace categories).
+     * @param messageMax The maximum number of log messages (of all types) to be provided
+     * to init. A negative value requests all messages available.
+     * @param context The Context map to send with the invocation.
+     * @throws Ice::RemoteLoggerAlreadyAttachedException Raised if this remote logger is already
+     * attached to this admin object.
+     */
+    void attachRemoteLogger(const ::std::shared_ptr<RemoteLoggerPrx>& prx, const LogMessageTypeSeq& messageTypes, const StringSeq& traceCategories, int messageMax, const Context& context = noExplicitContext)
+    {
+        _makePromiseOutgoing<void>(true, this, &LoggerAdminPrx::_iceI_attachRemoteLogger, prx, messageTypes, traceCategories, messageMax, context).get();
+    }
+
+    /**
+     * Attaches a RemoteLogger object to the local logger.
+     * attachRemoteLogger calls init on the provided RemoteLogger proxy.
+     * @param prx A proxy to the remote logger.
+     * @param messageTypes The list of message types that the remote logger wishes to receive.
+     * An empty list means no filtering (send all message types).
+     * @param traceCategories The categories of traces that the remote logger wishes to receive.
+     * This parameter is ignored if messageTypes is not empty and does not include trace.
+     * An empty list means no filtering (send all trace categories).
+     * @param messageMax The maximum number of log messages (of all types) to be provided
+     * to init. A negative value requests all messages available.
+     * @param context The Context map to send with the invocation.
+     * @return The future object for the invocation.
+     */
     template<template<typename> class P = ::std::promise>
-    auto attachRemoteLoggerAsync(const ::std::shared_ptr<::Ice::RemoteLoggerPrx>& iceP_prx, const ::Ice::LogMessageTypeSeq& iceP_messageTypes, const ::Ice::StringSeq& iceP_traceCategories, int iceP_messageMax, const ::Ice::Context& context = Ice::noExplicitContext)
+    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())
     {
-        return _makePromiseOutgoing<void, P>(false, this, &Ice::LoggerAdminPrx::_iceI_attachRemoteLogger, iceP_prx, iceP_messageTypes, iceP_traceCategories, iceP_messageMax, context);
-    }
-
+        return _makePromiseOutgoing<void, P>(false, this, &LoggerAdminPrx::_iceI_attachRemoteLogger, prx, messageTypes, traceCategories, messageMax, context);
+    }
+
+    /**
+     * Attaches a RemoteLogger object to the local logger.
+     * attachRemoteLogger calls init on the provided RemoteLogger proxy.
+     * @param prx A proxy to the remote logger.
+     * @param messageTypes The list of message types that the remote logger wishes to receive.
+     * An empty list means no filtering (send all message types).
+     * @param traceCategories The categories of traces that the remote logger wishes to receive.
+     * This parameter is ignored if messageTypes is not empty and does not include trace.
+     * An empty list means no filtering (send all trace categories).
+     * @param messageMax The maximum number of log messages (of all types) to be provided
+     * to init. A negative value requests all messages available.
+     * @param response The response callback.
+     * @param ex The exception callback.
+     * @param sent The sent callback.
+     * @param context The Context map to send with the invocation.
+     * @return A function that can be called to cancel the invocation locally.
+     */
     ::std::function<void()>
-    attachRemoteLoggerAsync(const ::std::shared_ptr<::Ice::RemoteLoggerPrx>& iceP_prx, const ::Ice::LogMessageTypeSeq& iceP_messageTypes, const ::Ice::StringSeq& iceP_traceCategories, int iceP_messageMax,
+    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 ::Ice::Context& context = Ice::noExplicitContext)
+                            const Context& context = noExplicitContext)
     {
-        return _makeLamdaOutgoing<void>(response, ex, sent, this, &Ice::LoggerAdminPrx::_iceI_attachRemoteLogger, iceP_prx, iceP_messageTypes, iceP_traceCategories, iceP_messageMax, context);
+        return _makeLamdaOutgoing<void>(std::move(response), std::move(ex), std::move(sent), this, &Ice::LoggerAdminPrx::_iceI_attachRemoteLogger, prx, messageTypes, traceCategories, messageMax, context);
     }
 
-    ICE_MEMBER(ICE_API) void _iceI_attachRemoteLogger(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&, const ::std::shared_ptr<::Ice::RemoteLoggerPrx>&, const ::Ice::LogMessageTypeSeq&, const ::Ice::StringSeq&, int, const ::Ice::Context&);
+    /// \cond INTERNAL
+    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&);
+    /// \endcond
 
-    bool detachRemoteLogger(const ::std::shared_ptr<::Ice::RemoteLoggerPrx>& iceP_prx, const ::Ice::Context& context = Ice::noExplicitContext)
+    /**
+     * Detaches a RemoteLogger object from the local logger.
+     * @param prx A proxy to the remote logger.
+     * @param context The Context map to send with the invocation.
+     * @return True if the provided remote logger proxy was detached, and false otherwise.
+     */
+    bool detachRemoteLogger(const ::std::shared_ptr<RemoteLoggerPrx>& prx, const Context& context = noExplicitContext)
     {
-        return _makePromiseOutgoing<bool>(true, this, &Ice::LoggerAdminPrx::_iceI_detachRemoteLogger, iceP_prx, context).get();
+        return _makePromiseOutgoing<bool>(true, this, &LoggerAdminPrx::_iceI_detachRemoteLogger, prx, context).get();
     }
 
+    /**
+     * Detaches a RemoteLogger object from the local logger.
+     * @param prx A proxy to the remote logger.
+     * @param context The Context map to send with the invocation.
+     * @return The future object for the invocation.
+     */
     template<template<typename> class P = ::std::promise>
-    auto detachRemoteLoggerAsync(const ::std::shared_ptr<::Ice::RemoteLoggerPrx>& iceP_prx, const ::Ice::Context& context = Ice::noExplicitContext)
+    auto detachRemoteLoggerAsync(const ::std::shared_ptr<RemoteLoggerPrx>& prx, const Context& context = noExplicitContext)
         -> decltype(::std::declval<P<bool>>().get_future())
     {
-        return _makePromiseOutgoing<bool, P>(false, this, &Ice::LoggerAdminPrx::_iceI_detachRemoteLogger, iceP_prx, context);
+        return _makePromiseOutgoing<bool, P>(false, this, &LoggerAdminPrx::_iceI_detachRemoteLogger, prx, context);
     }
 
+    /**
+     * Detaches a RemoteLogger object from the local logger.
+     * @param prx A proxy to the remote logger.
+     * @param response The response callback.
+     * @param ex The exception callback.
+     * @param sent The sent callback.
+     * @param context The Context map to send with the invocation.
+     * @return A function that can be called to cancel the invocation locally.
+     */
     ::std::function<void()>
-    detachRemoteLoggerAsync(const ::std::shared_ptr<::Ice::RemoteLoggerPrx>& iceP_prx,
+    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 ::Ice::Context& context = Ice::noExplicitContext)
-    {
-        return _makeLamdaOutgoing<bool>(response, ex, sent, this, &Ice::LoggerAdminPrx::_iceI_detachRemoteLogger, iceP_prx, context);
-    }
-
-    ICE_MEMBER(ICE_API) void _iceI_detachRemoteLogger(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<bool>>&, const ::std::shared_ptr<::Ice::RemoteLoggerPrx>&, const ::Ice::Context&);
-
-    ::Ice::LogMessageSeq getLog(const ::Ice::LogMessageTypeSeq& iceP_messageTypes, const ::Ice::StringSeq& iceP_traceCategories, int iceP_messageMax, ::std::string& iceP_prefix, const ::Ice::Context& context = Ice::noExplicitContext)
-    {
-        auto result = _makePromiseOutgoing<::Ice::LoggerAdmin::GetLogResult>(true, this, &Ice::LoggerAdminPrx::_iceI_getLog, iceP_messageTypes, iceP_traceCategories, iceP_messageMax, context).get();
-        iceP_prefix = ::std::move(result.prefix);
-        return ::std::move(result.returnValue);
-    }
-
+                            const Context& context = noExplicitContext)
+    {
+        return _makeLamdaOutgoing<bool>(std::move(response), std::move(ex), std::move(sent), this, &Ice::LoggerAdminPrx::_iceI_detachRemoteLogger, prx, context);
+    }
+
+    /// \cond INTERNAL
+    ICE_MEMBER(ICE_API) void _iceI_detachRemoteLogger(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<bool>>&, const ::std::shared_ptr<RemoteLoggerPrx>&, const Context&);
+    /// \endcond
+
+    /**
+     * Retrieves log messages recently logged.
+     * @param messageTypes The list of message types that the caller wishes to receive.
+     * An empty list means no filtering (send all message types).
+     * @param traceCategories The categories of traces that caller wish to receive.
+     * This parameter is ignored if messageTypes is not empty and does not include trace.
+     * An empty list means no filtering (send all trace categories).
+     * @param messageMax The maximum number of log messages (of all types) to be returned.
+     * A negative value requests all messages available.
+     * @param prefix The prefix of the associated local logger.
+     * @param context The Context map to send with the invocation.
+     * @return The Log messages.
+     */
+    LogMessageSeq getLog(const LogMessageTypeSeq& messageTypes, const StringSeq& traceCategories, int messageMax, ::std::string& prefix, const Context& context = noExplicitContext)
+    {
+        auto _result = _makePromiseOutgoing<LoggerAdmin::GetLogResult>(true, this, &LoggerAdminPrx::_iceI_getLog, messageTypes, traceCategories, messageMax, context).get();
+        prefix = ::std::move(_result.prefix);
+        return ::std::move(_result.returnValue);
+    }
+
+    /**
+     * Retrieves log messages recently logged.
+     * @param messageTypes The list of message types that the caller wishes to receive.
+     * An empty list means no filtering (send all message types).
+     * @param traceCategories The categories of traces that caller wish to receive.
+     * This parameter is ignored if messageTypes is not empty and does not include trace.
+     * An empty list means no filtering (send all trace categories).
+     * @param messageMax The maximum number of log messages (of all types) to be returned.
+     * A negative value requests all messages available.
+     * @param context The Context map to send with the invocation.
+     * @return The future object for the invocation.
+     */
     template<template<typename> class P = ::std::promise>
-    auto getLogAsync(const ::Ice::LogMessageTypeSeq& iceP_messageTypes, const ::Ice::StringSeq& iceP_traceCategories, int iceP_messageMax, const ::Ice::Context& context = Ice::noExplicitContext)
-        -> decltype(::std::declval<P<::Ice::LoggerAdmin::GetLogResult>>().get_future())
-    {
-        return _makePromiseOutgoing<::Ice::LoggerAdmin::GetLogResult, P>(false, this, &Ice::LoggerAdminPrx::_iceI_getLog, iceP_messageTypes, iceP_traceCategories, iceP_messageMax, context);
-    }
-
+    auto getLogAsync(const LogMessageTypeSeq& messageTypes, const StringSeq& traceCategories, int messageMax, const Context& context = noExplicitContext)
+        -> decltype(::std::declval<P<LoggerAdmin::GetLogResult>>().get_future())
+    {
+        return _makePromiseOutgoing<LoggerAdmin::GetLogResult, P>(false, this, &LoggerAdminPrx::_iceI_getLog, messageTypes, traceCategories, messageMax, context);
+    }
+
+    /**
+     * Retrieves log messages recently logged.
+     * @param messageTypes The list of message types that the caller wishes to receive.
+     * An empty list means no filtering (send all message types).
+     * @param traceCategories The categories of traces that caller wish to receive.
+     * This parameter is ignored if messageTypes is not empty and does not include trace.
+     * An empty list means no filtering (send all trace categories).
+     * @param messageMax The maximum number of log messages (of all types) to be returned.
+     * A negative value requests all messages available.
+     * @param response The response callback.
+     * @param ex The exception callback.
+     * @param sent The sent callback.
+     * @param context The Context map to send with the invocation.
+     * @return A function that can be called to cancel the invocation locally.
+     */
     ::std::function<void()>
-    getLogAsync(const ::Ice::LogMessageTypeSeq& iceP_messageTypes, const ::Ice::StringSeq& iceP_traceCategories, int iceP_messageMax,
+    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 ::Ice::Context& context = Ice::noExplicitContext)
+                const Context& context = noExplicitContext)
     {
-        auto responseCb = [response](::Ice::LoggerAdmin::GetLogResult&& result)
+        auto _responseCb = [response](LoggerAdmin::GetLogResult&& _result)
         {
-            response(::std::move(result.returnValue), ::std::move(result.prefix));
+            response(::std::move(_result.returnValue), ::std::move(_result.prefix));
         };
-        return _makeLamdaOutgoing<::Ice::LoggerAdmin::GetLogResult>(responseCb, ex, sent, this, &Ice::LoggerAdminPrx::_iceI_getLog, iceP_messageTypes, iceP_traceCategories, iceP_messageMax, context);
+        return _makeLamdaOutgoing<LoggerAdmin::GetLogResult>(std::move(_responseCb), std::move(ex), std::move(sent), this, &Ice::LoggerAdminPrx::_iceI_getLog, messageTypes, traceCategories, messageMax, context);
     }
 
-    ICE_MEMBER(ICE_API) void _iceI_getLog(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::Ice::LoggerAdmin::GetLogResult>>&, const ::Ice::LogMessageTypeSeq&, const ::Ice::StringSeq&, int, const ::Ice::Context&);
+    /// \cond INTERNAL
+    ICE_MEMBER(ICE_API) void _iceI_getLog(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<LoggerAdmin::GetLogResult>>&, const LogMessageTypeSeq&, const StringSeq&, int, const Context&);
+    /// \endcond
 
+    /**
+     * Obtains the Slice type ID of this interface.
+     * @return The fully-scoped type ID.
+     */
     ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
 
 protected:
 
+    /// \cond INTERNAL
     LoggerAdminPrx() = default;
     friend ::std::shared_ptr<LoggerAdminPrx> IceInternal::createProxy<LoggerAdminPrx>();
 
-    ICE_MEMBER(ICE_API) virtual ::std::shared_ptr<::Ice::ObjectPrx> _newInstance() const override;
+    ICE_MEMBER(ICE_API) virtual ::std::shared_ptr<ObjectPrx> _newInstance() const override;
+    /// \endcond
 };
 
 }
 
+/// \cond STREAM
 namespace Ice
 {
 
@@ -379,7 +734,9 @@ struct StreamReader<::Ice::LogMessage, S>
 };
 
 }
+/// \endcond
 
+/// \cond INTERNAL
 namespace Ice
 {
 
@@ -390,6 +747,7 @@ using LoggerAdminPtr = ::std::shared_ptr<LoggerAdmin>;
 using LoggerAdminPrxPtr = ::std::shared_ptr<LoggerAdminPrx>;
 
 }
+/// \endcond
 
 #else // C++98 mapping
 
@@ -400,12 +758,16 @@ namespace Ice
 {
 
 class RemoteLogger;
-ICE_API void _readProxy(::Ice::InputStream*, ::IceInternal::ProxyHandle< ::IceProxy::Ice::RemoteLogger>&);
-ICE_API ::IceProxy::Ice::Object* upCast(::IceProxy::Ice::RemoteLogger*);
+/// \cond INTERNAL
+ICE_API void _readProxy(::Ice::InputStream*, ::IceInternal::ProxyHandle< RemoteLogger>&);
+ICE_API ::IceProxy::Ice::Object* upCast(RemoteLogger*);
+/// \endcond
 
 class LoggerAdmin;
-ICE_API void _readProxy(::Ice::InputStream*, ::IceInternal::ProxyHandle< ::IceProxy::Ice::LoggerAdmin>&);
-ICE_API ::IceProxy::Ice::Object* upCast(::IceProxy::Ice::LoggerAdmin*);
+/// \cond INTERNAL
+ICE_API void _readProxy(::Ice::InputStream*, ::IceInternal::ProxyHandle< LoggerAdmin>&);
+ICE_API ::IceProxy::Ice::Object* upCast(LoggerAdmin*);
+/// \endcond
 
 }
 
@@ -415,39 +777,83 @@ namespace Ice
 {
 
 class RemoteLogger;
-ICE_API ::Ice::Object* upCast(::Ice::RemoteLogger*);
-typedef ::IceInternal::Handle< ::Ice::RemoteLogger> RemoteLoggerPtr;
+/// \cond INTERNAL
+ICE_API Object* upCast(RemoteLogger*);
+/// \endcond
+typedef ::IceInternal::Handle< RemoteLogger> RemoteLoggerPtr;
 typedef ::IceInternal::ProxyHandle< ::IceProxy::Ice::RemoteLogger> RemoteLoggerPrx;
 typedef RemoteLoggerPrx RemoteLoggerPrxPtr;
-ICE_API void _icePatchObjectPtr(RemoteLoggerPtr&, const ::Ice::ObjectPtr&);
+/// \cond INTERNAL
+ICE_API void _icePatchObjectPtr(RemoteLoggerPtr&, const ObjectPtr&);
+/// \endcond
 
 class LoggerAdmin;
-ICE_API ::Ice::Object* upCast(::Ice::LoggerAdmin*);
-typedef ::IceInternal::Handle< ::Ice::LoggerAdmin> LoggerAdminPtr;
+/// \cond INTERNAL
+ICE_API Object* upCast(LoggerAdmin*);
+/// \endcond
+typedef ::IceInternal::Handle< LoggerAdmin> LoggerAdminPtr;
 typedef ::IceInternal::ProxyHandle< ::IceProxy::Ice::LoggerAdmin> LoggerAdminPrx;
 typedef LoggerAdminPrx LoggerAdminPrxPtr;
-ICE_API void _icePatchObjectPtr(LoggerAdminPtr&, const ::Ice::ObjectPtr&);
+/// \cond INTERNAL
+ICE_API void _icePatchObjectPtr(LoggerAdminPtr&, const ObjectPtr&);
+/// \endcond
 
 }
 
 namespace Ice
 {
 
+/**
+ * An enumeration representing the different types of log messages.
+ */
 enum LogMessageType
 {
+    /**
+     * The {@link Logger} received a print message.
+     */
     PrintMessage,
+    /**
+     * The {@link Logger} received a trace message.
+     */
     TraceMessage,
+    /**
+     * The {@link Logger} received a warning message.
+     */
     WarningMessage,
+    /**
+     * The {@link Logger} received an error message.
+     */
     ErrorMessage
 };
 
-typedef ::std::vector< ::Ice::LogMessageType> LogMessageTypeSeq;
+/**
+ * A sequence of {@link LogMessageType}
+ */
+typedef ::std::vector<LogMessageType> LogMessageTypeSeq;
 
+/**
+ * A complete log message.
+ * \headerfile Ice/Ice.h
+ */
 struct LogMessage
 {
+    /**
+     * The type of message sent to the {@link Logger}.
+     */
     ::Ice::LogMessageType type;
+    /**
+     * The date and time when the {@link Logger} received this message, expressed
+     * as the number of microseconds since the Unix Epoch (00:00:00 UTC on 1 January 1970)
+     */
     ::Ice::Long timestamp;
+    /**
+     * For a message of type trace, the trace category of this log message;
+     * otherwise, the empty string.
+     */
     ::std::string traceCategory;
+    /**
+     * The log message itself.
+     */
     ::std::string message;
 
     bool operator==(const LogMessage& rhs_) const
@@ -534,44 +940,91 @@ struct LogMessage
     }
 };
 
+/**
+ * A sequence of {@link LogMessage}.
+ */
 typedef std::list<LogMessage> LogMessageSeq;
 
-class ICE_API RemoteLoggerAlreadyAttachedException : public ::Ice::UserException
+/**
+ * Thrown when the provided RemoteLogger was previously attached to a LoggerAdmin.
+ * \headerfile Ice/Ice.h
+ */
+class ICE_API RemoteLoggerAlreadyAttachedException : public UserException
 {
 public:
 
     RemoteLoggerAlreadyAttachedException() {}
     virtual ~RemoteLoggerAlreadyAttachedException() throw();
 
+    /**
+     * Obtains the Slice type ID of this exception.
+     * @return The fully-scoped type ID.
+     */
     virtual ::std::string ice_id() const;
+    /**
+     * Polymporphically clones this exception.
+     * @return A shallow copy of this exception.
+     */
     virtual RemoteLoggerAlreadyAttachedException* ice_clone() const;
+    /**
+     * Throws this exception.
+     */
     virtual void ice_throw() const;
 
 protected:
 
-    virtual void _writeImpl(::Ice::OutputStream*) const;
-    virtual void _readImpl(::Ice::InputStream*);
+    /// \cond STREAM
+    virtual void _writeImpl(OutputStream*) const;
+    virtual void _readImpl(InputStream*);
+    /// \endcond
 };
 
+/// \cond INTERNAL
 static RemoteLoggerAlreadyAttachedException _iceS_RemoteLoggerAlreadyAttachedException_init;
+/// \endcond
 
 }
 
 namespace Ice
 {
 
+/**
+ * Base class for asynchronous callback wrapper classes used for calls to
+ * IceProxy::Ice::RemoteLogger::begin_init.
+ * Create a wrapper instance by calling ::Ice::newCallback_RemoteLogger_init.
+ */
 class Callback_RemoteLogger_init_Base : public virtual ::IceInternal::CallbackBase { };
 typedef ::IceUtil::Handle< Callback_RemoteLogger_init_Base> Callback_RemoteLogger_initPtr;
 
+/**
+ * Base class for asynchronous callback wrapper classes used for calls to
+ * IceProxy::Ice::RemoteLogger::begin_log.
+ * Create a wrapper instance by calling ::Ice::newCallback_RemoteLogger_log.
+ */
 class Callback_RemoteLogger_log_Base : public virtual ::IceInternal::CallbackBase { };
 typedef ::IceUtil::Handle< Callback_RemoteLogger_log_Base> Callback_RemoteLogger_logPtr;
 
+/**
+ * Base class for asynchronous callback wrapper classes used for calls to
+ * IceProxy::Ice::LoggerAdmin::begin_attachRemoteLogger.
+ * Create a wrapper instance by calling ::Ice::newCallback_LoggerAdmin_attachRemoteLogger.
+ */
 class Callback_LoggerAdmin_attachRemoteLogger_Base : public virtual ::IceInternal::CallbackBase { };
 typedef ::IceUtil::Handle< Callback_LoggerAdmin_attachRemoteLogger_Base> Callback_LoggerAdmin_attachRemoteLoggerPtr;
 
+/**
+ * Base class for asynchronous callback wrapper classes used for calls to
+ * IceProxy::Ice::LoggerAdmin::begin_detachRemoteLogger.
+ * Create a wrapper instance by calling ::Ice::newCallback_LoggerAdmin_detachRemoteLogger.
+ */
 class Callback_LoggerAdmin_detachRemoteLogger_Base : public virtual ::IceInternal::CallbackBase { };
 typedef ::IceUtil::Handle< Callback_LoggerAdmin_detachRemoteLogger_Base> Callback_LoggerAdmin_detachRemoteLoggerPtr;
 
+/**
+ * Base class for asynchronous callback wrapper classes used for calls to
+ * IceProxy::Ice::LoggerAdmin::begin_getLog.
+ * Create a wrapper instance by calling ::Ice::newCallback_LoggerAdmin_getLog.
+ */
 class Callback_LoggerAdmin_getLog_Base : public virtual ::IceInternal::CallbackBase { };
 typedef ::IceUtil::Handle< Callback_LoggerAdmin_getLog_Base> Callback_LoggerAdmin_getLogPtr;
 
@@ -587,37 +1040,88 @@ class ICE_CLASS(ICE_API) RemoteLogger : public virtual ::Ice::Proxy<RemoteLogger
 {
 public:
 
-    ICE_MEMBER(ICE_API) void init(const ::std::string& iceP_prefix, const ::Ice::LogMessageSeq& iceP_logMessages, const ::Ice::Context& context = ::Ice::noExplicitContext)
-    {
-        end_init(_iceI_begin_init(iceP_prefix, iceP_logMessages, context, ::IceInternal::dummyCallback, 0, true));
-    }
-
-    ::Ice::AsyncResultPtr begin_init(const ::std::string& iceP_prefix, const ::Ice::LogMessageSeq& iceP_logMessages, const ::Ice::Context& context = ::Ice::noExplicitContext)
-    {
-        return _iceI_begin_init(iceP_prefix, iceP_logMessages, context, ::IceInternal::dummyCallback, 0);
-    }
-
-    ::Ice::AsyncResultPtr begin_init(const ::std::string& iceP_prefix, const ::Ice::LogMessageSeq& iceP_logMessages, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
-    {
-        return _iceI_begin_init(iceP_prefix, iceP_logMessages, ::Ice::noExplicitContext, del, cookie);
-    }
-
-    ::Ice::AsyncResultPtr begin_init(const ::std::string& iceP_prefix, const ::Ice::LogMessageSeq& iceP_logMessages, const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
-    {
-        return _iceI_begin_init(iceP_prefix, iceP_logMessages, context, del, cookie);
-    }
-
-    ::Ice::AsyncResultPtr begin_init(const ::std::string& iceP_prefix, const ::Ice::LogMessageSeq& iceP_logMessages, const ::Ice::Callback_RemoteLogger_initPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
-    {
-        return _iceI_begin_init(iceP_prefix, iceP_logMessages, ::Ice::noExplicitContext, del, cookie);
-    }
-
-    ::Ice::AsyncResultPtr begin_init(const ::std::string& iceP_prefix, const ::Ice::LogMessageSeq& iceP_logMessages, const ::Ice::Context& context, const ::Ice::Callback_RemoteLogger_initPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
-    {
-        return _iceI_begin_init(iceP_prefix, iceP_logMessages, context, del, cookie);
-    }
-
-    ICE_MEMBER(ICE_API) void end_init(const ::Ice::AsyncResultPtr&);
+    /**
+     * init is called by attachRemoteLogger when a RemoteLogger proxy is attached.
+     * @param prefix The prefix of the associated local Logger.
+     * @param logMessages Old log messages generated before "now".
+     * @param context The Context map to send with the invocation.
+     */
+    ICE_MEMBER(ICE_API) void init(const ::std::string& prefix, const ::Ice::LogMessageSeq& logMessages, const ::Ice::Context& context = ::Ice::noExplicitContext)
+    {
+        end_init(_iceI_begin_init(prefix, logMessages, context, ::IceInternal::dummyCallback, 0, true));
+    }
+
+    /**
+     * init is called by attachRemoteLogger when a RemoteLogger proxy is attached.
+     * @param prefix The prefix of the associated local Logger.
+     * @param logMessages Old log messages generated before "now".
+     * @param context The Context map to send with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_init(const ::std::string& prefix, const ::Ice::LogMessageSeq& logMessages, const ::Ice::Context& context = ::Ice::noExplicitContext)
+    {
+        return _iceI_begin_init(prefix, logMessages, context, ::IceInternal::dummyCallback, 0);
+    }
+
+    /**
+     * init is called by attachRemoteLogger when a RemoteLogger proxy is attached.
+     * @param prefix The prefix of the associated local Logger.
+     * @param logMessages Old log messages generated before "now".
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_init(const ::std::string& prefix, const ::Ice::LogMessageSeq& logMessages, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
+    {
+        return _iceI_begin_init(prefix, logMessages, ::Ice::noExplicitContext, cb, cookie);
+    }
+
+    /**
+     * init is called by attachRemoteLogger when a RemoteLogger proxy is attached.
+     * @param prefix The prefix of the associated local Logger.
+     * @param logMessages Old log messages generated before "now".
+     * @param context The Context map to send with the invocation.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::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)
+    {
+        return _iceI_begin_init(prefix, logMessages, context, cb, cookie);
+    }
+
+    /**
+     * init is called by attachRemoteLogger when a RemoteLogger proxy is attached.
+     * @param prefix The prefix of the associated local Logger.
+     * @param logMessages Old log messages generated before "now".
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_init(const ::std::string& prefix, const ::Ice::LogMessageSeq& logMessages, const ::Ice::Callback_RemoteLogger_initPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
+    {
+        return _iceI_begin_init(prefix, logMessages, ::Ice::noExplicitContext, cb, cookie);
+    }
+
+    /**
+     * init is called by attachRemoteLogger when a RemoteLogger proxy is attached.
+     * @param prefix The prefix of the associated local Logger.
+     * @param logMessages Old log messages generated before "now".
+     * @param context The Context map to send with the invocation.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::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)
+    {
+        return _iceI_begin_init(prefix, logMessages, context, cb, cookie);
+    }
+
+    /**
+     * Completes an invocation of begin_init.
+     * @param result The asynchronous result object for the invocation.
+     */
+    ICE_MEMBER(ICE_API) void end_init(const ::Ice::AsyncResultPtr& result);
 
 private:
 
@@ -625,37 +1129,82 @@ private:
 
 public:
 
-    ICE_MEMBER(ICE_API) void log(const ::Ice::LogMessage& iceP_message, const ::Ice::Context& context = ::Ice::noExplicitContext)
+    /**
+     * Log a LogMessage. Note that log may be called by LoggerAdmin before init.
+     * @param message The message to log.
+     * @param context The Context map to send with the invocation.
+     */
+    ICE_MEMBER(ICE_API) void log(const ::Ice::LogMessage& message, const ::Ice::Context& context = ::Ice::noExplicitContext)
     {
-        end_log(_iceI_begin_log(iceP_message, context, ::IceInternal::dummyCallback, 0, true));
+        end_log(_iceI_begin_log(message, context, ::IceInternal::dummyCallback, 0, true));
     }
 
-    ::Ice::AsyncResultPtr begin_log(const ::Ice::LogMessage& iceP_message, const ::Ice::Context& context = ::Ice::noExplicitContext)
+    /**
+     * Log a LogMessage. Note that log may be called by LoggerAdmin before init.
+     * @param message The message to log.
+     * @param context The Context map to send with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_log(const ::Ice::LogMessage& message, const ::Ice::Context& context = ::Ice::noExplicitContext)
     {
-        return _iceI_begin_log(iceP_message, context, ::IceInternal::dummyCallback, 0);
+        return _iceI_begin_log(message, context, ::IceInternal::dummyCallback, 0);
     }
 
-    ::Ice::AsyncResultPtr begin_log(const ::Ice::LogMessage& iceP_message, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
+    /**
+     * Log a LogMessage. Note that log may be called by LoggerAdmin before init.
+     * @param message The message to log.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_log(const ::Ice::LogMessage& message, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_log(iceP_message, ::Ice::noExplicitContext, del, cookie);
+        return _iceI_begin_log(message, ::Ice::noExplicitContext, cb, cookie);
     }
 
-    ::Ice::AsyncResultPtr begin_log(const ::Ice::LogMessage& iceP_message, const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
+    /**
+     * Log a LogMessage. Note that log may be called by LoggerAdmin before init.
+     * @param message The message to log.
+     * @param context The Context map to send with the invocation.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_log(const ::Ice::LogMessage& message, const ::Ice::Context& context, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_log(iceP_message, context, del, cookie);
+        return _iceI_begin_log(message, context, cb, cookie);
     }
 
-    ::Ice::AsyncResultPtr begin_log(const ::Ice::LogMessage& iceP_message, const ::Ice::Callback_RemoteLogger_logPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
+    /**
+     * Log a LogMessage. Note that log may be called by LoggerAdmin before init.
+     * @param message The message to log.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_log(const ::Ice::LogMessage& message, const ::Ice::Callback_RemoteLogger_logPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_log(iceP_message, ::Ice::noExplicitContext, del, cookie);
+        return _iceI_begin_log(message, ::Ice::noExplicitContext, cb, cookie);
     }
 
-    ::Ice::AsyncResultPtr begin_log(const ::Ice::LogMessage& iceP_message, const ::Ice::Context& context, const ::Ice::Callback_RemoteLogger_logPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
+    /**
+     * Log a LogMessage. Note that log may be called by LoggerAdmin before init.
+     * @param message The message to log.
+     * @param context The Context map to send with the invocation.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_log(const ::Ice::LogMessage& message, const ::Ice::Context& context, const ::Ice::Callback_RemoteLogger_logPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_log(iceP_message, context, del, cookie);
+        return _iceI_begin_log(message, context, cb, cookie);
     }
 
-    ICE_MEMBER(ICE_API) void end_log(const ::Ice::AsyncResultPtr&);
+    /**
+     * Completes an invocation of begin_log.
+     * @param result The asynchronous result object for the invocation.
+     */
+    ICE_MEMBER(ICE_API) void end_log(const ::Ice::AsyncResultPtr& result);
 
 private:
 
@@ -663,48 +1212,151 @@ private:
 
 public:
 
+    /**
+     * Obtains the Slice type ID corresponding to this interface.
+     * @return A fully-scoped type ID.
+     */
     ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
 
 protected:
+    /// \cond INTERNAL
 
     ICE_MEMBER(ICE_API) virtual ::IceProxy::Ice::Object* _newInstance() const;
+    /// \endcond
 };
 
 class ICE_CLASS(ICE_API) LoggerAdmin : public virtual ::Ice::Proxy<LoggerAdmin, ::IceProxy::Ice::Object>
 {
 public:
 
-    ICE_MEMBER(ICE_API) void attachRemoteLogger(const ::Ice::RemoteLoggerPrx& iceP_prx, const ::Ice::LogMessageTypeSeq& iceP_messageTypes, const ::Ice::StringSeq& iceP_traceCategories, ::Ice::Int iceP_messageMax, const ::Ice::Context& context = ::Ice::noExplicitContext)
-    {
-        end_attachRemoteLogger(_iceI_begin_attachRemoteLogger(iceP_prx, iceP_messageTypes, iceP_traceCategories, iceP_messageMax, context, ::IceInternal::dummyCallback, 0, true));
-    }
-
-    ::Ice::AsyncResultPtr begin_attachRemoteLogger(const ::Ice::RemoteLoggerPrx& iceP_prx, const ::Ice::LogMessageTypeSeq& iceP_messageTypes, const ::Ice::StringSeq& iceP_traceCategories, ::Ice::Int iceP_messageMax, const ::Ice::Context& context = ::Ice::noExplicitContext)
-    {
-        return _iceI_begin_attachRemoteLogger(iceP_prx, iceP_messageTypes, iceP_traceCategories, iceP_messageMax, context, ::IceInternal::dummyCallback, 0);
-    }
-
-    ::Ice::AsyncResultPtr begin_attachRemoteLogger(const ::Ice::RemoteLoggerPrx& iceP_prx, const ::Ice::LogMessageTypeSeq& iceP_messageTypes, const ::Ice::StringSeq& iceP_traceCategories, ::Ice::Int iceP_messageMax, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
-    {
-        return _iceI_begin_attachRemoteLogger(iceP_prx, iceP_messageTypes, iceP_traceCategories, iceP_messageMax, ::Ice::noExplicitContext, del, cookie);
-    }
-
-    ::Ice::AsyncResultPtr begin_attachRemoteLogger(const ::Ice::RemoteLoggerPrx& iceP_prx, const ::Ice::LogMessageTypeSeq& iceP_messageTypes, const ::Ice::StringSeq& iceP_traceCategories, ::Ice::Int iceP_messageMax, const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
-    {
-        return _iceI_begin_attachRemoteLogger(iceP_prx, iceP_messageTypes, iceP_traceCategories, iceP_messageMax, context, del, cookie);
-    }
-
-    ::Ice::AsyncResultPtr begin_attachRemoteLogger(const ::Ice::RemoteLoggerPrx& iceP_prx, const ::Ice::LogMessageTypeSeq& iceP_messageTypes, const ::Ice::StringSeq& iceP_traceCategories, ::Ice::Int iceP_messageMax, const ::Ice::Callback_LoggerAdmin_attachRemoteLoggerPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
-    {
-        return _iceI_begin_attachRemoteLogger(iceP_prx, iceP_messageTypes, iceP_traceCategories, iceP_messageMax, ::Ice::noExplicitContext, del, cookie);
-    }
-
-    ::Ice::AsyncResultPtr begin_attachRemoteLogger(const ::Ice::RemoteLoggerPrx& iceP_prx, const ::Ice::LogMessageTypeSeq& iceP_messageTypes, const ::Ice::StringSeq& iceP_traceCategories, ::Ice::Int iceP_messageMax, const ::Ice::Context& context, const ::Ice::Callback_LoggerAdmin_attachRemoteLoggerPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
-    {
-        return _iceI_begin_attachRemoteLogger(iceP_prx, iceP_messageTypes, iceP_traceCategories, iceP_messageMax, context, del, cookie);
-    }
-
-    ICE_MEMBER(ICE_API) void end_attachRemoteLogger(const ::Ice::AsyncResultPtr&);
+    /**
+     * Attaches a RemoteLogger object to the local logger.
+     * attachRemoteLogger calls init on the provided RemoteLogger proxy.
+     * @param prx A proxy to the remote logger.
+     * @param messageTypes The list of message types that the remote logger wishes to receive.
+     * An empty list means no filtering (send all message types).
+     * @param traceCategories The categories of traces that the remote logger wishes to receive.
+     * This parameter is ignored if messageTypes is not empty and does not include trace.
+     * An empty list means no filtering (send all trace categories).
+     * @param messageMax The maximum number of log messages (of all types) to be provided
+     * to init. A negative value requests all messages available.
+     * @param context The Context map to send with the invocation.
+     * @throws Ice::RemoteLoggerAlreadyAttachedException Raised if this remote logger is already
+     * attached to this admin object.
+     */
+    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)
+    {
+        end_attachRemoteLogger(_iceI_begin_attachRemoteLogger(prx, messageTypes, traceCategories, messageMax, context, ::IceInternal::dummyCallback, 0, true));
+    }
+
+    /**
+     * Attaches a RemoteLogger object to the local logger.
+     * attachRemoteLogger calls init on the provided RemoteLogger proxy.
+     * @param prx A proxy to the remote logger.
+     * @param messageTypes The list of message types that the remote logger wishes to receive.
+     * An empty list means no filtering (send all message types).
+     * @param traceCategories The categories of traces that the remote logger wishes to receive.
+     * This parameter is ignored if messageTypes is not empty and does not include trace.
+     * An empty list means no filtering (send all trace categories).
+     * @param messageMax The maximum number of log messages (of all types) to be provided
+     * to init. A negative value requests all messages available.
+     * @param context The Context map to send with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::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)
+    {
+        return _iceI_begin_attachRemoteLogger(prx, messageTypes, traceCategories, messageMax, context, ::IceInternal::dummyCallback, 0);
+    }
+
+    /**
+     * Attaches a RemoteLogger object to the local logger.
+     * attachRemoteLogger calls init on the provided RemoteLogger proxy.
+     * @param prx A proxy to the remote logger.
+     * @param messageTypes The list of message types that the remote logger wishes to receive.
+     * An empty list means no filtering (send all message types).
+     * @param traceCategories The categories of traces that the remote logger wishes to receive.
+     * This parameter is ignored if messageTypes is not empty and does not include trace.
+     * An empty list means no filtering (send all trace categories).
+     * @param messageMax The maximum number of log messages (of all types) to be provided
+     * to init. A negative value requests all messages available.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::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)
+    {
+        return _iceI_begin_attachRemoteLogger(prx, messageTypes, traceCategories, messageMax, ::Ice::noExplicitContext, cb, cookie);
+    }
+
+    /**
+     * Attaches a RemoteLogger object to the local logger.
+     * attachRemoteLogger calls init on the provided RemoteLogger proxy.
+     * @param prx A proxy to the remote logger.
+     * @param messageTypes The list of message types that the remote logger wishes to receive.
+     * An empty list means no filtering (send all message types).
+     * @param traceCategories The categories of traces that the remote logger wishes to receive.
+     * This parameter is ignored if messageTypes is not empty and does not include trace.
+     * An empty list means no filtering (send all trace categories).
+     * @param messageMax The maximum number of log messages (of all types) to be provided
+     * to init. A negative value requests all messages available.
+     * @param context The Context map to send with the invocation.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::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)
+    {
+        return _iceI_begin_attachRemoteLogger(prx, messageTypes, traceCategories, messageMax, context, cb, cookie);
+    }
+
+    /**
+     * Attaches a RemoteLogger object to the local logger.
+     * attachRemoteLogger calls init on the provided RemoteLogger proxy.
+     * @param prx A proxy to the remote logger.
+     * @param messageTypes The list of message types that the remote logger wishes to receive.
+     * An empty list means no filtering (send all message types).
+     * @param traceCategories The categories of traces that the remote logger wishes to receive.
+     * This parameter is ignored if messageTypes is not empty and does not include trace.
+     * An empty list means no filtering (send all trace categories).
+     * @param messageMax The maximum number of log messages (of all types) to be provided
+     * to init. A negative value requests all messages available.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::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)
+    {
+        return _iceI_begin_attachRemoteLogger(prx, messageTypes, traceCategories, messageMax, ::Ice::noExplicitContext, cb, cookie);
+    }
+
+    /**
+     * Attaches a RemoteLogger object to the local logger.
+     * attachRemoteLogger calls init on the provided RemoteLogger proxy.
+     * @param prx A proxy to the remote logger.
+     * @param messageTypes The list of message types that the remote logger wishes to receive.
+     * An empty list means no filtering (send all message types).
+     * @param traceCategories The categories of traces that the remote logger wishes to receive.
+     * This parameter is ignored if messageTypes is not empty and does not include trace.
+     * An empty list means no filtering (send all trace categories).
+     * @param messageMax The maximum number of log messages (of all types) to be provided
+     * to init. A negative value requests all messages available.
+     * @param context The Context map to send with the invocation.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::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)
+    {
+        return _iceI_begin_attachRemoteLogger(prx, messageTypes, traceCategories, messageMax, context, cb, cookie);
+    }
+
+    /**
+     * Completes an invocation of begin_attachRemoteLogger.
+     * @param result The asynchronous result object for the invocation.
+     * @throws Ice::RemoteLoggerAlreadyAttachedException Raised if this remote logger is already
+     * attached to this admin object.
+     */
+    ICE_MEMBER(ICE_API) void end_attachRemoteLogger(const ::Ice::AsyncResultPtr& result);
 
 private:
 
@@ -712,37 +1364,84 @@ private:
 
 public:
 
-    ICE_MEMBER(ICE_API) bool detachRemoteLogger(const ::Ice::RemoteLoggerPrx& iceP_prx, const ::Ice::Context& context = ::Ice::noExplicitContext)
+    /**
+     * Detaches a RemoteLogger object from the local logger.
+     * @param prx A proxy to the remote logger.
+     * @param context The Context map to send with the invocation.
+     * @return True if the provided remote logger proxy was detached, and false otherwise.
+     */
+    ICE_MEMBER(ICE_API) bool detachRemoteLogger(const ::Ice::RemoteLoggerPrx& prx, const ::Ice::Context& context = ::Ice::noExplicitContext)
     {
-        return end_detachRemoteLogger(_iceI_begin_detachRemoteLogger(iceP_prx, context, ::IceInternal::dummyCallback, 0, true));
+        return end_detachRemoteLogger(_iceI_begin_detachRemoteLogger(prx, context, ::IceInternal::dummyCallback, 0, true));
     }
 
-    ::Ice::AsyncResultPtr begin_detachRemoteLogger(const ::Ice::RemoteLoggerPrx& iceP_prx, const ::Ice::Context& context = ::Ice::noExplicitContext)
+    /**
+     * Detaches a RemoteLogger object from the local logger.
+     * @param prx A proxy to the remote logger.
+     * @param context The Context map to send with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_detachRemoteLogger(const ::Ice::RemoteLoggerPrx& prx, const ::Ice::Context& context = ::Ice::noExplicitContext)
     {
-        return _iceI_begin_detachRemoteLogger(iceP_prx, context, ::IceInternal::dummyCallback, 0);
+        return _iceI_begin_detachRemoteLogger(prx, context, ::IceInternal::dummyCallback, 0);
     }
 
-    ::Ice::AsyncResultPtr begin_detachRemoteLogger(const ::Ice::RemoteLoggerPrx& iceP_prx, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
+    /**
+     * Detaches a RemoteLogger object from the local logger.
+     * @param prx A proxy to the remote logger.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_detachRemoteLogger(const ::Ice::RemoteLoggerPrx& prx, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_detachRemoteLogger(iceP_prx, ::Ice::noExplicitContext, del, cookie);
+        return _iceI_begin_detachRemoteLogger(prx, ::Ice::noExplicitContext, cb, cookie);
     }
 
-    ::Ice::AsyncResultPtr begin_detachRemoteLogger(const ::Ice::RemoteLoggerPrx& iceP_prx, const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
+    /**
+     * Detaches a RemoteLogger object from the local logger.
+     * @param prx A proxy to the remote logger.
+     * @param context The Context map to send with the invocation.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_detachRemoteLogger(const ::Ice::RemoteLoggerPrx& prx, const ::Ice::Context& context, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_detachRemoteLogger(iceP_prx, context, del, cookie);
+        return _iceI_begin_detachRemoteLogger(prx, context, cb, cookie);
     }
 
-    ::Ice::AsyncResultPtr begin_detachRemoteLogger(const ::Ice::RemoteLoggerPrx& iceP_prx, const ::Ice::Callback_LoggerAdmin_detachRemoteLoggerPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
+    /**
+     * Detaches a RemoteLogger object from the local logger.
+     * @param prx A proxy to the remote logger.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_detachRemoteLogger(const ::Ice::RemoteLoggerPrx& prx, const ::Ice::Callback_LoggerAdmin_detachRemoteLoggerPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_detachRemoteLogger(iceP_prx, ::Ice::noExplicitContext, del, cookie);
+        return _iceI_begin_detachRemoteLogger(prx, ::Ice::noExplicitContext, cb, cookie);
     }
 
-    ::Ice::AsyncResultPtr begin_detachRemoteLogger(const ::Ice::RemoteLoggerPrx& iceP_prx, const ::Ice::Context& context, const ::Ice::Callback_LoggerAdmin_detachRemoteLoggerPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
+    /**
+     * Detaches a RemoteLogger object from the local logger.
+     * @param prx A proxy to the remote logger.
+     * @param context The Context map to send with the invocation.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_detachRemoteLogger(const ::Ice::RemoteLoggerPrx& prx, const ::Ice::Context& context, const ::Ice::Callback_LoggerAdmin_detachRemoteLoggerPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_detachRemoteLogger(iceP_prx, context, del, cookie);
+        return _iceI_begin_detachRemoteLogger(prx, context, cb, cookie);
     }
 
-    ICE_MEMBER(ICE_API) bool end_detachRemoteLogger(const ::Ice::AsyncResultPtr&);
+    /**
+     * Completes an invocation of begin_detachRemoteLogger.
+     * @param result The asynchronous result object for the invocation.
+     * @return True if the provided remote logger proxy was detached, and false otherwise.
+     */
+    ICE_MEMBER(ICE_API) bool end_detachRemoteLogger(const ::Ice::AsyncResultPtr& result);
 
 private:
 
@@ -750,37 +1449,126 @@ private:
 
 public:
 
-    ICE_MEMBER(ICE_API) ::Ice::LogMessageSeq getLog(const ::Ice::LogMessageTypeSeq& iceP_messageTypes, const ::Ice::StringSeq& iceP_traceCategories, ::Ice::Int iceP_messageMax, ::std::string& iceP_prefix, const ::Ice::Context& context = ::Ice::noExplicitContext)
-    {
-        return end_getLog(iceP_prefix, _iceI_begin_getLog(iceP_messageTypes, iceP_traceCategories, iceP_messageMax, context, ::IceInternal::dummyCallback, 0, true));
-    }
-
-    ::Ice::AsyncResultPtr begin_getLog(const ::Ice::LogMessageTypeSeq& iceP_messageTypes, const ::Ice::StringSeq& iceP_traceCategories, ::Ice::Int iceP_messageMax, const ::Ice::Context& context = ::Ice::noExplicitContext)
-    {
-        return _iceI_begin_getLog(iceP_messageTypes, iceP_traceCategories, iceP_messageMax, context, ::IceInternal::dummyCallback, 0);
-    }
-
-    ::Ice::AsyncResultPtr begin_getLog(const ::Ice::LogMessageTypeSeq& iceP_messageTypes, const ::Ice::StringSeq& iceP_traceCategories, ::Ice::Int iceP_messageMax, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
-    {
-        return _iceI_begin_getLog(iceP_messageTypes, iceP_traceCategories, iceP_messageMax, ::Ice::noExplicitContext, del, cookie);
-    }
-
-    ::Ice::AsyncResultPtr begin_getLog(const ::Ice::LogMessageTypeSeq& iceP_messageTypes, const ::Ice::StringSeq& iceP_traceCategories, ::Ice::Int iceP_messageMax, const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
-    {
-        return _iceI_begin_getLog(iceP_messageTypes, iceP_traceCategories, iceP_messageMax, context, del, cookie);
-    }
-
-    ::Ice::AsyncResultPtr begin_getLog(const ::Ice::LogMessageTypeSeq& iceP_messageTypes, const ::Ice::StringSeq& iceP_traceCategories, ::Ice::Int iceP_messageMax, const ::Ice::Callback_LoggerAdmin_getLogPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
-    {
-        return _iceI_begin_getLog(iceP_messageTypes, iceP_traceCategories, iceP_messageMax, ::Ice::noExplicitContext, del, cookie);
-    }
-
-    ::Ice::AsyncResultPtr begin_getLog(const ::Ice::LogMessageTypeSeq& iceP_messageTypes, const ::Ice::StringSeq& iceP_traceCategories, ::Ice::Int iceP_messageMax, const ::Ice::Context& context, const ::Ice::Callback_LoggerAdmin_getLogPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
-    {
-        return _iceI_begin_getLog(iceP_messageTypes, iceP_traceCategories, iceP_messageMax, context, del, cookie);
-    }
-
-    ICE_MEMBER(ICE_API) ::Ice::LogMessageSeq end_getLog(::std::string& iceP_prefix, const ::Ice::AsyncResultPtr&);
+    /**
+     * Retrieves log messages recently logged.
+     * @param messageTypes The list of message types that the caller wishes to receive.
+     * An empty list means no filtering (send all message types).
+     * @param traceCategories The categories of traces that caller wish to receive.
+     * This parameter is ignored if messageTypes is not empty and does not include trace.
+     * An empty list means no filtering (send all trace categories).
+     * @param messageMax The maximum number of log messages (of all types) to be returned.
+     * A negative value requests all messages available.
+     * @param prefix The prefix of the associated local logger.
+     * @param context The Context map to send with the invocation.
+     * @return The Log messages.
+     */
+    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)
+    {
+        return end_getLog(prefix, _iceI_begin_getLog(messageTypes, traceCategories, messageMax, context, ::IceInternal::dummyCallback, 0, true));
+    }
+
+    /**
+     * Retrieves log messages recently logged.
+     * @param messageTypes The list of message types that the caller wishes to receive.
+     * An empty list means no filtering (send all message types).
+     * @param traceCategories The categories of traces that caller wish to receive.
+     * This parameter is ignored if messageTypes is not empty and does not include trace.
+     * An empty list means no filtering (send all trace categories).
+     * @param messageMax The maximum number of log messages (of all types) to be returned.
+     * A negative value requests all messages available.
+     * @param context The Context map to send with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_getLog(const ::Ice::LogMessageTypeSeq& messageTypes, const ::Ice::StringSeq& traceCategories, ::Ice::Int messageMax, const ::Ice::Context& context = ::Ice::noExplicitContext)
+    {
+        return _iceI_begin_getLog(messageTypes, traceCategories, messageMax, context, ::IceInternal::dummyCallback, 0);
+    }
+
+    /**
+     * Retrieves log messages recently logged.
+     * @param messageTypes The list of message types that the caller wishes to receive.
+     * An empty list means no filtering (send all message types).
+     * @param traceCategories The categories of traces that caller wish to receive.
+     * This parameter is ignored if messageTypes is not empty and does not include trace.
+     * An empty list means no filtering (send all trace categories).
+     * @param messageMax The maximum number of log messages (of all types) to be returned.
+     * A negative value requests all messages available.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_getLog(const ::Ice::LogMessageTypeSeq& messageTypes, const ::Ice::StringSeq& traceCategories, ::Ice::Int messageMax, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
+    {
+        return _iceI_begin_getLog(messageTypes, traceCategories, messageMax, ::Ice::noExplicitContext, cb, cookie);
+    }
+
+    /**
+     * Retrieves log messages recently logged.
+     * @param messageTypes The list of message types that the caller wishes to receive.
+     * An empty list means no filtering (send all message types).
+     * @param traceCategories The categories of traces that caller wish to receive.
+     * This parameter is ignored if messageTypes is not empty and does not include trace.
+     * An empty list means no filtering (send all trace categories).
+     * @param messageMax The maximum number of log messages (of all types) to be returned.
+     * A negative value requests all messages available.
+     * @param context The Context map to send with the invocation.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::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)
+    {
+        return _iceI_begin_getLog(messageTypes, traceCategories, messageMax, context, cb, cookie);
+    }
+
+    /**
+     * Retrieves log messages recently logged.
+     * @param messageTypes The list of message types that the caller wishes to receive.
+     * An empty list means no filtering (send all message types).
+     * @param traceCategories The categories of traces that caller wish to receive.
+     * This parameter is ignored if messageTypes is not empty and does not include trace.
+     * An empty list means no filtering (send all trace categories).
+     * @param messageMax The maximum number of log messages (of all types) to be returned.
+     * A negative value requests all messages available.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::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)
+    {
+        return _iceI_begin_getLog(messageTypes, traceCategories, messageMax, ::Ice::noExplicitContext, cb, cookie);
+    }
+
+    /**
+     * Retrieves log messages recently logged.
+     * @param messageTypes The list of message types that the caller wishes to receive.
+     * An empty list means no filtering (send all message types).
+     * @param traceCategories The categories of traces that caller wish to receive.
+     * This parameter is ignored if messageTypes is not empty and does not include trace.
+     * An empty list means no filtering (send all trace categories).
+     * @param messageMax The maximum number of log messages (of all types) to be returned.
+     * A negative value requests all messages available.
+     * @param context The Context map to send with the invocation.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::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)
+    {
+        return _iceI_begin_getLog(messageTypes, traceCategories, messageMax, context, cb, cookie);
+    }
+
+    /**
+     * Completes an invocation of begin_getLog.
+     * @param prefix The prefix of the associated local logger.
+     * @param result The asynchronous result object for the invocation.
+     * @return The Log messages.
+     */
+    ICE_MEMBER(ICE_API) ::Ice::LogMessageSeq end_getLog(::std::string& prefix, const ::Ice::AsyncResultPtr& result);
+    /// \cond INTERNAL
+
+    ICE_MEMBER(ICE_API) void _iceI_end_getLog(::std::string& iceP_prefix, ::Ice::LogMessageSeq& ret, const ::Ice::AsyncResultPtr&);
+    /// \endcond
 
 private:
 
@@ -788,11 +1576,17 @@ private:
 
 public:
 
+    /**
+     * Obtains the Slice type ID corresponding to this interface.
+     * @return A fully-scoped type ID.
+     */
     ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
 
 protected:
+    /// \cond INTERNAL
 
     ICE_MEMBER(ICE_API) virtual ::IceProxy::Ice::Object* _newInstance() const;
+    /// \endcond
 };
 
 }
@@ -802,7 +1596,13 @@ protected:
 namespace Ice
 {
 
-class ICE_API RemoteLogger : public virtual ::Ice::Object
+/**
+ * The Ice remote logger interface. An application can implement a
+ * RemoteLogger to receive the log messages sent to the local {@link Logger}
+ * of another Ice application.
+ * \headerfile Ice/Ice.h
+ */
+class ICE_API RemoteLogger : public virtual Object
 {
 public:
 
@@ -811,37 +1611,85 @@ public:
 
     virtual ~RemoteLogger();
 
-    virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::emptyCurrent) const;
-    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::emptyCurrent) const;
-    virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::emptyCurrent) const;
-
+    /**
+     * Determines whether this object supports an interface with the given Slice type ID.
+     * @param id The fully-scoped Slice type ID.
+     * @param current The Current object for the invocation.
+     * @return True if this object supports the interface, false, otherwise.
+     */
+    virtual bool ice_isA(const ::std::string& id, const Current& current = emptyCurrent) const;
+
+    /**
+     * Obtains a list of the Slice type IDs representing the interfaces supported by this object.
+     * @param current The Current object for the invocation.
+     * @return A list of fully-scoped type IDs.
+     */
+    virtual ::std::vector< ::std::string> ice_ids(const Current& current = emptyCurrent) const;
+
+    /**
+     * Obtains a Slice type ID representing the most-derived interface supported by this object.
+     * @param current The Current object for the invocation.
+     * @return A fully-scoped type ID.
+     */
+    virtual const ::std::string& ice_id(const Current& current = emptyCurrent) const;
+
+    /**
+     * Obtains the Slice type ID corresponding to this class.
+     * @return A fully-scoped type ID.
+     */
     static const ::std::string& ice_staticId();
 
-    virtual void init(const ::std::string&, const ::Ice::LogMessageSeq&, const ::Ice::Current& = ::Ice::emptyCurrent) = 0;
+    /**
+     * init is called by attachRemoteLogger when a RemoteLogger proxy is attached.
+     * @param prefix The prefix of the associated local Logger.
+     * @param logMessages Old log messages generated before "now".
+     * @param current The Current object for the invocation.
+     */
+    virtual void init(const ::std::string& prefix, const LogMessageSeq& logMessages, const Current& current = emptyCurrent) = 0;
+    /// \cond INTERNAL
     bool _iceD_init(::IceInternal::Incoming&, const ::Ice::Current&);
-
-    virtual void log(const ::Ice::LogMessage&, const ::Ice::Current& = ::Ice::emptyCurrent) = 0;
+    /// \endcond
+
+    /**
+     * Log a LogMessage. Note that log may be called by LoggerAdmin before init.
+     * @param message The message to log.
+     * @param current The Current object for the invocation.
+     */
+    virtual void log(const LogMessage& message, const Current& current = emptyCurrent) = 0;
+    /// \cond INTERNAL
     bool _iceD_log(::IceInternal::Incoming&, const ::Ice::Current&);
+    /// \endcond
 
-    virtual bool _iceDispatch(::IceInternal::Incoming&, const ::Ice::Current&);
+    /// \cond INTERNAL
+    virtual bool _iceDispatch(::IceInternal::Incoming&, const Current&);
+    /// \endcond
 
 protected:
 
-    virtual void _iceWriteImpl(::Ice::OutputStream*) const;
-    virtual void _iceReadImpl(::Ice::InputStream*);
+    /// \cond STREAM
+    virtual void _iceWriteImpl(OutputStream*) const;
+    virtual void _iceReadImpl(InputStream*);
+    /// \endcond
 };
 
+/// \cond INTERNAL
 inline bool operator==(const RemoteLogger& lhs, const RemoteLogger& rhs)
 {
-    return static_cast<const ::Ice::Object&>(lhs) == static_cast<const ::Ice::Object&>(rhs);
+    return static_cast<const Object&>(lhs) == static_cast<const Object&>(rhs);
 }
 
 inline bool operator<(const RemoteLogger& lhs, const RemoteLogger& rhs)
 {
-    return static_cast<const ::Ice::Object&>(lhs) < static_cast<const ::Ice::Object&>(rhs);
+    return static_cast<const Object&>(lhs) < static_cast<const Object&>(rhs);
 }
+/// \endcond
 
-class ICE_API LoggerAdmin : public virtual ::Ice::Object
+/**
+ * The interface of the admin object that allows an Ice application the attach its
+ * {@link RemoteLogger} to the {@link Logger} of this admin object's Ice communicator.
+ * \headerfile Ice/Ice.h
+ */
+class ICE_API LoggerAdmin : public virtual Object
 {
 public:
 
@@ -850,41 +1698,110 @@ public:
 
     virtual ~LoggerAdmin();
 
-    virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::emptyCurrent) const;
-    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::emptyCurrent) const;
-    virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::emptyCurrent) const;
-
+    /**
+     * Determines whether this object supports an interface with the given Slice type ID.
+     * @param id The fully-scoped Slice type ID.
+     * @param current The Current object for the invocation.
+     * @return True if this object supports the interface, false, otherwise.
+     */
+    virtual bool ice_isA(const ::std::string& id, const Current& current = emptyCurrent) const;
+
+    /**
+     * Obtains a list of the Slice type IDs representing the interfaces supported by this object.
+     * @param current The Current object for the invocation.
+     * @return A list of fully-scoped type IDs.
+     */
+    virtual ::std::vector< ::std::string> ice_ids(const Current& current = emptyCurrent) const;
+
+    /**
+     * Obtains a Slice type ID representing the most-derived interface supported by this object.
+     * @param current The Current object for the invocation.
+     * @return A fully-scoped type ID.
+     */
+    virtual const ::std::string& ice_id(const Current& current = emptyCurrent) const;
+
+    /**
+     * Obtains the Slice type ID corresponding to this class.
+     * @return A fully-scoped type ID.
+     */
     static const ::std::string& ice_staticId();
 
-    virtual void attachRemoteLogger(const ::Ice::RemoteLoggerPrx&, const ::Ice::LogMessageTypeSeq&, const ::Ice::StringSeq&, ::Ice::Int, const ::Ice::Current& = ::Ice::emptyCurrent) = 0;
+    /**
+     * Attaches a RemoteLogger object to the local logger.
+     * attachRemoteLogger calls init on the provided RemoteLogger proxy.
+     * @param prx A proxy to the remote logger.
+     * @param messageTypes The list of message types that the remote logger wishes to receive.
+     * An empty list means no filtering (send all message types).
+     * @param traceCategories The categories of traces that the remote logger wishes to receive.
+     * This parameter is ignored if messageTypes is not empty and does not include trace.
+     * An empty list means no filtering (send all trace categories).
+     * @param messageMax The maximum number of log messages (of all types) to be provided
+     * to init. A negative value requests all messages available.
+     * @param current The Current object for the invocation.
+     * @throws Ice::RemoteLoggerAlreadyAttachedException Raised if this remote logger is already
+     * attached to this admin object.
+     */
+    virtual void attachRemoteLogger(const RemoteLoggerPrx& prx, const LogMessageTypeSeq& messageTypes, const StringSeq& traceCategories, Int messageMax, const Current& current = emptyCurrent) = 0;
+    /// \cond INTERNAL
     bool _iceD_attachRemoteLogger(::IceInternal::Incoming&, const ::Ice::Current&);
-
-    virtual bool detachRemoteLogger(const ::Ice::RemoteLoggerPrx&, const ::Ice::Current& = ::Ice::emptyCurrent) = 0;
+    /// \endcond
+
+    /**
+     * Detaches a RemoteLogger object from the local logger.
+     * @param prx A proxy to the remote logger.
+     * @param current The Current object for the invocation.
+     * @return True if the provided remote logger proxy was detached, and false otherwise.
+     */
+    virtual bool detachRemoteLogger(const RemoteLoggerPrx& prx, const Current& current = emptyCurrent) = 0;
+    /// \cond INTERNAL
     bool _iceD_detachRemoteLogger(::IceInternal::Incoming&, const ::Ice::Current&);
-
-    virtual ::Ice::LogMessageSeq getLog(const ::Ice::LogMessageTypeSeq&, const ::Ice::StringSeq&, ::Ice::Int, ::std::string&, const ::Ice::Current& = ::Ice::emptyCurrent) = 0;
+    /// \endcond
+
+    /**
+     * Retrieves log messages recently logged.
+     * @param messageTypes The list of message types that the caller wishes to receive.
+     * An empty list means no filtering (send all message types).
+     * @param traceCategories The categories of traces that caller wish to receive.
+     * This parameter is ignored if messageTypes is not empty and does not include trace.
+     * An empty list means no filtering (send all trace categories).
+     * @param messageMax The maximum number of log messages (of all types) to be returned.
+     * A negative value requests all messages available.
+     * @param prefix The prefix of the associated local logger.
+     * @param current The Current object for the invocation.
+     * @return The Log messages.
+     */
+    virtual LogMessageSeq getLog(const LogMessageTypeSeq& messageTypes, const StringSeq& traceCategories, Int messageMax, ::std::string& prefix, const Current& current = emptyCurrent) = 0;
+    /// \cond INTERNAL
     bool _iceD_getLog(::IceInternal::Incoming&, const ::Ice::Current&);
+    /// \endcond
 
-    virtual bool _iceDispatch(::IceInternal::Incoming&, const ::Ice::Current&);
+    /// \cond INTERNAL
+    virtual bool _iceDispatch(::IceInternal::Incoming&, const Current&);
+    /// \endcond
 
 protected:
 
-    virtual void _iceWriteImpl(::Ice::OutputStream*) const;
-    virtual void _iceReadImpl(::Ice::InputStream*);
+    /// \cond STREAM
+    virtual void _iceWriteImpl(OutputStream*) const;
+    virtual void _iceReadImpl(InputStream*);
+    /// \endcond
 };
 
+/// \cond INTERNAL
 inline bool operator==(const LoggerAdmin& lhs, const LoggerAdmin& rhs)
 {
-    return static_cast<const ::Ice::Object&>(lhs) == static_cast<const ::Ice::Object&>(rhs);
+    return static_cast<const Object&>(lhs) == static_cast<const Object&>(rhs);
 }
 
 inline bool operator<(const LoggerAdmin& lhs, const LoggerAdmin& rhs)
 {
-    return static_cast<const ::Ice::Object&>(lhs) < static_cast<const ::Ice::Object&>(rhs);
+    return static_cast<const Object&>(lhs) < static_cast<const Object&>(rhs);
 }
+/// \endcond
 
 }
 
+/// \cond STREAM
 namespace Ice
 {
 
@@ -937,10 +1854,16 @@ struct StreamableTraits< ::Ice::RemoteLoggerAlreadyAttachedException>
 };
 
 }
+/// \endcond
 
 namespace Ice
 {
 
+/**
+ * Type-safe asynchronous callback wrapper class used for calls to
+ * IceProxy::Ice::RemoteLogger::begin_init.
+ * Create a wrapper instance by calling ::Ice::newCallback_RemoteLogger_init.
+ */
 template<class T>
 class CallbackNC_RemoteLogger_init : public Callback_RemoteLogger_init_Base, public ::IceInternal::OnewayCallbackNC<T>
 {
@@ -958,30 +1881,65 @@ public:
     }
 };
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::RemoteLogger::begin_init.
+ */
 template<class T> Callback_RemoteLogger_initPtr
 newCallback_RemoteLogger_init(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
 {
     return new CallbackNC_RemoteLogger_init<T>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::RemoteLogger::begin_init.
+ */
 template<class T> Callback_RemoteLogger_initPtr
 newCallback_RemoteLogger_init(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
 {
     return new CallbackNC_RemoteLogger_init<T>(instance, 0, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::RemoteLogger::begin_init.
+ */
 template<class T> Callback_RemoteLogger_initPtr
 newCallback_RemoteLogger_init(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
 {
     return new CallbackNC_RemoteLogger_init<T>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::RemoteLogger::begin_init.
+ */
 template<class T> Callback_RemoteLogger_initPtr
 newCallback_RemoteLogger_init(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
 {
     return new CallbackNC_RemoteLogger_init<T>(instance, 0, excb, sentcb);
 }
 
+/**
+ * Type-safe asynchronous callback wrapper class with cookie support used for calls to
+ * IceProxy::Ice::RemoteLogger::begin_init.
+ * Create a wrapper instance by calling ::Ice::newCallback_RemoteLogger_init.
+ */
 template<class T, typename CT>
 class Callback_RemoteLogger_init : public Callback_RemoteLogger_init_Base, public ::IceInternal::OnewayCallback<T, CT>
 {
@@ -999,30 +1957,69 @@ public:
     }
 };
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * Use this overload when your callback methods receive a cookie value.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::RemoteLogger::begin_init.
+ */
 template<class T, typename CT> Callback_RemoteLogger_initPtr
 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)
 {
     return new Callback_RemoteLogger_init<T, CT>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * Use this overload when your callback methods receive a cookie value.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::RemoteLogger::begin_init.
+ */
 template<class T, typename CT> Callback_RemoteLogger_initPtr
 newCallback_RemoteLogger_init(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
 {
     return new Callback_RemoteLogger_init<T, CT>(instance, 0, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * Use this overload when your callback methods receive a cookie value.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::RemoteLogger::begin_init.
+ */
 template<class T, typename CT> Callback_RemoteLogger_initPtr
 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)
 {
     return new Callback_RemoteLogger_init<T, CT>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * Use this overload when your callback methods receive a cookie value.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::RemoteLogger::begin_init.
+ */
 template<class T, typename CT> Callback_RemoteLogger_initPtr
 newCallback_RemoteLogger_init(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
 {
     return new Callback_RemoteLogger_init<T, CT>(instance, 0, excb, sentcb);
 }
 
+/**
+ * Type-safe asynchronous callback wrapper class used for calls to
+ * IceProxy::Ice::RemoteLogger::begin_log.
+ * Create a wrapper instance by calling ::Ice::newCallback_RemoteLogger_log.
+ */
 template<class T>
 class CallbackNC_RemoteLogger_log : public Callback_RemoteLogger_log_Base, public ::IceInternal::OnewayCallbackNC<T>
 {
@@ -1040,30 +2037,65 @@ public:
     }
 };
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::RemoteLogger::begin_log.
+ */
 template<class T> Callback_RemoteLogger_logPtr
 newCallback_RemoteLogger_log(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
 {
     return new CallbackNC_RemoteLogger_log<T>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::RemoteLogger::begin_log.
+ */
 template<class T> Callback_RemoteLogger_logPtr
 newCallback_RemoteLogger_log(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
 {
     return new CallbackNC_RemoteLogger_log<T>(instance, 0, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::RemoteLogger::begin_log.
+ */
 template<class T> Callback_RemoteLogger_logPtr
 newCallback_RemoteLogger_log(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
 {
     return new CallbackNC_RemoteLogger_log<T>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::RemoteLogger::begin_log.
+ */
 template<class T> Callback_RemoteLogger_logPtr
 newCallback_RemoteLogger_log(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
 {
     return new CallbackNC_RemoteLogger_log<T>(instance, 0, excb, sentcb);
 }
 
+/**
+ * Type-safe asynchronous callback wrapper class with cookie support used for calls to
+ * IceProxy::Ice::RemoteLogger::begin_log.
+ * Create a wrapper instance by calling ::Ice::newCallback_RemoteLogger_log.
+ */
 template<class T, typename CT>
 class Callback_RemoteLogger_log : public Callback_RemoteLogger_log_Base, public ::IceInternal::OnewayCallback<T, CT>
 {
@@ -1081,30 +2113,69 @@ public:
     }
 };
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * Use this overload when your callback methods receive a cookie value.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::RemoteLogger::begin_log.
+ */
 template<class T, typename CT> Callback_RemoteLogger_logPtr
 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)
 {
     return new Callback_RemoteLogger_log<T, CT>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * Use this overload when your callback methods receive a cookie value.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::RemoteLogger::begin_log.
+ */
 template<class T, typename CT> Callback_RemoteLogger_logPtr
 newCallback_RemoteLogger_log(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
 {
     return new Callback_RemoteLogger_log<T, CT>(instance, 0, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * Use this overload when your callback methods receive a cookie value.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::RemoteLogger::begin_log.
+ */
 template<class T, typename CT> Callback_RemoteLogger_logPtr
 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)
 {
     return new Callback_RemoteLogger_log<T, CT>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * Use this overload when your callback methods receive a cookie value.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::RemoteLogger::begin_log.
+ */
 template<class T, typename CT> Callback_RemoteLogger_logPtr
 newCallback_RemoteLogger_log(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
 {
     return new Callback_RemoteLogger_log<T, CT>(instance, 0, excb, sentcb);
 }
 
+/**
+ * Type-safe asynchronous callback wrapper class used for calls to
+ * IceProxy::Ice::LoggerAdmin::begin_attachRemoteLogger.
+ * Create a wrapper instance by calling ::Ice::newCallback_LoggerAdmin_attachRemoteLogger.
+ */
 template<class T>
 class CallbackNC_LoggerAdmin_attachRemoteLogger : public Callback_LoggerAdmin_attachRemoteLogger_Base, public ::IceInternal::TwowayCallbackNC<T>
 {
@@ -1121,9 +2192,10 @@ public:
     {
     }
 
-    virtual void completed(const ::Ice::AsyncResultPtr& result) const
+    /// \cond INTERNAL
+    virtual void completed(const AsyncResultPtr& result) const
     {
-        ::Ice::LoggerAdminPrx proxy = ::Ice::LoggerAdminPrx::uncheckedCast(result->getProxy());
+        LoggerAdminPrx proxy = LoggerAdminPrx::uncheckedCast(result->getProxy());
         try
         {
             proxy->end_attachRemoteLogger(result);
@@ -1138,36 +2210,72 @@ public:
             (::IceInternal::CallbackNC<T>::_callback.get()->*_response)();
         }
     }
+    /// \endcond
 
 private:
 
     Response _response;
 };
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::LoggerAdmin::begin_attachRemoteLogger.
+ */
 template<class T> Callback_LoggerAdmin_attachRemoteLoggerPtr
 newCallback_LoggerAdmin_attachRemoteLogger(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
 {
     return new CallbackNC_LoggerAdmin_attachRemoteLogger<T>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::LoggerAdmin::begin_attachRemoteLogger.
+ */
 template<class T> Callback_LoggerAdmin_attachRemoteLoggerPtr
 newCallback_LoggerAdmin_attachRemoteLogger(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
 {
     return new CallbackNC_LoggerAdmin_attachRemoteLogger<T>(instance, 0, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::LoggerAdmin::begin_attachRemoteLogger.
+ */
 template<class T> Callback_LoggerAdmin_attachRemoteLoggerPtr
 newCallback_LoggerAdmin_attachRemoteLogger(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
 {
     return new CallbackNC_LoggerAdmin_attachRemoteLogger<T>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::LoggerAdmin::begin_attachRemoteLogger.
+ */
 template<class T> Callback_LoggerAdmin_attachRemoteLoggerPtr
 newCallback_LoggerAdmin_attachRemoteLogger(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
 {
     return new CallbackNC_LoggerAdmin_attachRemoteLogger<T>(instance, 0, excb, sentcb);
 }
 
+/**
+ * Type-safe asynchronous callback wrapper class with cookie support used for calls to
+ * IceProxy::Ice::LoggerAdmin::begin_attachRemoteLogger.
+ * Create a wrapper instance by calling ::Ice::newCallback_LoggerAdmin_attachRemoteLogger.
+ */
 template<class T, typename CT>
 class Callback_LoggerAdmin_attachRemoteLogger : public Callback_LoggerAdmin_attachRemoteLogger_Base, public ::IceInternal::TwowayCallback<T, CT>
 {
@@ -1184,9 +2292,10 @@ public:
     {
     }
 
-    virtual void completed(const ::Ice::AsyncResultPtr& result) const
+    /// \cond INTERNAL
+    virtual void completed(const AsyncResultPtr& result) const
     {
-        ::Ice::LoggerAdminPrx proxy = ::Ice::LoggerAdminPrx::uncheckedCast(result->getProxy());
+        LoggerAdminPrx proxy = LoggerAdminPrx::uncheckedCast(result->getProxy());
         try
         {
             proxy->end_attachRemoteLogger(result);
@@ -1201,36 +2310,76 @@ public:
             (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(CT::dynamicCast(result->getCookie()));
         }
     }
+    /// \endcond
 
 private:
 
     Response _response;
 };
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * Use this overload when your callback methods receive a cookie value.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::LoggerAdmin::begin_attachRemoteLogger.
+ */
 template<class T, typename CT> Callback_LoggerAdmin_attachRemoteLoggerPtr
 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)
 {
     return new Callback_LoggerAdmin_attachRemoteLogger<T, CT>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * Use this overload when your callback methods receive a cookie value.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::LoggerAdmin::begin_attachRemoteLogger.
+ */
 template<class T, typename CT> Callback_LoggerAdmin_attachRemoteLoggerPtr
 newCallback_LoggerAdmin_attachRemoteLogger(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
 {
     return new Callback_LoggerAdmin_attachRemoteLogger<T, CT>(instance, 0, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * Use this overload when your callback methods receive a cookie value.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::LoggerAdmin::begin_attachRemoteLogger.
+ */
 template<class T, typename CT> Callback_LoggerAdmin_attachRemoteLoggerPtr
 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)
 {
     return new Callback_LoggerAdmin_attachRemoteLogger<T, CT>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * Use this overload when your callback methods receive a cookie value.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::LoggerAdmin::begin_attachRemoteLogger.
+ */
 template<class T, typename CT> Callback_LoggerAdmin_attachRemoteLoggerPtr
 newCallback_LoggerAdmin_attachRemoteLogger(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
 {
     return new Callback_LoggerAdmin_attachRemoteLogger<T, CT>(instance, 0, excb, sentcb);
 }
 
+/**
+ * Type-safe asynchronous callback wrapper class used for calls to
+ * IceProxy::Ice::LoggerAdmin::begin_detachRemoteLogger.
+ * Create a wrapper instance by calling ::Ice::newCallback_LoggerAdmin_detachRemoteLogger.
+ */
 template<class T>
 class CallbackNC_LoggerAdmin_detachRemoteLogger : public Callback_LoggerAdmin_detachRemoteLogger_Base, public ::IceInternal::TwowayCallbackNC<T>
 {
@@ -1247,9 +2396,10 @@ public:
     {
     }
 
-    virtual void completed(const ::Ice::AsyncResultPtr& result) const
+    /// \cond INTERNAL
+    virtual void completed(const AsyncResultPtr& result) const
     {
-        ::Ice::LoggerAdminPrx proxy = ::Ice::LoggerAdminPrx::uncheckedCast(result->getProxy());
+        LoggerAdminPrx proxy = LoggerAdminPrx::uncheckedCast(result->getProxy());
         bool ret;
         try
         {
@@ -1265,24 +2415,46 @@ public:
             (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
         }
     }
+    /// \endcond
 
 private:
 
     Response _response;
 };
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::LoggerAdmin::begin_detachRemoteLogger.
+ */
 template<class T> Callback_LoggerAdmin_detachRemoteLoggerPtr
 newCallback_LoggerAdmin_detachRemoteLogger(const IceUtil::Handle<T>& instance, void (T::*cb)(bool), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
 {
     return new CallbackNC_LoggerAdmin_detachRemoteLogger<T>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::LoggerAdmin::begin_detachRemoteLogger.
+ */
 template<class T> Callback_LoggerAdmin_detachRemoteLoggerPtr
 newCallback_LoggerAdmin_detachRemoteLogger(T* instance, void (T::*cb)(bool), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
 {
     return new CallbackNC_LoggerAdmin_detachRemoteLogger<T>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Type-safe asynchronous callback wrapper class with cookie support used for calls to
+ * IceProxy::Ice::LoggerAdmin::begin_detachRemoteLogger.
+ * Create a wrapper instance by calling ::Ice::newCallback_LoggerAdmin_detachRemoteLogger.
+ */
 template<class T, typename CT>
 class Callback_LoggerAdmin_detachRemoteLogger : public Callback_LoggerAdmin_detachRemoteLogger_Base, public ::IceInternal::TwowayCallback<T, CT>
 {
@@ -1299,9 +2471,10 @@ public:
     {
     }
 
-    virtual void completed(const ::Ice::AsyncResultPtr& result) const
+    /// \cond INTERNAL
+    virtual void completed(const AsyncResultPtr& result) const
     {
-        ::Ice::LoggerAdminPrx proxy = ::Ice::LoggerAdminPrx::uncheckedCast(result->getProxy());
+        LoggerAdminPrx proxy = LoggerAdminPrx::uncheckedCast(result->getProxy());
         bool ret;
         try
         {
@@ -1317,24 +2490,48 @@ public:
             (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret, CT::dynamicCast(result->getCookie()));
         }
     }
+    /// \endcond
 
 private:
 
     Response _response;
 };
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * Use this overload when your callback methods receive a cookie value.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::LoggerAdmin::begin_detachRemoteLogger.
+ */
 template<class T, typename CT> Callback_LoggerAdmin_detachRemoteLoggerPtr
 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)
 {
     return new Callback_LoggerAdmin_detachRemoteLogger<T, CT>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * Use this overload when your callback methods receive a cookie value.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::LoggerAdmin::begin_detachRemoteLogger.
+ */
 template<class T, typename CT> Callback_LoggerAdmin_detachRemoteLoggerPtr
 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)
 {
     return new Callback_LoggerAdmin_detachRemoteLogger<T, CT>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Type-safe asynchronous callback wrapper class used for calls to
+ * IceProxy::Ice::LoggerAdmin::begin_getLog.
+ * Create a wrapper instance by calling ::Ice::newCallback_LoggerAdmin_getLog.
+ */
 template<class T>
 class CallbackNC_LoggerAdmin_getLog : public Callback_LoggerAdmin_getLog_Base, public ::IceInternal::TwowayCallbackNC<T>
 {
@@ -1344,18 +2541,19 @@ public:
 
     typedef void (T::*Exception)(const ::Ice::Exception&);
     typedef void (T::*Sent)(bool);
-    typedef void (T::*Response)(const ::Ice::LogMessageSeq&, const ::std::string&);
+    typedef void (T::*Response)(const LogMessageSeq&, const ::std::string&);
 
     CallbackNC_LoggerAdmin_getLog(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
         : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
     {
     }
 
-    virtual void completed(const ::Ice::AsyncResultPtr& result) const
+    /// \cond INTERNAL
+    virtual void completed(const AsyncResultPtr& result) const
     {
-        ::Ice::LoggerAdminPrx proxy = ::Ice::LoggerAdminPrx::uncheckedCast(result->getProxy());
+        LoggerAdminPrx proxy = LoggerAdminPrx::uncheckedCast(result->getProxy());
         ::std::string iceP_prefix;
-        ::Ice::LogMessageSeq ret;
+        LogMessageSeq ret;
         try
         {
             ret = proxy->end_getLog(iceP_prefix, result);
@@ -1370,24 +2568,46 @@ public:
             (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret, iceP_prefix);
         }
     }
+    /// \endcond
 
 private:
 
     Response _response;
 };
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::LoggerAdmin::begin_getLog.
+ */
 template<class T> Callback_LoggerAdmin_getLogPtr
-newCallback_LoggerAdmin_getLog(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::LogMessageSeq&, const ::std::string&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
+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)
 {
     return new CallbackNC_LoggerAdmin_getLog<T>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::LoggerAdmin::begin_getLog.
+ */
 template<class T> Callback_LoggerAdmin_getLogPtr
-newCallback_LoggerAdmin_getLog(T* instance, void (T::*cb)(const ::Ice::LogMessageSeq&, const ::std::string&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
+newCallback_LoggerAdmin_getLog(T* instance, void (T::*cb)(const LogMessageSeq&, const ::std::string&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
 {
     return new CallbackNC_LoggerAdmin_getLog<T>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Type-safe asynchronous callback wrapper class with cookie support used for calls to
+ * IceProxy::Ice::LoggerAdmin::begin_getLog.
+ * Create a wrapper instance by calling ::Ice::newCallback_LoggerAdmin_getLog.
+ */
 template<class T, typename CT>
 class Callback_LoggerAdmin_getLog : public Callback_LoggerAdmin_getLog_Base, public ::IceInternal::TwowayCallback<T, CT>
 {
@@ -1397,18 +2617,19 @@ public:
 
     typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
     typedef void (T::*Sent)(bool , const CT&);
-    typedef void (T::*Response)(const ::Ice::LogMessageSeq&, const ::std::string&, const CT&);
+    typedef void (T::*Response)(const LogMessageSeq&, const ::std::string&, const CT&);
 
     Callback_LoggerAdmin_getLog(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
         : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
     {
     }
 
-    virtual void completed(const ::Ice::AsyncResultPtr& result) const
+    /// \cond INTERNAL
+    virtual void completed(const AsyncResultPtr& result) const
     {
-        ::Ice::LoggerAdminPrx proxy = ::Ice::LoggerAdminPrx::uncheckedCast(result->getProxy());
+        LoggerAdminPrx proxy = LoggerAdminPrx::uncheckedCast(result->getProxy());
         ::std::string iceP_prefix;
-        ::Ice::LogMessageSeq ret;
+        LogMessageSeq ret;
         try
         {
             ret = proxy->end_getLog(iceP_prefix, result);
@@ -1423,20 +2644,39 @@ public:
             (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret, iceP_prefix, CT::dynamicCast(result->getCookie()));
         }
     }
+    /// \endcond
 
 private:
 
     Response _response;
 };
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * Use this overload when your callback methods receive a cookie value.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::LoggerAdmin::begin_getLog.
+ */
 template<class T, typename CT> Callback_LoggerAdmin_getLogPtr
-newCallback_LoggerAdmin_getLog(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::LogMessageSeq&, const ::std::string&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
+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)
 {
     return new Callback_LoggerAdmin_getLog<T, CT>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * Use this overload when your callback methods receive a cookie value.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::LoggerAdmin::begin_getLog.
+ */
 template<class T, typename CT> Callback_LoggerAdmin_getLogPtr
-newCallback_LoggerAdmin_getLog(T* instance, void (T::*cb)(const ::Ice::LogMessageSeq&, const ::std::string&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
+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)
 {
     return new Callback_LoggerAdmin_getLog<T, CT>(instance, cb, excb, sentcb);
 }