Router.h

// Copyright (c) ZeroC, Inc.
 
// slice2cpp version 3.8.0-alpha.0
// <auto-generated>Generated from Slice file 'Router.ice'.</auto-generated>
// clang-format off
 
#ifndef Glacier2_Router_h_
#define Glacier2_Router_h_
 
#include <Ice/PushDisableWarnings.h>
#include <Ice/Ice.h>
#include <Ice/Router.h>
#include "PermissionsVerifier.h"
#include "Session.h"
#include <Glacier2/Config.h>
 
#ifndef ICE_DISABLE_VERSION
#   if ICE_INT_VERSION  != 30850
#       error Ice version mismatch: an exact match is required for beta generated code
#   endif
#endif
 
#ifndef GLACIER2_API
#   if defined(GLACIER2_API_EXPORTS)
#       define GLACIER2_API ICE_DECLSPEC_EXPORT
#   else
#       define GLACIER2_API ICE_DECLSPEC_IMPORT
#   endif
#endif
 
// NOLINTBEGIN(modernize-concat-nested-namespaces)
 
/// Communicate through firewalls and across NATs.
namespace Glacier2
{
    class RouterPrx;
}
 
namespace Glacier2
{
    /// The Glacier2 specialization of the ::Ice::RouterPrx interface.
    /// @headerfile Glacier2/Glacier2.h
    class GLACIER2_API RouterPrx : public Ice::Proxy<RouterPrx, ::Ice::RouterPrx>
    {
    public:
#if defined(__GNUC__) && !defined(__clang__)
#   pragma GCC diagnostic push
#   pragma GCC diagnostic ignored "-Wextra" // initialize all virtual bases in correct order
#endif
 
        /// Constructs a proxy from a Communicator and a proxy string.
        /// @param communicator The communicator of the new proxy.
        /// @param proxyString The proxy string to parse.
        RouterPrx(const Ice::CommunicatorPtr& communicator, std::string_view proxyString) : Ice::ObjectPrx{communicator, proxyString} {} // NOLINT(modernize-use-equals-default)
 
        /// Copy constructor. Constructs with a copy of the contents of @p other.
        /// @param other The proxy to copy from.
        RouterPrx(const RouterPrx& other) noexcept : Ice::ObjectPrx{other} {} // NOLINT(modernize-use-equals-default)
 
        /// Move constructor. Constructs a proxy with the contents of @p other using move semantics.
        /// @param other The proxy to move from.
        RouterPrx(RouterPrx&& other) noexcept : Ice::ObjectPrx{std::move(other)} {} // NOLINT(modernize-use-equals-default)
 
        ~RouterPrx() override;
 
        /// Copy assignment operator. Replaces the contents of this proxy with a copy of the contents of @p rhs.
        /// @param rhs The proxy to copy from.
        /// @return A reference to this proxy.
        RouterPrx& operator=(const RouterPrx& rhs) noexcept
        {
            if (this != &rhs)
            {
                Ice::ObjectPrx::operator=(rhs);
            }
            return *this;
        }
 
        /// Move assignment operator. Replaces the contents of this proxy with the contents of @p rhs using move semantics.
        /// @param rhs The proxy to move from.
        RouterPrx& operator=(RouterPrx&& rhs) noexcept
        {
            if (this != &rhs)
            {
                Ice::ObjectPrx::operator=(std::move(rhs));
            }
            return *this;
        }
 
        /// Gets a unique category that identifies the client (caller) in the router. This category must be used in the
        /// identities of all the client's callback objects.
        /// @param context The request context.
        /// @return The category. It's an empty string when `Glacier2.Server.Endpoints` is not configured.
        std::string getCategoryForClient(const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Gets a unique category that identifies the client (caller) in the router. This category must be used in the
        /// identities of all the client's callback objects.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - The category. It's an empty string when `Glacier2.Server.Endpoints` is not configured.
        [[nodiscard]] std::future<std::string> getCategoryForClientAsync(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Gets a unique category that identifies the client (caller) in the router. This category must be used in the
        /// identities of all the client's callback objects.
        /// @param response The response callback. It accepts:
        /// - The category. It's an empty string when `Glacier2.Server.Endpoints` is not configured.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> getCategoryForClientAsync(std::function<void(std::string)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_getCategoryForClient(const std::shared_ptr<IceInternal::OutgoingAsyncT<std::string>>&, const Ice::Context&) const;
 
        /// Creates a session for the client (caller) with the router. If a ::Glacier2::SessionManagerPrx is configured,
        /// a proxy to a ::Glacier2::SessionPrx object is returned to the client. Otherwise, null is returned and only an
        /// internal session (i.e., not visible to the client) is created.
        /// If a non-null session proxy is returned, it must be configured to route through the router that created it.
        /// This occurs automatically when the router is configured as the client's default router at the time the
        /// session proxy is created in the client application; otherwise, the client must configure the session proxy
        /// explicitly.
        /// @param userId The user ID.
        /// @param password The password.
        /// @param context The request context.
        /// @return A proxy for the newly created session, or null if no ::Glacier2::SessionManagerPrx is configured.
        /// @throws Glacier2::CannotCreateSessionException Thrown when the session cannot be created.
        /// @throws Glacier2::PermissionDeniedException Thrown when an authentication or authorization failure occurs.
        /// @see Session
        /// @see SessionManager
        /// @see PermissionsVerifier
        std::optional<SessionPrx> createSession(std::string_view userId, std::string_view password, const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Creates a session for the client (caller) with the router. If a ::Glacier2::SessionManagerPrx is configured,
        /// a proxy to a ::Glacier2::SessionPrx object is returned to the client. Otherwise, null is returned and only an
        /// internal session (i.e., not visible to the client) is created.
        /// If a non-null session proxy is returned, it must be configured to route through the router that created it.
        /// This occurs automatically when the router is configured as the client's default router at the time the
        /// session proxy is created in the client application; otherwise, the client must configure the session proxy
        /// explicitly.
        /// @param userId The user ID.
        /// @param password The password.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - A proxy for the newly created session, or null if no ::Glacier2::SessionManagerPrx is configured.
        /// @see Session
        /// @see SessionManager
        /// @see PermissionsVerifier
        [[nodiscard]] std::future<std::optional<SessionPrx>> createSessionAsync(std::string_view userId, std::string_view password, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Creates a session for the client (caller) with the router. If a ::Glacier2::SessionManagerPrx is configured,
        /// a proxy to a ::Glacier2::SessionPrx object is returned to the client. Otherwise, null is returned and only an
        /// internal session (i.e., not visible to the client) is created.
        /// If a non-null session proxy is returned, it must be configured to route through the router that created it.
        /// This occurs automatically when the router is configured as the client's default router at the time the
        /// session proxy is created in the client application; otherwise, the client must configure the session proxy
        /// explicitly.
        /// @param userId The user ID.
        /// @param password The password.
        /// @param response The response callback. It accepts:
        /// - A proxy for the newly created session, or null if no ::Glacier2::SessionManagerPrx is configured.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        /// @see Session
        /// @see SessionManager
        /// @see PermissionsVerifier
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> createSessionAsync(std::string_view userId, std::string_view password, std::function<void(std::optional<::Glacier2::SessionPrx>)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_createSession(const std::shared_ptr<IceInternal::OutgoingAsyncT<std::optional<SessionPrx>>>&, std::string_view, std::string_view, const Ice::Context&) const;
 
        /// Creates a per-client session with the router. The user is authenticated through the SSL certificate(s)
        /// associated with the connection. If an ::Glacier2::SSLSessionManagerPrx is configured, a proxy to a ::Glacier2::SessionPrx
        /// object is returned to the client. Otherwise, null is returned and only an internal session (i.e., not
        /// visible to the client) is created.
        /// If a non-null session proxy is returned, it must be configured to route through the router that created it.
        /// This occurs automatically when the router is configured as the client's default router at the time the
        /// session proxy is created in the client application; otherwise, the client must configure the session proxy
        /// explicitly.
        /// @param context The request context.
        /// @return A proxy for the newly created session, or null if no ::Glacier2::SSLSessionManagerPrx is configured.
        /// @throws Glacier2::CannotCreateSessionException Thrown when the session cannot be created.
        /// @throws Glacier2::PermissionDeniedException Thrown when an authentication or authorization failure occurs.
        /// @see Session
        /// @see SessionManager
        /// @see PermissionsVerifier
        std::optional<SessionPrx> createSessionFromSecureConnection(const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Creates a per-client session with the router. The user is authenticated through the SSL certificate(s)
        /// associated with the connection. If an ::Glacier2::SSLSessionManagerPrx is configured, a proxy to a ::Glacier2::SessionPrx
        /// object is returned to the client. Otherwise, null is returned and only an internal session (i.e., not
        /// visible to the client) is created.
        /// If a non-null session proxy is returned, it must be configured to route through the router that created it.
        /// This occurs automatically when the router is configured as the client's default router at the time the
        /// session proxy is created in the client application; otherwise, the client must configure the session proxy
        /// explicitly.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - A proxy for the newly created session, or null if no ::Glacier2::SSLSessionManagerPrx is configured.
        /// @see Session
        /// @see SessionManager
        /// @see PermissionsVerifier
        [[nodiscard]] std::future<std::optional<SessionPrx>> createSessionFromSecureConnectionAsync(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Creates a per-client session with the router. The user is authenticated through the SSL certificate(s)
        /// associated with the connection. If an ::Glacier2::SSLSessionManagerPrx is configured, a proxy to a ::Glacier2::SessionPrx
        /// object is returned to the client. Otherwise, null is returned and only an internal session (i.e., not
        /// visible to the client) is created.
        /// If a non-null session proxy is returned, it must be configured to route through the router that created it.
        /// This occurs automatically when the router is configured as the client's default router at the time the
        /// session proxy is created in the client application; otherwise, the client must configure the session proxy
        /// explicitly.
        /// @param response The response callback. It accepts:
        /// - A proxy for the newly created session, or null if no ::Glacier2::SSLSessionManagerPrx is configured.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        /// @see Session
        /// @see SessionManager
        /// @see PermissionsVerifier
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> createSessionFromSecureConnectionAsync(std::function<void(std::optional<::Glacier2::SessionPrx>)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_createSessionFromSecureConnection(const std::shared_ptr<IceInternal::OutgoingAsyncT<std::optional<SessionPrx>>>&, const Ice::Context&) const;
 
        /// Keeps the session with this router alive.
        /// @param context The request context.
        /// @throws Glacier2::SessionNotExistException Thrown when no session exists for the caller (client).
        [[deprecated("As of Ice 3.8, this operation does nothing.")]] void refreshSession(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Keeps the session with this router alive.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[deprecated("As of Ice 3.8, this operation does nothing.")]] [[nodiscard]] std::future<void> refreshSessionAsync(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Keeps the session with this router alive.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        [[deprecated("As of Ice 3.8, this operation does nothing.")]] std::function<void()> refreshSessionAsync(std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_refreshSession(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, const Ice::Context&) const;
 
        /// Destroys the session of the caller with this router.
        /// @param context The request context.
        /// @throws Glacier2::SessionNotExistException Thrown when no session exists for the caller (client).
        void destroySession(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Destroys the session of the caller with this router.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> destroySessionAsync(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Destroys the session of the caller with this router.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> destroySessionAsync(std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_destroySession(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, const Ice::Context&) const;
 
        /// Gets the idle timeout used by the server-side of the connection.
        /// @param context The request context.
        /// @return The idle timeout (in seconds).
        std::int64_t getSessionTimeout(const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Gets the idle timeout used by the server-side of the connection.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - The idle timeout (in seconds).
        [[nodiscard]] std::future<std::int64_t> getSessionTimeoutAsync(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Gets the idle timeout used by the server-side of the connection.
        /// @param response The response callback. It accepts:
        /// - The idle timeout (in seconds).
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> getSessionTimeoutAsync(std::function<void(std::int64_t)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_getSessionTimeout(const std::shared_ptr<IceInternal::OutgoingAsyncT<std::int64_t>>&, const Ice::Context&) const;
 
        /// Gets the idle timeout used by the server-side of the connection.
        /// @param context The request context.
        /// @return The idle timeout (in seconds).
        std::int32_t getACMTimeout(const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Gets the idle timeout used by the server-side of the connection.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - The idle timeout (in seconds).
        [[nodiscard]] std::future<std::int32_t> getACMTimeoutAsync(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Gets the idle timeout used by the server-side of the connection.
        /// @param response The response callback. It accepts:
        /// - The idle timeout (in seconds).
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> getACMTimeoutAsync(std::function<void(std::int32_t)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_getACMTimeout(const std::shared_ptr<IceInternal::OutgoingAsyncT<std::int32_t>>&, const Ice::Context&) const;
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::Glacier2::Router"`.
        static const char* ice_staticId() noexcept;
 
        /// @private
        static RouterPrx _fromReference(IceInternal::ReferencePtr ref) { return RouterPrx{std::move(ref)}; }
 
    protected:
        /// @private
        RouterPrx() = default;
 
        /// @private
        explicit RouterPrx(IceInternal::ReferencePtr&& ref) : Ice::ObjectPrx{std::move(ref)}
        {
        }
 
#if defined(__GNUC__) && !defined(__clang__)
#   pragma GCC diagnostic pop
#endif
    };
}
 
namespace Glacier2
{
    /// The exception that is thrown when a client tries to destroy a session with a router, but no session exists for
    /// this client.
    /// @see Router#destroySession
    /// @headerfile Glacier2/Glacier2.h
    class GLACIER2_API SessionNotExistException : public Ice::UserException
    {
    public:
        /// Gets the type ID of the associated Slice exception.
        /// @return The string `"::Glacier2::SessionNotExistException"`.
        static const char* ice_staticId() noexcept;
 
        [[nodiscard]] const char* ice_id() const noexcept override;
 
        void ice_throw() const override;
 
    protected:
        /// @private
        void _writeImpl(Ice::OutputStream*) const override;
 
        /// @private
        void _readImpl(Ice::InputStream*) override;
    };
}
 
namespace Glacier2
{
    /// The Glacier2 specialization of the ::Ice::RouterPrx interface.
    /// @headerfile Glacier2/Glacier2.h
    class GLACIER2_API Router : public virtual ::Ice::Router
    {
    public:
        /// The associated proxy type.
        using ProxyType = RouterPrx;
 
        /// Dispatches an incoming request to one of the member functions of this generated class, based on the operation name carried by the request.
        /// @param request The incoming request.
        /// @param sendResponse The callback to send the response.
        void dispatch(Ice::IncomingRequest& request, std::function<void(Ice::OutgoingResponse)> sendResponse) override;
 
        [[nodiscard]] std::vector<std::string> ice_ids(const Ice::Current& current) const override;
 
        [[nodiscard]] std::string ice_id(const Ice::Current& current) const override;
 
        /// Gets a unique category that identifies the client (caller) in the router. This category must be used in the
        /// identities of all the client's callback objects.
        /// @param current The Current object of the incoming request.
        /// @return The category. It's an empty string when `Glacier2.Server.Endpoints` is not configured.
        [[nodiscard]] virtual std::string getCategoryForClient(const Ice::Current& current) const = 0;
 
        /// @private
        void _iceD_getCategoryForClient(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>) const;
 
        /// Creates a session for the client (caller) with the router. If a ::Glacier2::SessionManagerPrx is configured,
        /// a proxy to a ::Glacier2::SessionPrx object is returned to the client. Otherwise, null is returned and only an
        /// internal session (i.e., not visible to the client) is created.
        /// If a non-null session proxy is returned, it must be configured to route through the router that created it.
        /// This occurs automatically when the router is configured as the client's default router at the time the
        /// session proxy is created in the client application; otherwise, the client must configure the session proxy
        /// explicitly.
        /// @param userId The user ID.
        /// @param password The password.
        /// @param response The response callback. It accepts:
        /// - A proxy for the newly created session, or null if no ::Glacier2::SessionManagerPrx is configured.
        /// @param exception The exception callback.
        /// @param current The Current object of the incoming request.
        /// @throws Glacier2::CannotCreateSessionException Thrown when the session cannot be created.
        /// @throws Glacier2::PermissionDeniedException Thrown when an authentication or authorization failure occurs.
        /// @see Session
        /// @see SessionManager
        /// @see PermissionsVerifier
        virtual void createSessionAsync(std::string userId, std::string password, std::function<void(const std::optional<SessionPrx>& returnValue)> response, std::function<void(std::exception_ptr)> exception, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_createSession(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Creates a per-client session with the router. The user is authenticated through the SSL certificate(s)
        /// associated with the connection. If an ::Glacier2::SSLSessionManagerPrx is configured, a proxy to a ::Glacier2::SessionPrx
        /// object is returned to the client. Otherwise, null is returned and only an internal session (i.e., not
        /// visible to the client) is created.
        /// If a non-null session proxy is returned, it must be configured to route through the router that created it.
        /// This occurs automatically when the router is configured as the client's default router at the time the
        /// session proxy is created in the client application; otherwise, the client must configure the session proxy
        /// explicitly.
        /// @param response The response callback. It accepts:
        /// - A proxy for the newly created session, or null if no ::Glacier2::SSLSessionManagerPrx is configured.
        /// @param exception The exception callback.
        /// @param current The Current object of the incoming request.
        /// @throws Glacier2::CannotCreateSessionException Thrown when the session cannot be created.
        /// @throws Glacier2::PermissionDeniedException Thrown when an authentication or authorization failure occurs.
        /// @see Session
        /// @see SessionManager
        /// @see PermissionsVerifier
        virtual void createSessionFromSecureConnectionAsync(std::function<void(const std::optional<SessionPrx>& returnValue)> response, std::function<void(std::exception_ptr)> exception, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_createSessionFromSecureConnection(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Keeps the session with this router alive.
        /// @param current The Current object of the incoming request.
        /// @throws Glacier2::SessionNotExistException Thrown when no session exists for the caller (client).
        virtual void refreshSession(const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_refreshSession(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Destroys the session of the caller with this router.
        /// @param current The Current object of the incoming request.
        /// @throws Glacier2::SessionNotExistException Thrown when no session exists for the caller (client).
        virtual void destroySession(const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_destroySession(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets the idle timeout used by the server-side of the connection.
        /// @param current The Current object of the incoming request.
        /// @return The idle timeout (in seconds).
        [[nodiscard]] virtual std::int64_t getSessionTimeout(const Ice::Current& current) const = 0;
 
        /// @private
        void _iceD_getSessionTimeout(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>) const;
 
        /// Gets the idle timeout used by the server-side of the connection.
        /// @param current The Current object of the incoming request.
        /// @return The idle timeout (in seconds).
        [[nodiscard]] virtual std::int32_t getACMTimeout(const Ice::Current& current) const = 0;
 
        /// @private
        void _iceD_getACMTimeout(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>) const;
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::Glacier2::Router"`.
        static const char* ice_staticId() noexcept;
    };
 
    /// A shared pointer to a Router.
    using RouterPtr = std::shared_ptr<Router>;
}
 
// NOLINTEND(modernize-concat-nested-namespaces)
 
#include <Ice/PopDisableWarnings.h>
#endif