Session.h

// Copyright (c) ZeroC, Inc.
 
// slice2cpp version 3.9.0-alpha.0
// <auto-generated>Generated from Slice file 'Session.ice'.</auto-generated>
// clang-format off
 
#ifndef Glacier2_Session_h_
#define Glacier2_Session_h_
 
#include <Ice/PushDisableWarnings.h>
#include <Ice/Ice.h>
#include <Ice/BuiltinSequences.h>
#include <Ice/Identity.h>
#include "SSLInfo.h"
#include <Glacier2/Config.h>
 
#ifndef ICE_DISABLE_VERSION
#   if ICE_INT_VERSION  != 30950
#       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)
 
namespace Glacier2
{
    class RouterPrx;
 
    class SessionPrx;
 
    class StringSetPrx;
 
    class IdentitySetPrx;
 
    class SessionControlPrx;
 
    class SessionManagerPrx;
 
    class SSLSessionManagerPrx;
}
 
namespace Glacier2
{
    /// Represents a session between a client application and the Glacier2 router. With Glacier2, the lifetime of a
    /// session is tied to the Ice connection between the client and the router: the session is destroyed when the
    /// connection is closed.
    /// @remarks The Slice compiler generated this proxy class from Slice interface `::Glacier2::Session`.
    /// @see RouterPrx
    /// @see SessionManagerPrx
    /// @headerfile Glacier2/Glacier2.h
    class GLACIER2_API SessionPrx : public Ice::Proxy<SessionPrx, Ice::ObjectPrx>
    {
    public:
        /// 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.
        SessionPrx(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.
        SessionPrx(const SessionPrx& 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.
        SessionPrx(SessionPrx&& other) noexcept : Ice::ObjectPrx{std::move(other)} {} // NOLINT(modernize-use-equals-default)
 
        ~SessionPrx() 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.
        SessionPrx& operator=(const SessionPrx& 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.
        SessionPrx& operator=(SessionPrx&& rhs) noexcept
        {
            if (this != &rhs)
            {
                Ice::ObjectPrx::operator=(std::move(rhs));
            }
            return *this;
        }
 
        /// Destroys this session.
        /// @param context The request context.
        void destroy(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Destroys this session.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> destroyAsync(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Destroys this session.
        /// @param response The response callback. The Ice runtime calls this function from an Ice thread pool
        /// thread. If you set Ice::InitializationData::executor, the executor determines the thread that executes this
        /// function.
        /// @param exception The exception callback. The Ice runtime calls this function from an Ice thread pool
        /// thread. If you set Ice::InitializationData::executor, the executor determines the thread that executes this
        /// function.
        /// @param sent The sent callback. The Ice runtime calls this function when the request is accepted by the
        /// transport. When the request is accepted synchronously, the Ice runtime calls this function from the current
        /// thread and passes `true` as argument. When the request is accepted asynchronously, the Ice runtime calls
        /// this function from an Ice thread pool thread and passes `false` as argument. If you set
        /// Ice::InitializationData::executor, the executor determines the thread that executes this function in the
        /// asynchronous case.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        /// @remark When this proxy is a oneway or datagram proxy, the Ice runtime does not call the response
        /// callback: a successful invocation completes with the sent callback. When this proxy is a batch
        /// proxy, this function only adds the request to the batch: the Ice runtime calls none of the
        /// callbacks, and the request is sent later, by a flush.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> destroyAsync(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_destroy(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, const Ice::Context&) const;
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::Glacier2::Session"`.
        static const char* ice_staticId() noexcept;
 
        /// @private
        static SessionPrx _fromReference(IceInternal::ReferencePtr ref) { return SessionPrx{std::move(ref)}; }
 
    protected:
        /// @private
        SessionPrx() = default;
 
        /// @private
        explicit SessionPrx(IceInternal::ReferencePtr&& ref) : Ice::ObjectPrx{std::move(ref)}
        {
        }
    };
 
    /// Manages a set of constraints on a SessionPrx.
    /// @remarks The Slice compiler generated this proxy class from Slice interface `::Glacier2::StringSet`.
    /// @see SessionControlPrx
    /// @headerfile Glacier2/Glacier2.h
    class GLACIER2_API StringSetPrx : public Ice::Proxy<StringSetPrx, Ice::ObjectPrx>
    {
    public:
        /// 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.
        StringSetPrx(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.
        StringSetPrx(const StringSetPrx& 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.
        StringSetPrx(StringSetPrx&& other) noexcept : Ice::ObjectPrx{std::move(other)} {} // NOLINT(modernize-use-equals-default)
 
        ~StringSetPrx() 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.
        StringSetPrx& operator=(const StringSetPrx& 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.
        StringSetPrx& operator=(StringSetPrx&& rhs) noexcept
        {
            if (this != &rhs)
            {
                Ice::ObjectPrx::operator=(std::move(rhs));
            }
            return *this;
        }
 
        /// Adds a sequence of strings to this set of constraints. Order is not preserved and duplicates are implicitly
        /// removed.
        /// @param additions The sequence of strings to add.
        /// @param context The request context.
        void add(const ::Ice::StringSeq& additions, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Adds a sequence of strings to this set of constraints. Order is not preserved and duplicates are implicitly
        /// removed.
        /// @param additions The sequence of strings to add.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> addAsync(const ::Ice::StringSeq& additions, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Adds a sequence of strings to this set of constraints. Order is not preserved and duplicates are implicitly
        /// removed.
        /// @param additions The sequence of strings to add.
        /// @param response The response callback. The Ice runtime calls this function from an Ice thread pool
        /// thread. If you set Ice::InitializationData::executor, the executor determines the thread that executes this
        /// function.
        /// @param exception The exception callback. The Ice runtime calls this function from an Ice thread pool
        /// thread. If you set Ice::InitializationData::executor, the executor determines the thread that executes this
        /// function.
        /// @param sent The sent callback. The Ice runtime calls this function when the request is accepted by the
        /// transport. When the request is accepted synchronously, the Ice runtime calls this function from the current
        /// thread and passes `true` as argument. When the request is accepted asynchronously, the Ice runtime calls
        /// this function from an Ice thread pool thread and passes `false` as argument. If you set
        /// Ice::InitializationData::executor, the executor determines the thread that executes this function in the
        /// asynchronous case.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        /// @remark When this proxy is a oneway or datagram proxy, the Ice runtime does not call the response
        /// callback: a successful invocation completes with the sent callback. When this proxy is a batch
        /// proxy, this function only adds the request to the batch: the Ice runtime calls none of the
        /// callbacks, and the request is sent later, by a flush.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> addAsync(const ::Ice::StringSeq& additions, 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_add(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, const ::Ice::StringSeq&, const Ice::Context&) const;
 
        /// Removes a sequence of strings from this set of constraints. No errors are returned if an entry is not found.
        /// @param deletions The sequence of strings to remove.
        /// @param context The request context.
        void remove(const ::Ice::StringSeq& deletions, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Removes a sequence of strings from this set of constraints. No errors are returned if an entry is not found.
        /// @param deletions The sequence of strings to remove.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> removeAsync(const ::Ice::StringSeq& deletions, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Removes a sequence of strings from this set of constraints. No errors are returned if an entry is not found.
        /// @param deletions The sequence of strings to remove.
        /// @param response The response callback. The Ice runtime calls this function from an Ice thread pool
        /// thread. If you set Ice::InitializationData::executor, the executor determines the thread that executes this
        /// function.
        /// @param exception The exception callback. The Ice runtime calls this function from an Ice thread pool
        /// thread. If you set Ice::InitializationData::executor, the executor determines the thread that executes this
        /// function.
        /// @param sent The sent callback. The Ice runtime calls this function when the request is accepted by the
        /// transport. When the request is accepted synchronously, the Ice runtime calls this function from the current
        /// thread and passes `true` as argument. When the request is accepted asynchronously, the Ice runtime calls
        /// this function from an Ice thread pool thread and passes `false` as argument. If you set
        /// Ice::InitializationData::executor, the executor determines the thread that executes this function in the
        /// asynchronous case.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        /// @remark When this proxy is a oneway or datagram proxy, the Ice runtime does not call the response
        /// callback: a successful invocation completes with the sent callback. When this proxy is a batch
        /// proxy, this function only adds the request to the batch: the Ice runtime calls none of the
        /// callbacks, and the request is sent later, by a flush.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> removeAsync(const ::Ice::StringSeq& deletions, 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_remove(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, const ::Ice::StringSeq&, const Ice::Context&) const;
 
        /// Gets a sequence of strings describing the constraints in this set.
        /// @param context The request context.
        /// @return The sequence of strings for this set.
        ::Ice::StringSeq get(const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Gets a sequence of strings describing the constraints in this set.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - The sequence of strings for this set.
        [[nodiscard]] std::future<::Ice::StringSeq> getAsync(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Gets a sequence of strings describing the constraints in this set.
        /// @param response The response callback. The Ice runtime calls this function from an Ice thread pool
        /// thread. If you set Ice::InitializationData::executor, the executor determines the thread that executes this
        /// function. It accepts:
        /// - The sequence of strings for this set.
        /// @param exception The exception callback. The Ice runtime calls this function from an Ice thread pool
        /// thread. If you set Ice::InitializationData::executor, the executor determines the thread that executes this
        /// function.
        /// @param sent The sent callback. The Ice runtime calls this function when the request is accepted by the
        /// transport. When the request is accepted synchronously, the Ice runtime calls this function from the current
        /// thread and passes `true` as argument. When the request is accepted asynchronously, the Ice runtime calls
        /// this function from an Ice thread pool thread and passes `false` as argument. If you set
        /// Ice::InitializationData::executor, the executor determines the thread that executes this function in the
        /// asynchronous case.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> getAsync(std::function<void(::Ice::StringSeq)> 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_get(const std::shared_ptr<IceInternal::OutgoingAsyncT<::Ice::StringSeq>>&, const Ice::Context&) const;
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::Glacier2::StringSet"`.
        static const char* ice_staticId() noexcept;
 
        /// @private
        static StringSetPrx _fromReference(IceInternal::ReferencePtr ref) { return StringSetPrx{std::move(ref)}; }
 
    protected:
        /// @private
        StringSetPrx() = default;
 
        /// @private
        explicit StringSetPrx(IceInternal::ReferencePtr&& ref) : Ice::ObjectPrx{std::move(ref)}
        {
        }
    };
 
    /// Manages a set of object identity constraints on a SessionPrx.
    /// @remarks The Slice compiler generated this proxy class from Slice interface `::Glacier2::IdentitySet`.
    /// @see SessionControlPrx
    /// @headerfile Glacier2/Glacier2.h
    class GLACIER2_API IdentitySetPrx : public Ice::Proxy<IdentitySetPrx, Ice::ObjectPrx>
    {
    public:
        /// 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.
        IdentitySetPrx(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.
        IdentitySetPrx(const IdentitySetPrx& 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.
        IdentitySetPrx(IdentitySetPrx&& other) noexcept : Ice::ObjectPrx{std::move(other)} {} // NOLINT(modernize-use-equals-default)
 
        ~IdentitySetPrx() 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.
        IdentitySetPrx& operator=(const IdentitySetPrx& 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.
        IdentitySetPrx& operator=(IdentitySetPrx&& rhs) noexcept
        {
            if (this != &rhs)
            {
                Ice::ObjectPrx::operator=(std::move(rhs));
            }
            return *this;
        }
 
        /// Adds a sequence of Ice identities to this set of constraints. Order is not preserved and duplicates are
        /// implicitly removed.
        /// @param additions The sequence of Ice identities to add.
        /// @param context The request context.
        void add(const ::Ice::IdentitySeq& additions, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Adds a sequence of Ice identities to this set of constraints. Order is not preserved and duplicates are
        /// implicitly removed.
        /// @param additions The sequence of Ice identities to add.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> addAsync(const ::Ice::IdentitySeq& additions, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Adds a sequence of Ice identities to this set of constraints. Order is not preserved and duplicates are
        /// implicitly removed.
        /// @param additions The sequence of Ice identities to add.
        /// @param response The response callback. The Ice runtime calls this function from an Ice thread pool
        /// thread. If you set Ice::InitializationData::executor, the executor determines the thread that executes this
        /// function.
        /// @param exception The exception callback. The Ice runtime calls this function from an Ice thread pool
        /// thread. If you set Ice::InitializationData::executor, the executor determines the thread that executes this
        /// function.
        /// @param sent The sent callback. The Ice runtime calls this function when the request is accepted by the
        /// transport. When the request is accepted synchronously, the Ice runtime calls this function from the current
        /// thread and passes `true` as argument. When the request is accepted asynchronously, the Ice runtime calls
        /// this function from an Ice thread pool thread and passes `false` as argument. If you set
        /// Ice::InitializationData::executor, the executor determines the thread that executes this function in the
        /// asynchronous case.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        /// @remark When this proxy is a oneway or datagram proxy, the Ice runtime does not call the response
        /// callback: a successful invocation completes with the sent callback. When this proxy is a batch
        /// proxy, this function only adds the request to the batch: the Ice runtime calls none of the
        /// callbacks, and the request is sent later, by a flush.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> addAsync(const ::Ice::IdentitySeq& additions, 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_add(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, const ::Ice::IdentitySeq&, const Ice::Context&) const;
 
        /// Removes a sequence of identities from this set of constraints. No errors are returned if an entry is not
        /// found.
        /// @param deletions The sequence of Ice identities to remove.
        /// @param context The request context.
        void remove(const ::Ice::IdentitySeq& deletions, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Removes a sequence of identities from this set of constraints. No errors are returned if an entry is not
        /// found.
        /// @param deletions The sequence of Ice identities to remove.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> removeAsync(const ::Ice::IdentitySeq& deletions, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Removes a sequence of identities from this set of constraints. No errors are returned if an entry is not
        /// found.
        /// @param deletions The sequence of Ice identities to remove.
        /// @param response The response callback. The Ice runtime calls this function from an Ice thread pool
        /// thread. If you set Ice::InitializationData::executor, the executor determines the thread that executes this
        /// function.
        /// @param exception The exception callback. The Ice runtime calls this function from an Ice thread pool
        /// thread. If you set Ice::InitializationData::executor, the executor determines the thread that executes this
        /// function.
        /// @param sent The sent callback. The Ice runtime calls this function when the request is accepted by the
        /// transport. When the request is accepted synchronously, the Ice runtime calls this function from the current
        /// thread and passes `true` as argument. When the request is accepted asynchronously, the Ice runtime calls
        /// this function from an Ice thread pool thread and passes `false` as argument. If you set
        /// Ice::InitializationData::executor, the executor determines the thread that executes this function in the
        /// asynchronous case.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        /// @remark When this proxy is a oneway or datagram proxy, the Ice runtime does not call the response
        /// callback: a successful invocation completes with the sent callback. When this proxy is a batch
        /// proxy, this function only adds the request to the batch: the Ice runtime calls none of the
        /// callbacks, and the request is sent later, by a flush.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> removeAsync(const ::Ice::IdentitySeq& deletions, 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_remove(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, const ::Ice::IdentitySeq&, const Ice::Context&) const;
 
        /// Gets a sequence of identities describing the constraints in this set.
        /// @param context The request context.
        /// @return The sequence of Ice identities for this set.
        ::Ice::IdentitySeq get(const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Gets a sequence of identities describing the constraints in this set.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - The sequence of Ice identities for this set.
        [[nodiscard]] std::future<::Ice::IdentitySeq> getAsync(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Gets a sequence of identities describing the constraints in this set.
        /// @param response The response callback. The Ice runtime calls this function from an Ice thread pool
        /// thread. If you set Ice::InitializationData::executor, the executor determines the thread that executes this
        /// function. It accepts:
        /// - The sequence of Ice identities for this set.
        /// @param exception The exception callback. The Ice runtime calls this function from an Ice thread pool
        /// thread. If you set Ice::InitializationData::executor, the executor determines the thread that executes this
        /// function.
        /// @param sent The sent callback. The Ice runtime calls this function when the request is accepted by the
        /// transport. When the request is accepted synchronously, the Ice runtime calls this function from the current
        /// thread and passes `true` as argument. When the request is accepted asynchronously, the Ice runtime calls
        /// this function from an Ice thread pool thread and passes `false` as argument. If you set
        /// Ice::InitializationData::executor, the executor determines the thread that executes this function in the
        /// asynchronous case.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> getAsync(std::function<void(::Ice::IdentitySeq)> 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_get(const std::shared_ptr<IceInternal::OutgoingAsyncT<::Ice::IdentitySeq>>&, const Ice::Context&) const;
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::Glacier2::IdentitySet"`.
        static const char* ice_staticId() noexcept;
 
        /// @private
        static IdentitySetPrx _fromReference(IceInternal::ReferencePtr ref) { return IdentitySetPrx{std::move(ref)}; }
 
    protected:
        /// @private
        IdentitySetPrx() = default;
 
        /// @private
        explicit IdentitySetPrx(IceInternal::ReferencePtr&& ref) : Ice::ObjectPrx{std::move(ref)}
        {
        }
    };
 
    /// Represents a router-provided object that allows an application-provided session manager to configure the
    /// routing constraints for a session.
    /// @remarks The Slice compiler generated this proxy class from Slice interface `::Glacier2::SessionControl`.
    /// @see SessionManagerPrx
    /// @headerfile Glacier2/Glacier2.h
    class GLACIER2_API SessionControlPrx : public Ice::Proxy<SessionControlPrx, Ice::ObjectPrx>
    {
    public:
        /// 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.
        SessionControlPrx(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.
        SessionControlPrx(const SessionControlPrx& 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.
        SessionControlPrx(SessionControlPrx&& other) noexcept : Ice::ObjectPrx{std::move(other)} {} // NOLINT(modernize-use-equals-default)
 
        ~SessionControlPrx() 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.
        SessionControlPrx& operator=(const SessionControlPrx& 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.
        SessionControlPrx& operator=(SessionControlPrx&& rhs) noexcept
        {
            if (this != &rhs)
            {
                Ice::ObjectPrx::operator=(std::move(rhs));
            }
            return *this;
        }
 
        /// Gets a proxy to the object that manages the allowable categories for object identities for this session.
        /// @param context The request context.
        /// @return A proxy to a ::Glacier2::StringSetPrx object. This proxy is never null.
        std::optional<StringSetPrx> categories(const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Gets a proxy to the object that manages the allowable categories for object identities for this session.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - A proxy to a ::Glacier2::StringSetPrx object. This proxy is never null.
        [[nodiscard]] std::future<std::optional<StringSetPrx>> categoriesAsync(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Gets a proxy to the object that manages the allowable categories for object identities for this session.
        /// @param response The response callback. The Ice runtime calls this function from an Ice thread pool
        /// thread. If you set Ice::InitializationData::executor, the executor determines the thread that executes this
        /// function. It accepts:
        /// - A proxy to a ::Glacier2::StringSetPrx object. This proxy is never null.
        /// @param exception The exception callback. The Ice runtime calls this function from an Ice thread pool
        /// thread. If you set Ice::InitializationData::executor, the executor determines the thread that executes this
        /// function.
        /// @param sent The sent callback. The Ice runtime calls this function when the request is accepted by the
        /// transport. When the request is accepted synchronously, the Ice runtime calls this function from the current
        /// thread and passes `true` as argument. When the request is accepted asynchronously, the Ice runtime calls
        /// this function from an Ice thread pool thread and passes `false` as argument. If you set
        /// Ice::InitializationData::executor, the executor determines the thread that executes this function in the
        /// asynchronous case.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> categoriesAsync(std::function<void(std::optional<::Glacier2::StringSetPrx>)> 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_categories(const std::shared_ptr<IceInternal::OutgoingAsyncT<std::optional<StringSetPrx>>>&, const Ice::Context&) const;
 
        /// Gets a proxy to the object that manages the allowable adapter identities for objects for this session.
        /// @param context The request context.
        /// @return A proxy to a ::Glacier2::StringSetPrx object. This proxy is never null.
        std::optional<StringSetPrx> adapterIds(const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Gets a proxy to the object that manages the allowable adapter identities for objects for this session.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - A proxy to a ::Glacier2::StringSetPrx object. This proxy is never null.
        [[nodiscard]] std::future<std::optional<StringSetPrx>> adapterIdsAsync(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Gets a proxy to the object that manages the allowable adapter identities for objects for this session.
        /// @param response The response callback. The Ice runtime calls this function from an Ice thread pool
        /// thread. If you set Ice::InitializationData::executor, the executor determines the thread that executes this
        /// function. It accepts:
        /// - A proxy to a ::Glacier2::StringSetPrx object. This proxy is never null.
        /// @param exception The exception callback. The Ice runtime calls this function from an Ice thread pool
        /// thread. If you set Ice::InitializationData::executor, the executor determines the thread that executes this
        /// function.
        /// @param sent The sent callback. The Ice runtime calls this function when the request is accepted by the
        /// transport. When the request is accepted synchronously, the Ice runtime calls this function from the current
        /// thread and passes `true` as argument. When the request is accepted asynchronously, the Ice runtime calls
        /// this function from an Ice thread pool thread and passes `false` as argument. If you set
        /// Ice::InitializationData::executor, the executor determines the thread that executes this function in the
        /// asynchronous case.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> adapterIdsAsync(std::function<void(std::optional<::Glacier2::StringSetPrx>)> 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_adapterIds(const std::shared_ptr<IceInternal::OutgoingAsyncT<std::optional<StringSetPrx>>>&, const Ice::Context&) const;
 
        /// Gets a proxy to the object that manages the allowable object identities for this session.
        /// @param context The request context.
        /// @return A proxy to an ::Glacier2::IdentitySetPrx object. This proxy is never null.
        std::optional<IdentitySetPrx> identities(const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Gets a proxy to the object that manages the allowable object identities for this session.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - A proxy to an ::Glacier2::IdentitySetPrx object. This proxy is never null.
        [[nodiscard]] std::future<std::optional<IdentitySetPrx>> identitiesAsync(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Gets a proxy to the object that manages the allowable object identities for this session.
        /// @param response The response callback. The Ice runtime calls this function from an Ice thread pool
        /// thread. If you set Ice::InitializationData::executor, the executor determines the thread that executes this
        /// function. It accepts:
        /// - A proxy to an ::Glacier2::IdentitySetPrx object. This proxy is never null.
        /// @param exception The exception callback. The Ice runtime calls this function from an Ice thread pool
        /// thread. If you set Ice::InitializationData::executor, the executor determines the thread that executes this
        /// function.
        /// @param sent The sent callback. The Ice runtime calls this function when the request is accepted by the
        /// transport. When the request is accepted synchronously, the Ice runtime calls this function from the current
        /// thread and passes `true` as argument. When the request is accepted asynchronously, the Ice runtime calls
        /// this function from an Ice thread pool thread and passes `false` as argument. If you set
        /// Ice::InitializationData::executor, the executor determines the thread that executes this function in the
        /// asynchronous case.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> identitiesAsync(std::function<void(std::optional<::Glacier2::IdentitySetPrx>)> 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_identities(const std::shared_ptr<IceInternal::OutgoingAsyncT<std::optional<IdentitySetPrx>>>&, const Ice::Context&) const;
 
        /// Gets the session timeout.
        /// @param context The request context.
        /// @return The timeout.
        std::int32_t getSessionTimeout(const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Gets the session timeout.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - The timeout.
        [[nodiscard]] std::future<std::int32_t> getSessionTimeoutAsync(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Gets the session timeout.
        /// @param response The response callback. The Ice runtime calls this function from an Ice thread pool
        /// thread. If you set Ice::InitializationData::executor, the executor determines the thread that executes this
        /// function. It accepts:
        /// - The timeout.
        /// @param exception The exception callback. The Ice runtime calls this function from an Ice thread pool
        /// thread. If you set Ice::InitializationData::executor, the executor determines the thread that executes this
        /// function.
        /// @param sent The sent callback. The Ice runtime calls this function when the request is accepted by the
        /// transport. When the request is accepted synchronously, the Ice runtime calls this function from the current
        /// thread and passes `true` as argument. When the request is accepted asynchronously, the Ice runtime calls
        /// this function from an Ice thread pool thread and passes `false` as argument. If you set
        /// Ice::InitializationData::executor, the executor determines the thread that executes this function in the
        /// asynchronous case.
        /// @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::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_getSessionTimeout(const std::shared_ptr<IceInternal::OutgoingAsyncT<std::int32_t>>&, const Ice::Context&) const;
 
        /// Destroys the associated session.
        /// @param context The request context.
        void destroy(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Destroys the associated session.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> destroyAsync(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Destroys the associated session.
        /// @param response The response callback. The Ice runtime calls this function from an Ice thread pool
        /// thread. If you set Ice::InitializationData::executor, the executor determines the thread that executes this
        /// function.
        /// @param exception The exception callback. The Ice runtime calls this function from an Ice thread pool
        /// thread. If you set Ice::InitializationData::executor, the executor determines the thread that executes this
        /// function.
        /// @param sent The sent callback. The Ice runtime calls this function when the request is accepted by the
        /// transport. When the request is accepted synchronously, the Ice runtime calls this function from the current
        /// thread and passes `true` as argument. When the request is accepted asynchronously, the Ice runtime calls
        /// this function from an Ice thread pool thread and passes `false` as argument. If you set
        /// Ice::InitializationData::executor, the executor determines the thread that executes this function in the
        /// asynchronous case.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        /// @remark When this proxy is a oneway or datagram proxy, the Ice runtime does not call the response
        /// callback: a successful invocation completes with the sent callback. When this proxy is a batch
        /// proxy, this function only adds the request to the batch: the Ice runtime calls none of the
        /// callbacks, and the request is sent later, by a flush.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> destroyAsync(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_destroy(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, const Ice::Context&) const;
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::Glacier2::SessionControl"`.
        static const char* ice_staticId() noexcept;
 
        /// @private
        static SessionControlPrx _fromReference(IceInternal::ReferencePtr ref) { return SessionControlPrx{std::move(ref)}; }
 
    protected:
        /// @private
        SessionControlPrx() = default;
 
        /// @private
        explicit SessionControlPrx(IceInternal::ReferencePtr&& ref) : Ice::ObjectPrx{std::move(ref)}
        {
        }
    };
 
    /// Represents an application-provided factory for session objects. You can configure a Glacier2 router with your
    /// own SessionManager implementation; this router will then return the sessions created by this session manager to
    /// its clients.
    /// @remarks The Slice compiler generated this proxy class from Slice interface `::Glacier2::SessionManager`.
    /// @headerfile Glacier2/Glacier2.h
    class GLACIER2_API SessionManagerPrx : public Ice::Proxy<SessionManagerPrx, Ice::ObjectPrx>
    {
    public:
        /// 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.
        SessionManagerPrx(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.
        SessionManagerPrx(const SessionManagerPrx& 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.
        SessionManagerPrx(SessionManagerPrx&& other) noexcept : Ice::ObjectPrx{std::move(other)} {} // NOLINT(modernize-use-equals-default)
 
        ~SessionManagerPrx() 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.
        SessionManagerPrx& operator=(const SessionManagerPrx& 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.
        SessionManagerPrx& operator=(SessionManagerPrx&& rhs) noexcept
        {
            if (this != &rhs)
            {
                Ice::ObjectPrx::operator=(std::move(rhs));
            }
            return *this;
        }
 
        /// Creates a new session object.
        /// @param userId The user ID for the session.
        /// @param control A proxy to the session control object. This proxy is null when `Glacier2.Server.Endpoints`
        /// is not configured.
        /// @param context The request context.
        /// @return A proxy to the newly created session. This proxy is never null.
        /// @throws Glacier2::CannotCreateSessionException Thrown when the session cannot be created.
        std::optional<SessionPrx> create(std::string_view userId, const std::optional<SessionControlPrx>& control, const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Creates a new session object.
        /// @param userId The user ID for the session.
        /// @param control A proxy to the session control object. This proxy is null when `Glacier2.Server.Endpoints`
        /// is not configured.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - A proxy to the newly created session. This proxy is never null.
        [[nodiscard]] std::future<std::optional<SessionPrx>> createAsync(std::string_view userId, const std::optional<SessionControlPrx>& control, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Creates a new session object.
        /// @param userId The user ID for the session.
        /// @param control A proxy to the session control object. This proxy is null when `Glacier2.Server.Endpoints`
        /// is not configured.
        /// @param response The response callback. The Ice runtime calls this function from an Ice thread pool
        /// thread. If you set Ice::InitializationData::executor, the executor determines the thread that executes this
        /// function. It accepts:
        /// - A proxy to the newly created session. This proxy is never null.
        /// @param exception The exception callback. The Ice runtime calls this function from an Ice thread pool
        /// thread. If you set Ice::InitializationData::executor, the executor determines the thread that executes this
        /// function.
        /// @param sent The sent callback. The Ice runtime calls this function when the request is accepted by the
        /// transport. When the request is accepted synchronously, the Ice runtime calls this function from the current
        /// thread and passes `true` as argument. When the request is accepted asynchronously, the Ice runtime calls
        /// this function from an Ice thread pool thread and passes `false` as argument. If you set
        /// Ice::InitializationData::executor, the executor determines the thread that executes this function in the
        /// asynchronous case.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> createAsync(std::string_view userId, const std::optional<SessionControlPrx>& control, 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_create(const std::shared_ptr<IceInternal::OutgoingAsyncT<std::optional<SessionPrx>>>&, std::string_view, const std::optional<SessionControlPrx>&, const Ice::Context&) const;
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::Glacier2::SessionManager"`.
        static const char* ice_staticId() noexcept;
 
        /// @private
        static SessionManagerPrx _fromReference(IceInternal::ReferencePtr ref) { return SessionManagerPrx{std::move(ref)}; }
 
    protected:
        /// @private
        SessionManagerPrx() = default;
 
        /// @private
        explicit SessionManagerPrx(IceInternal::ReferencePtr&& ref) : Ice::ObjectPrx{std::move(ref)}
        {
        }
    };
 
    /// Represents an application-provided factory for session objects. You can configure a Glacier2 router with your
    /// own SSLSessionManager implementation; this router will then return the sessions created by this session manager
    /// to its clients.
    /// @remarks The Slice compiler generated this proxy class from Slice interface `::Glacier2::SSLSessionManager`.
    /// @headerfile Glacier2/Glacier2.h
    class GLACIER2_API SSLSessionManagerPrx : public Ice::Proxy<SSLSessionManagerPrx, Ice::ObjectPrx>
    {
    public:
        /// 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.
        SSLSessionManagerPrx(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.
        SSLSessionManagerPrx(const SSLSessionManagerPrx& 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.
        SSLSessionManagerPrx(SSLSessionManagerPrx&& other) noexcept : Ice::ObjectPrx{std::move(other)} {} // NOLINT(modernize-use-equals-default)
 
        ~SSLSessionManagerPrx() 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.
        SSLSessionManagerPrx& operator=(const SSLSessionManagerPrx& 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.
        SSLSessionManagerPrx& operator=(SSLSessionManagerPrx&& rhs) noexcept
        {
            if (this != &rhs)
            {
                Ice::ObjectPrx::operator=(std::move(rhs));
            }
            return *this;
        }
 
        /// Creates a new session object.
        /// @param info The SSL info.
        /// @param control A proxy to the session control object. This proxy is null when `Glacier2.Server.Endpoints`
        /// is not configured.
        /// @param context The request context.
        /// @return A proxy to the newly created session. This proxy is never null.
        /// @throws Glacier2::CannotCreateSessionException Thrown when the session cannot be created.
        std::optional<SessionPrx> create(const SSLInfo& info, const std::optional<SessionControlPrx>& control, const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Creates a new session object.
        /// @param info The SSL info.
        /// @param control A proxy to the session control object. This proxy is null when `Glacier2.Server.Endpoints`
        /// is not configured.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - A proxy to the newly created session. This proxy is never null.
        [[nodiscard]] std::future<std::optional<SessionPrx>> createAsync(const SSLInfo& info, const std::optional<SessionControlPrx>& control, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Creates a new session object.
        /// @param info The SSL info.
        /// @param control A proxy to the session control object. This proxy is null when `Glacier2.Server.Endpoints`
        /// is not configured.
        /// @param response The response callback. The Ice runtime calls this function from an Ice thread pool
        /// thread. If you set Ice::InitializationData::executor, the executor determines the thread that executes this
        /// function. It accepts:
        /// - A proxy to the newly created session. This proxy is never null.
        /// @param exception The exception callback. The Ice runtime calls this function from an Ice thread pool
        /// thread. If you set Ice::InitializationData::executor, the executor determines the thread that executes this
        /// function.
        /// @param sent The sent callback. The Ice runtime calls this function when the request is accepted by the
        /// transport. When the request is accepted synchronously, the Ice runtime calls this function from the current
        /// thread and passes `true` as argument. When the request is accepted asynchronously, the Ice runtime calls
        /// this function from an Ice thread pool thread and passes `false` as argument. If you set
        /// Ice::InitializationData::executor, the executor determines the thread that executes this function in the
        /// asynchronous case.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> createAsync(const SSLInfo& info, const std::optional<SessionControlPrx>& control, 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_create(const std::shared_ptr<IceInternal::OutgoingAsyncT<std::optional<SessionPrx>>>&, const SSLInfo&, const std::optional<SessionControlPrx>&, const Ice::Context&) const;
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::Glacier2::SSLSessionManager"`.
        static const char* ice_staticId() noexcept;
 
        /// @private
        static SSLSessionManagerPrx _fromReference(IceInternal::ReferencePtr ref) { return SSLSessionManagerPrx{std::move(ref)}; }
 
    protected:
        /// @private
        SSLSessionManagerPrx() = default;
 
        /// @private
        explicit SSLSessionManagerPrx(IceInternal::ReferencePtr&& ref) : Ice::ObjectPrx{std::move(ref)}
        {
        }
    };
}
 
namespace Glacier2
{
    /// The exception that is thrown when an attempt to create a new session fails.
    /// @remarks The Slice compiler generated this exception class from Slice exception `::Glacier2::CannotCreateSessionException`.
    /// @headerfile Glacier2/Glacier2.h
    class GLACIER2_API CannotCreateSessionException : public Ice::UserException
    {
    public:
        /// Default constructor.
        CannotCreateSessionException() noexcept = default;
 
        /// One-shot constructor to initialize all data members.
        /// @param reason The reason why the session creation failed.
        CannotCreateSessionException(std::string reason) noexcept :
            reason(std::move(reason))
        {
        }
 
        /// Copy constructor.
        CannotCreateSessionException(const CannotCreateSessionException&) noexcept = default;
 
        /// Creates a tuple with all the fields of this exception.
        /// @return A tuple with all the fields of this exception.
        [[nodiscard]] std::tuple<const std::string&> ice_tuple() const
        {
            return std::tie(reason);
        }
 
        void ice_printFields(std::ostream& os) const override;
        /// Gets the type ID of the associated Slice exception.
        /// @return The string `"::Glacier2::CannotCreateSessionException"`.
        static const char* ice_staticId() noexcept;
 
        [[nodiscard]] const char* ice_id() const noexcept override;
 
        void ice_throw() const override;
 
        /// The reason why the session creation failed.
        std::string reason;
 
    protected:
        /// @private
        void _writeImpl(Ice::OutputStream*) const override;
 
        /// @private
        void _readImpl(Ice::InputStream*) override;
    };
}
 
namespace Glacier2
{
    /// Represents a session between a client application and the Glacier2 router. With Glacier2, the lifetime of a
    /// session is tied to the Ice connection between the client and the router: the session is destroyed when the
    /// connection is closed.
    /// @remarks The Slice compiler generated this skeleton class from Slice interface `::Glacier2::Session`.
    /// @see RouterPrx
    /// @see SessionManagerPrx
    /// @headerfile Glacier2/Glacier2.h
    class GLACIER2_API Session : public virtual Ice::Object
    {
    public:
        /// The associated proxy type.
        using ProxyType = SessionPrx;
 
        /// 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;
 
        /// Destroys this session.
        /// @param current The Current object of the incoming request.
        virtual void destroy(const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_destroy(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::Glacier2::Session"`.
        static const char* ice_staticId() noexcept;
    };
 
    /// A shared pointer to a Session.
    using SessionPtr = std::shared_ptr<Session>;
 
    /// Manages a set of constraints on a SessionPrx.
    /// @remarks The Slice compiler generated this skeleton class from Slice interface `::Glacier2::StringSet`.
    /// @see SessionControlPrx
    /// @headerfile Glacier2/Glacier2.h
    class GLACIER2_API StringSet : public virtual Ice::Object
    {
    public:
        /// The associated proxy type.
        using ProxyType = StringSetPrx;
 
        /// 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;
 
        /// Adds a sequence of strings to this set of constraints. Order is not preserved and duplicates are implicitly
        /// removed.
        /// @param additions The sequence of strings to add.
        /// @param current The Current object of the incoming request.
        virtual void add(::Ice::StringSeq additions, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_add(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Removes a sequence of strings from this set of constraints. No errors are returned if an entry is not found.
        /// @param deletions The sequence of strings to remove.
        /// @param current The Current object of the incoming request.
        virtual void remove(::Ice::StringSeq deletions, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_remove(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets a sequence of strings describing the constraints in this set.
        /// @param current The Current object of the incoming request.
        /// @return The sequence of strings for this set.
        virtual ::Ice::StringSeq get(const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_get(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::Glacier2::StringSet"`.
        static const char* ice_staticId() noexcept;
    };
 
    /// A shared pointer to a StringSet.
    using StringSetPtr = std::shared_ptr<StringSet>;
 
    /// Manages a set of object identity constraints on a SessionPrx.
    /// @remarks The Slice compiler generated this skeleton class from Slice interface `::Glacier2::IdentitySet`.
    /// @see SessionControlPrx
    /// @headerfile Glacier2/Glacier2.h
    class GLACIER2_API IdentitySet : public virtual Ice::Object
    {
    public:
        /// The associated proxy type.
        using ProxyType = IdentitySetPrx;
 
        /// 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;
 
        /// Adds a sequence of Ice identities to this set of constraints. Order is not preserved and duplicates are
        /// implicitly removed.
        /// @param additions The sequence of Ice identities to add.
        /// @param current The Current object of the incoming request.
        virtual void add(::Ice::IdentitySeq additions, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_add(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Removes a sequence of identities from this set of constraints. No errors are returned if an entry is not
        /// found.
        /// @param deletions The sequence of Ice identities to remove.
        /// @param current The Current object of the incoming request.
        virtual void remove(::Ice::IdentitySeq deletions, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_remove(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets a sequence of identities describing the constraints in this set.
        /// @param current The Current object of the incoming request.
        /// @return The sequence of Ice identities for this set.
        virtual ::Ice::IdentitySeq get(const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_get(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::Glacier2::IdentitySet"`.
        static const char* ice_staticId() noexcept;
    };
 
    /// A shared pointer to an IdentitySet.
    using IdentitySetPtr = std::shared_ptr<IdentitySet>;
 
    /// Represents a router-provided object that allows an application-provided session manager to configure the
    /// routing constraints for a session.
    /// @remarks The Slice compiler generated this skeleton class from Slice interface `::Glacier2::SessionControl`.
    /// @see SessionManagerPrx
    /// @headerfile Glacier2/Glacier2.h
    class GLACIER2_API SessionControl : public virtual Ice::Object
    {
    public:
        /// The associated proxy type.
        using ProxyType = SessionControlPrx;
 
        /// 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 proxy to the object that manages the allowable categories for object identities for this session.
        /// @param current The Current object of the incoming request.
        /// @return A proxy to a ::Glacier2::StringSetPrx object. This proxy is never null.
        virtual std::optional<StringSetPrx> categories(const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_categories(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets a proxy to the object that manages the allowable adapter identities for objects for this session.
        /// @param current The Current object of the incoming request.
        /// @return A proxy to a ::Glacier2::StringSetPrx object. This proxy is never null.
        virtual std::optional<StringSetPrx> adapterIds(const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_adapterIds(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets a proxy to the object that manages the allowable object identities for this session.
        /// @param current The Current object of the incoming request.
        /// @return A proxy to an ::Glacier2::IdentitySetPrx object. This proxy is never null.
        virtual std::optional<IdentitySetPrx> identities(const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_identities(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets the session timeout.
        /// @param current The Current object of the incoming request.
        /// @return The timeout.
        virtual std::int32_t getSessionTimeout(const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_getSessionTimeout(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Destroys the associated session.
        /// @param current The Current object of the incoming request.
        virtual void destroy(const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_destroy(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::Glacier2::SessionControl"`.
        static const char* ice_staticId() noexcept;
    };
 
    /// A shared pointer to a SessionControl.
    using SessionControlPtr = std::shared_ptr<SessionControl>;
 
    /// Represents an application-provided factory for session objects. You can configure a Glacier2 router with your
    /// own SessionManager implementation; this router will then return the sessions created by this session manager to
    /// its clients.
    /// @remarks The Slice compiler generated this skeleton class from Slice interface `::Glacier2::SessionManager`.
    /// @headerfile Glacier2/Glacier2.h
    class GLACIER2_API SessionManager : public virtual Ice::Object
    {
    public:
        /// The associated proxy type.
        using ProxyType = SessionManagerPrx;
 
        /// 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;
 
        /// Creates a new session object.
        /// @param userId The user ID for the session.
        /// @param control A proxy to the session control object. This proxy is null when `Glacier2.Server.Endpoints`
        /// is not configured.
        /// @param current The Current object of the incoming request.
        /// @return A proxy to the newly created session. This proxy is never null.
        /// @throws Glacier2::CannotCreateSessionException Thrown when the session cannot be created.
        virtual std::optional<SessionPrx> create(std::string userId, std::optional<SessionControlPrx> control, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_create(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::Glacier2::SessionManager"`.
        static const char* ice_staticId() noexcept;
    };
 
    /// A shared pointer to a SessionManager.
    using SessionManagerPtr = std::shared_ptr<SessionManager>;
 
    /// Represents an application-provided factory for session objects. You can configure a Glacier2 router with your
    /// own SSLSessionManager implementation; this router will then return the sessions created by this session manager
    /// to its clients.
    /// @remarks The Slice compiler generated this skeleton class from Slice interface `::Glacier2::SSLSessionManager`.
    /// @headerfile Glacier2/Glacier2.h
    class GLACIER2_API SSLSessionManager : public virtual Ice::Object
    {
    public:
        /// The associated proxy type.
        using ProxyType = SSLSessionManagerPrx;
 
        /// 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;
 
        /// Creates a new session object.
        /// @param info The SSL info.
        /// @param control A proxy to the session control object. This proxy is null when `Glacier2.Server.Endpoints`
        /// is not configured.
        /// @param current The Current object of the incoming request.
        /// @return A proxy to the newly created session. This proxy is never null.
        /// @throws Glacier2::CannotCreateSessionException Thrown when the session cannot be created.
        virtual std::optional<SessionPrx> create(SSLInfo info, std::optional<SessionControlPrx> control, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_create(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::Glacier2::SSLSessionManager"`.
        static const char* ice_staticId() noexcept;
    };
 
    /// A shared pointer to a SSLSessionManager.
    using SSLSessionManagerPtr = std::shared_ptr<SSLSessionManager>;
}
 
namespace Glacier2
{
    /// Represents a session between a client application and the Glacier2 router. With Glacier2, the lifetime of a
    /// session is tied to the Ice connection between the client and the router: the session is destroyed when the
    /// connection is closed.
    /// @remarks The Slice compiler generated this skeleton class from Slice interface `::Glacier2::Session`.
    /// @see RouterPrx
    /// @see SessionManagerPrx
    /// @headerfile Glacier2/Glacier2.h
    class GLACIER2_API AsyncSession : public virtual Ice::Object
    {
    public:
        /// The associated proxy type.
        using ProxyType = SessionPrx;
 
        /// 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;
 
        /// Destroys this session.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param current The Current object of the incoming request.
        virtual void destroyAsync(std::function<void()> response, std::function<void(std::exception_ptr)> exception, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_destroy(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::Glacier2::Session"`.
        static const char* ice_staticId() noexcept;
    };
 
    /// A shared pointer to an AsyncSession.
    using AsyncSessionPtr = std::shared_ptr<AsyncSession>;
 
    /// Manages a set of constraints on a SessionPrx.
    /// @remarks The Slice compiler generated this skeleton class from Slice interface `::Glacier2::StringSet`.
    /// @see SessionControlPrx
    /// @headerfile Glacier2/Glacier2.h
    class GLACIER2_API AsyncStringSet : public virtual Ice::Object
    {
    public:
        /// The associated proxy type.
        using ProxyType = StringSetPrx;
 
        /// 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;
 
        /// Adds a sequence of strings to this set of constraints. Order is not preserved and duplicates are implicitly
        /// removed.
        /// @param additions The sequence of strings to add.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param current The Current object of the incoming request.
        virtual void addAsync(::Ice::StringSeq additions, std::function<void()> response, std::function<void(std::exception_ptr)> exception, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_add(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Removes a sequence of strings from this set of constraints. No errors are returned if an entry is not found.
        /// @param deletions The sequence of strings to remove.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param current The Current object of the incoming request.
        virtual void removeAsync(::Ice::StringSeq deletions, std::function<void()> response, std::function<void(std::exception_ptr)> exception, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_remove(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets a sequence of strings describing the constraints in this set.
        /// @param response The response callback. It accepts:
        /// - The sequence of strings for this set.
        /// @param exception The exception callback.
        /// @param current The Current object of the incoming request.
        virtual void getAsync(std::function<void(const ::Ice::StringSeq& returnValue)> response, std::function<void(std::exception_ptr)> exception, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_get(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::Glacier2::StringSet"`.
        static const char* ice_staticId() noexcept;
    };
 
    /// A shared pointer to an AsyncStringSet.
    using AsyncStringSetPtr = std::shared_ptr<AsyncStringSet>;
 
    /// Manages a set of object identity constraints on a SessionPrx.
    /// @remarks The Slice compiler generated this skeleton class from Slice interface `::Glacier2::IdentitySet`.
    /// @see SessionControlPrx
    /// @headerfile Glacier2/Glacier2.h
    class GLACIER2_API AsyncIdentitySet : public virtual Ice::Object
    {
    public:
        /// The associated proxy type.
        using ProxyType = IdentitySetPrx;
 
        /// 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;
 
        /// Adds a sequence of Ice identities to this set of constraints. Order is not preserved and duplicates are
        /// implicitly removed.
        /// @param additions The sequence of Ice identities to add.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param current The Current object of the incoming request.
        virtual void addAsync(::Ice::IdentitySeq additions, std::function<void()> response, std::function<void(std::exception_ptr)> exception, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_add(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Removes a sequence of identities from this set of constraints. No errors are returned if an entry is not
        /// found.
        /// @param deletions The sequence of Ice identities to remove.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param current The Current object of the incoming request.
        virtual void removeAsync(::Ice::IdentitySeq deletions, std::function<void()> response, std::function<void(std::exception_ptr)> exception, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_remove(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets a sequence of identities describing the constraints in this set.
        /// @param response The response callback. It accepts:
        /// - The sequence of Ice identities for this set.
        /// @param exception The exception callback.
        /// @param current The Current object of the incoming request.
        virtual void getAsync(std::function<void(const ::Ice::IdentitySeq& returnValue)> response, std::function<void(std::exception_ptr)> exception, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_get(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::Glacier2::IdentitySet"`.
        static const char* ice_staticId() noexcept;
    };
 
    /// A shared pointer to an AsyncIdentitySet.
    using AsyncIdentitySetPtr = std::shared_ptr<AsyncIdentitySet>;
 
    /// Represents a router-provided object that allows an application-provided session manager to configure the
    /// routing constraints for a session.
    /// @remarks The Slice compiler generated this skeleton class from Slice interface `::Glacier2::SessionControl`.
    /// @see SessionManagerPrx
    /// @headerfile Glacier2/Glacier2.h
    class GLACIER2_API AsyncSessionControl : public virtual Ice::Object
    {
    public:
        /// The associated proxy type.
        using ProxyType = SessionControlPrx;
 
        /// 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 proxy to the object that manages the allowable categories for object identities for this session.
        /// @param response The response callback. It accepts:
        /// - A proxy to a ::Glacier2::StringSetPrx object. This proxy is never null.
        /// @param exception The exception callback.
        /// @param current The Current object of the incoming request.
        virtual void categoriesAsync(std::function<void(const std::optional<StringSetPrx>& returnValue)> response, std::function<void(std::exception_ptr)> exception, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_categories(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets a proxy to the object that manages the allowable adapter identities for objects for this session.
        /// @param response The response callback. It accepts:
        /// - A proxy to a ::Glacier2::StringSetPrx object. This proxy is never null.
        /// @param exception The exception callback.
        /// @param current The Current object of the incoming request.
        virtual void adapterIdsAsync(std::function<void(const std::optional<StringSetPrx>& returnValue)> response, std::function<void(std::exception_ptr)> exception, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_adapterIds(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets a proxy to the object that manages the allowable object identities for this session.
        /// @param response The response callback. It accepts:
        /// - A proxy to an ::Glacier2::IdentitySetPrx object. This proxy is never null.
        /// @param exception The exception callback.
        /// @param current The Current object of the incoming request.
        virtual void identitiesAsync(std::function<void(const std::optional<IdentitySetPrx>& returnValue)> response, std::function<void(std::exception_ptr)> exception, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_identities(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets the session timeout.
        /// @param response The response callback. It accepts:
        /// - The timeout.
        /// @param exception The exception callback.
        /// @param current The Current object of the incoming request.
        virtual void getSessionTimeoutAsync(std::function<void(std::int32_t returnValue)> response, std::function<void(std::exception_ptr)> exception, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_getSessionTimeout(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Destroys the associated session.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param current The Current object of the incoming request.
        virtual void destroyAsync(std::function<void()> response, std::function<void(std::exception_ptr)> exception, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_destroy(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::Glacier2::SessionControl"`.
        static const char* ice_staticId() noexcept;
    };
 
    /// A shared pointer to an AsyncSessionControl.
    using AsyncSessionControlPtr = std::shared_ptr<AsyncSessionControl>;
 
    /// Represents an application-provided factory for session objects. You can configure a Glacier2 router with your
    /// own SessionManager implementation; this router will then return the sessions created by this session manager to
    /// its clients.
    /// @remarks The Slice compiler generated this skeleton class from Slice interface `::Glacier2::SessionManager`.
    /// @headerfile Glacier2/Glacier2.h
    class GLACIER2_API AsyncSessionManager : public virtual Ice::Object
    {
    public:
        /// The associated proxy type.
        using ProxyType = SessionManagerPrx;
 
        /// 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;
 
        /// Creates a new session object.
        /// @param userId The user ID for the session.
        /// @param control A proxy to the session control object. This proxy is null when `Glacier2.Server.Endpoints`
        /// is not configured.
        /// @param response The response callback. It accepts:
        /// - A proxy to the newly created session. This proxy is never null.
        /// @param exception The exception callback.
        /// @param current The Current object of the incoming request.
        /// @throws Glacier2::CannotCreateSessionException Thrown when the session cannot be created.
        virtual void createAsync(std::string userId, std::optional<SessionControlPrx> control, std::function<void(const std::optional<SessionPrx>& returnValue)> response, std::function<void(std::exception_ptr)> exception, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_create(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::Glacier2::SessionManager"`.
        static const char* ice_staticId() noexcept;
    };
 
    /// A shared pointer to an AsyncSessionManager.
    using AsyncSessionManagerPtr = std::shared_ptr<AsyncSessionManager>;
 
    /// Represents an application-provided factory for session objects. You can configure a Glacier2 router with your
    /// own SSLSessionManager implementation; this router will then return the sessions created by this session manager
    /// to its clients.
    /// @remarks The Slice compiler generated this skeleton class from Slice interface `::Glacier2::SSLSessionManager`.
    /// @headerfile Glacier2/Glacier2.h
    class GLACIER2_API AsyncSSLSessionManager : public virtual Ice::Object
    {
    public:
        /// The associated proxy type.
        using ProxyType = SSLSessionManagerPrx;
 
        /// 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;
 
        /// Creates a new session object.
        /// @param info The SSL info.
        /// @param control A proxy to the session control object. This proxy is null when `Glacier2.Server.Endpoints`
        /// is not configured.
        /// @param response The response callback. It accepts:
        /// - A proxy to the newly created session. This proxy is never null.
        /// @param exception The exception callback.
        /// @param current The Current object of the incoming request.
        /// @throws Glacier2::CannotCreateSessionException Thrown when the session cannot be created.
        virtual void createAsync(SSLInfo info, std::optional<SessionControlPrx> control, std::function<void(const std::optional<SessionPrx>& returnValue)> response, std::function<void(std::exception_ptr)> exception, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_create(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::Glacier2::SSLSessionManager"`.
        static const char* ice_staticId() noexcept;
    };
 
    /// A shared pointer to an AsyncSSLSessionManager.
    using AsyncSSLSessionManagerPtr = std::shared_ptr<AsyncSSLSessionManager>;
}
 
// NOLINTEND(modernize-concat-nested-namespaces)
 
#include <Ice/PopDisableWarnings.h>
#endif