Exception.h

// Copyright (c) ZeroC, Inc.
 
// slice2cpp version 3.8.0-alpha.0
// <auto-generated>Generated from Slice file 'Exception.ice'.</auto-generated>
// clang-format off
 
#ifndef IceGrid_Exception_h_
#define IceGrid_Exception_h_
 
#include <Ice/PushDisableWarnings.h>
#include <Ice/Ice.h>
#include <Ice/BuiltinSequences.h>
#include <Ice/Identity.h>
#include <IceGrid/Config.h>
 
#ifndef ICE_DISABLE_VERSION
#   if ICE_INT_VERSION  != 30850
#       error Ice version mismatch: an exact match is required for beta generated code
#   endif
#endif
 
#ifndef ICEGRID_API
#   if defined(ICEGRID_API_EXPORTS)
#       define ICEGRID_API ICE_DECLSPEC_EXPORT
#   else
#       define ICEGRID_API ICE_DECLSPEC_IMPORT
#   endif
#endif
 
// NOLINTBEGIN(modernize-concat-nested-namespaces)
 
namespace IceGrid
{
}
 
namespace IceGrid
{
    /// The exception that is thrown when IceGrid does not know an application with the provided name.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API ApplicationNotExistException : public Ice::UserException
    {
    public:
        /// Default constructor.
        ApplicationNotExistException() noexcept = default;
 
        /// One-shot constructor to initialize all data members.
        /// @param name The name of the application.
        ApplicationNotExistException(std::string name) noexcept :
            name(std::move(name))
        {
        }
 
        /// Copy constructor.
        ApplicationNotExistException(const ApplicationNotExistException&) 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(name);
        }
 
        void ice_printFields(std::ostream& os) const override;
        /// Gets the type ID of the associated Slice exception.
        /// @return The string `"::IceGrid::ApplicationNotExistException"`.
        static const char* ice_staticId() noexcept;
 
        [[nodiscard]] const char* ice_id() const noexcept override;
 
        void ice_throw() const override;
 
        /// The name of the application.
        std::string name;
 
    protected:
        /// @private
        void _writeImpl(Ice::OutputStream*) const override;
 
        /// @private
        void _readImpl(Ice::InputStream*) override;
    };
 
    /// The exception that is thrown when IceGrid does not know a server with the provided server ID.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API ServerNotExistException : public Ice::UserException
    {
    public:
        /// Default constructor.
        ServerNotExistException() noexcept = default;
 
        /// One-shot constructor to initialize all data members.
        /// @param id The server ID.
        ServerNotExistException(std::string id) noexcept :
            id(std::move(id))
        {
        }
 
        /// Copy constructor.
        ServerNotExistException(const ServerNotExistException&) 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(id);
        }
 
        void ice_printFields(std::ostream& os) const override;
        /// Gets the type ID of the associated Slice exception.
        /// @return The string `"::IceGrid::ServerNotExistException"`.
        static const char* ice_staticId() noexcept;
 
        [[nodiscard]] const char* ice_id() const noexcept override;
 
        void ice_throw() const override;
 
        /// The server ID.
        std::string id;
 
    protected:
        /// @private
        void _writeImpl(Ice::OutputStream*) const override;
 
        /// @private
        void _readImpl(Ice::InputStream*) override;
    };
 
    /// The exception that is thrown when a server failed to start.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API ServerStartException : public Ice::UserException
    {
    public:
        /// Default constructor.
        ServerStartException() noexcept = default;
 
        /// One-shot constructor to initialize all data members.
        /// @param id The server ID.
        /// @param reason The reason for the failure.
        ServerStartException(std::string id, std::string reason) noexcept :
            id(std::move(id)),
            reason(std::move(reason))
        {
        }
 
        /// Copy constructor.
        ServerStartException(const ServerStartException&) 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&, const std::string&> ice_tuple() const
        {
            return std::tie(id, reason);
        }
 
        void ice_printFields(std::ostream& os) const override;
        /// Gets the type ID of the associated Slice exception.
        /// @return The string `"::IceGrid::ServerStartException"`.
        static const char* ice_staticId() noexcept;
 
        [[nodiscard]] const char* ice_id() const noexcept override;
 
        void ice_throw() const override;
 
        /// The server ID.
        std::string id;
 
        /// The reason for the failure.
        std::string reason;
 
    protected:
        /// @private
        void _writeImpl(Ice::OutputStream*) const override;
 
        /// @private
        void _readImpl(Ice::InputStream*) override;
    };
 
    /// The exception that is thrown when a server failed to stop.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API ServerStopException : public Ice::UserException
    {
    public:
        /// Default constructor.
        ServerStopException() noexcept = default;
 
        /// One-shot constructor to initialize all data members.
        /// @param id The server ID.
        /// @param reason The reason for the failure.
        ServerStopException(std::string id, std::string reason) noexcept :
            id(std::move(id)),
            reason(std::move(reason))
        {
        }
 
        /// Copy constructor.
        ServerStopException(const ServerStopException&) 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&, const std::string&> ice_tuple() const
        {
            return std::tie(id, reason);
        }
 
        void ice_printFields(std::ostream& os) const override;
        /// Gets the type ID of the associated Slice exception.
        /// @return The string `"::IceGrid::ServerStopException"`.
        static const char* ice_staticId() noexcept;
 
        [[nodiscard]] const char* ice_id() const noexcept override;
 
        void ice_throw() const override;
 
        /// The server ID.
        std::string id;
 
        /// The reason for the failure.
        std::string reason;
 
    protected:
        /// @private
        void _writeImpl(Ice::OutputStream*) const override;
 
        /// @private
        void _readImpl(Ice::InputStream*) override;
    };
 
    /// The exception that is thrown when IceGrid does not know an object adapter with the provided adapter ID.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API AdapterNotExistException : public Ice::UserException
    {
    public:
        /// Default constructor.
        AdapterNotExistException() noexcept = default;
 
        /// One-shot constructor to initialize all data members.
        /// @param id The adapter ID.
        AdapterNotExistException(std::string id) noexcept :
            id(std::move(id))
        {
        }
 
        /// Copy constructor.
        AdapterNotExistException(const AdapterNotExistException&) 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(id);
        }
 
        void ice_printFields(std::ostream& os) const override;
        /// Gets the type ID of the associated Slice exception.
        /// @return The string `"::IceGrid::AdapterNotExistException"`.
        static const char* ice_staticId() noexcept;
 
        [[nodiscard]] const char* ice_id() const noexcept override;
 
        void ice_throw() const override;
 
        /// The adapter ID.
        std::string id;
 
    protected:
        /// @private
        void _writeImpl(Ice::OutputStream*) const override;
 
        /// @private
        void _readImpl(Ice::InputStream*) override;
    };
 
    /// The exception that is thrown when a well-known object is already registered.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API ObjectExistsException : public Ice::UserException
    {
    public:
        /// Default constructor.
        ObjectExistsException() noexcept = default;
 
        /// One-shot constructor to initialize all data members.
        /// @param id The identity of the object.
        ObjectExistsException(::Ice::Identity id) noexcept :
            id(std::move(id))
        {
        }
 
        /// Copy constructor.
        ObjectExistsException(const ObjectExistsException&) 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 ::Ice::Identity&> ice_tuple() const
        {
            return std::tie(id);
        }
 
        void ice_printFields(std::ostream& os) const override;
        /// Gets the type ID of the associated Slice exception.
        /// @return The string `"::IceGrid::ObjectExistsException"`.
        static const char* ice_staticId() noexcept;
 
        [[nodiscard]] const char* ice_id() const noexcept override;
 
        void ice_throw() const override;
 
        /// The identity of the object.
        ::Ice::Identity id;
 
    protected:
        /// @private
        void _writeImpl(Ice::OutputStream*) const override;
 
        /// @private
        void _readImpl(Ice::InputStream*) override;
    };
 
    /// The exception that is thrown when a well-known object is not registered.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API ObjectNotRegisteredException : public Ice::UserException
    {
    public:
        /// Default constructor.
        ObjectNotRegisteredException() noexcept = default;
 
        /// One-shot constructor to initialize all data members.
        /// @param id The identity of the object.
        ObjectNotRegisteredException(::Ice::Identity id) noexcept :
            id(std::move(id))
        {
        }
 
        /// Copy constructor.
        ObjectNotRegisteredException(const ObjectNotRegisteredException&) 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 ::Ice::Identity&> ice_tuple() const
        {
            return std::tie(id);
        }
 
        void ice_printFields(std::ostream& os) const override;
        /// Gets the type ID of the associated Slice exception.
        /// @return The string `"::IceGrid::ObjectNotRegisteredException"`.
        static const char* ice_staticId() noexcept;
 
        [[nodiscard]] const char* ice_id() const noexcept override;
 
        void ice_throw() const override;
 
        /// The identity of the object.
        ::Ice::Identity id;
 
    protected:
        /// @private
        void _writeImpl(Ice::OutputStream*) const override;
 
        /// @private
        void _readImpl(Ice::InputStream*) override;
    };
 
    /// The exception that is thrown when IceGrid does not know a node with the provided name.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API NodeNotExistException : public Ice::UserException
    {
    public:
        /// Default constructor.
        NodeNotExistException() noexcept = default;
 
        /// One-shot constructor to initialize all data members.
        /// @param name The node name.
        NodeNotExistException(std::string name) noexcept :
            name(std::move(name))
        {
        }
 
        /// Copy constructor.
        NodeNotExistException(const NodeNotExistException&) 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(name);
        }
 
        void ice_printFields(std::ostream& os) const override;
        /// Gets the type ID of the associated Slice exception.
        /// @return The string `"::IceGrid::NodeNotExistException"`.
        static const char* ice_staticId() noexcept;
 
        [[nodiscard]] const char* ice_id() const noexcept override;
 
        void ice_throw() const override;
 
        /// The node name.
        std::string name;
 
    protected:
        /// @private
        void _writeImpl(Ice::OutputStream*) const override;
 
        /// @private
        void _readImpl(Ice::InputStream*) override;
    };
 
    /// The exception that is thrown when IceGrid does not know a registry with the provided name.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API RegistryNotExistException : public Ice::UserException
    {
    public:
        /// Default constructor.
        RegistryNotExistException() noexcept = default;
 
        /// One-shot constructor to initialize all data members.
        /// @param name The registry name.
        RegistryNotExistException(std::string name) noexcept :
            name(std::move(name))
        {
        }
 
        /// Copy constructor.
        RegistryNotExistException(const RegistryNotExistException&) 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(name);
        }
 
        void ice_printFields(std::ostream& os) const override;
        /// Gets the type ID of the associated Slice exception.
        /// @return The string `"::IceGrid::RegistryNotExistException"`.
        static const char* ice_staticId() noexcept;
 
        [[nodiscard]] const char* ice_id() const noexcept override;
 
        void ice_throw() const override;
 
        /// The registry name.
        std::string name;
 
    protected:
        /// @private
        void _writeImpl(Ice::OutputStream*) const override;
 
        /// @private
        void _readImpl(Ice::InputStream*) override;
    };
 
    /// The exception that is thrown when IceGrid cannot deploy a server.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API DeploymentException : public Ice::UserException
    {
    public:
        /// Default constructor.
        DeploymentException() noexcept = default;
 
        /// One-shot constructor to initialize all data members.
        /// @param reason The reason for the failure.
        DeploymentException(std::string reason) noexcept :
            reason(std::move(reason))
        {
        }
 
        /// Copy constructor.
        DeploymentException(const DeploymentException&) 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 `"::IceGrid::DeploymentException"`.
        static const char* ice_staticId() noexcept;
 
        [[nodiscard]] const char* ice_id() const noexcept override;
 
        void ice_throw() const override;
 
        /// The reason for the failure.
        std::string reason;
 
    protected:
        /// @private
        void _writeImpl(Ice::OutputStream*) const override;
 
        /// @private
        void _readImpl(Ice::InputStream*) override;
    };
 
    /// The exception that is thrown when IceGrid cannot reach a node.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API NodeUnreachableException : public Ice::UserException
    {
    public:
        /// Default constructor.
        NodeUnreachableException() noexcept = default;
 
        /// One-shot constructor to initialize all data members.
        /// @param name The name of the node that is not reachable.
        /// @param reason The reason why the node couldn't be reached.
        NodeUnreachableException(std::string name, std::string reason) noexcept :
            name(std::move(name)),
            reason(std::move(reason))
        {
        }
 
        /// Copy constructor.
        NodeUnreachableException(const NodeUnreachableException&) 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&, const std::string&> ice_tuple() const
        {
            return std::tie(name, reason);
        }
 
        void ice_printFields(std::ostream& os) const override;
        /// Gets the type ID of the associated Slice exception.
        /// @return The string `"::IceGrid::NodeUnreachableException"`.
        static const char* ice_staticId() noexcept;
 
        [[nodiscard]] const char* ice_id() const noexcept override;
 
        void ice_throw() const override;
 
        /// The name of the node that is not reachable.
        std::string name;
 
        /// The reason why the node couldn't be reached.
        std::string reason;
 
    protected:
        /// @private
        void _writeImpl(Ice::OutputStream*) const override;
 
        /// @private
        void _readImpl(Ice::InputStream*) override;
    };
 
    /// The exception that is thrown when IceGrid cannot reach a server.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API ServerUnreachableException : public Ice::UserException
    {
    public:
        /// Default constructor.
        ServerUnreachableException() noexcept = default;
 
        /// One-shot constructor to initialize all data members.
        /// @param name The id of the server that is not reachable.
        /// @param reason The reason why the server couldn't be reached.
        ServerUnreachableException(std::string name, std::string reason) noexcept :
            name(std::move(name)),
            reason(std::move(reason))
        {
        }
 
        /// Copy constructor.
        ServerUnreachableException(const ServerUnreachableException&) 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&, const std::string&> ice_tuple() const
        {
            return std::tie(name, reason);
        }
 
        void ice_printFields(std::ostream& os) const override;
        /// Gets the type ID of the associated Slice exception.
        /// @return The string `"::IceGrid::ServerUnreachableException"`.
        static const char* ice_staticId() noexcept;
 
        [[nodiscard]] const char* ice_id() const noexcept override;
 
        void ice_throw() const override;
 
        /// The id of the server that is not reachable.
        std::string name;
 
        /// The reason why the server couldn't be reached.
        std::string reason;
 
    protected:
        /// @private
        void _writeImpl(Ice::OutputStream*) const override;
 
        /// @private
        void _readImpl(Ice::InputStream*) override;
    };
 
    /// The exception that is thrown when IceGrid cannot reach a registry.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API RegistryUnreachableException : public Ice::UserException
    {
    public:
        /// Default constructor.
        RegistryUnreachableException() noexcept = default;
 
        /// One-shot constructor to initialize all data members.
        /// @param name The name of the registry that is not reachable.
        /// @param reason The reason why the registry couldn't be reached.
        RegistryUnreachableException(std::string name, std::string reason) noexcept :
            name(std::move(name)),
            reason(std::move(reason))
        {
        }
 
        /// Copy constructor.
        RegistryUnreachableException(const RegistryUnreachableException&) 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&, const std::string&> ice_tuple() const
        {
            return std::tie(name, reason);
        }
 
        void ice_printFields(std::ostream& os) const override;
        /// Gets the type ID of the associated Slice exception.
        /// @return The string `"::IceGrid::RegistryUnreachableException"`.
        static const char* ice_staticId() noexcept;
 
        [[nodiscard]] const char* ice_id() const noexcept override;
 
        void ice_throw() const override;
 
        /// The name of the registry that is not reachable.
        std::string name;
 
        /// The reason why the registry couldn't be reached.
        std::string reason;
 
    protected:
        /// @private
        void _writeImpl(Ice::OutputStream*) const override;
 
        /// @private
        void _readImpl(Ice::InputStream*) override;
    };
 
    /// The exception that is thrown when an unknown signal is sent to a server.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API BadSignalException : public Ice::UserException
    {
    public:
        /// Default constructor.
        BadSignalException() noexcept = default;
 
        /// One-shot constructor to initialize all data members.
        /// @param reason The details of the unknown signal.
        BadSignalException(std::string reason) noexcept :
            reason(std::move(reason))
        {
        }
 
        /// Copy constructor.
        BadSignalException(const BadSignalException&) 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 `"::IceGrid::BadSignalException"`.
        static const char* ice_staticId() noexcept;
 
        [[nodiscard]] const char* ice_id() const noexcept override;
 
        void ice_throw() const override;
 
        /// The details of the unknown signal.
        std::string reason;
 
    protected:
        /// @private
        void _writeImpl(Ice::OutputStream*) const override;
 
        /// @private
        void _readImpl(Ice::InputStream*) override;
    };
 
    /// The exception that is thrown when the registry update lock cannot be acquired.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API AccessDeniedException : public Ice::UserException
    {
    public:
        /// Default constructor.
        AccessDeniedException() noexcept = default;
 
        /// One-shot constructor to initialize all data members.
        /// @param lockUserId The id of the user holding the lock (if any).
        AccessDeniedException(std::string lockUserId) noexcept :
            lockUserId(std::move(lockUserId))
        {
        }
 
        /// Copy constructor.
        AccessDeniedException(const AccessDeniedException&) 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(lockUserId);
        }
 
        void ice_printFields(std::ostream& os) const override;
        /// Gets the type ID of the associated Slice exception.
        /// @return The string `"::IceGrid::AccessDeniedException"`.
        static const char* ice_staticId() noexcept;
 
        [[nodiscard]] const char* ice_id() const noexcept override;
 
        void ice_throw() const override;
 
        /// The id of the user holding the lock (if any).
        std::string lockUserId;
 
    protected:
        /// @private
        void _writeImpl(Ice::OutputStream*) const override;
 
        /// @private
        void _readImpl(Ice::InputStream*) override;
    };
 
    /// The exception that is thrown when the allocation of an object failed.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API AllocationException : public Ice::UserException
    {
    public:
        /// Default constructor.
        AllocationException() noexcept = default;
 
        /// One-shot constructor to initialize all data members.
        /// @param reason The reason why the object couldn't be allocated.
        AllocationException(std::string reason) noexcept :
            reason(std::move(reason))
        {
        }
 
        /// Copy constructor.
        AllocationException(const AllocationException&) 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 `"::IceGrid::AllocationException"`.
        static const char* ice_staticId() noexcept;
 
        [[nodiscard]] const char* ice_id() const noexcept override;
 
        void ice_throw() const override;
 
        /// The reason why the object couldn't be allocated.
        std::string reason;
 
    protected:
        /// @private
        void _writeImpl(Ice::OutputStream*) const override;
 
        /// @private
        void _readImpl(Ice::InputStream*) override;
    };
 
    /// The exception that is thrown when the request to allocate an object times out.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API AllocationTimeoutException : public AllocationException
    {
    public:
        using AllocationException::AllocationException;
 
        /// Gets the type ID of the associated Slice exception.
        /// @return The string `"::IceGrid::AllocationTimeoutException"`.
        static const char* ice_staticId() noexcept;
 
        [[nodiscard]] const char* ice_id() const noexcept override;
 
        void ice_throw() const override;
 
    protected:
        /// @private
        void _writeImpl(Ice::OutputStream*) const override;
 
        /// @private
        void _readImpl(Ice::InputStream*) override;
    };
 
    /// The exception that is thrown when a client is not allowed to create a session.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API PermissionDeniedException : public Ice::UserException
    {
    public:
        /// Default constructor.
        PermissionDeniedException() noexcept = default;
 
        /// One-shot constructor to initialize all data members.
        /// @param reason The reason why permission was denied.
        PermissionDeniedException(std::string reason) noexcept :
            reason(std::move(reason))
        {
        }
 
        /// Copy constructor.
        PermissionDeniedException(const PermissionDeniedException&) 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 `"::IceGrid::PermissionDeniedException"`.
        static const char* ice_staticId() noexcept;
 
        [[nodiscard]] const char* ice_id() const noexcept override;
 
        void ice_throw() const override;
 
        /// The reason why permission was denied.
        std::string reason;
 
    protected:
        /// @private
        void _writeImpl(Ice::OutputStream*) const override;
 
        /// @private
        void _readImpl(Ice::InputStream*) override;
    };
 
    /// The exception that is thrown when an observer is already registered with the registry.
    /// @see AdminSession#setObservers
    /// @see AdminSession#setObserversByIdentity
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API ObserverAlreadyRegisteredException : public Ice::UserException
    {
    public:
        /// Default constructor.
        ObserverAlreadyRegisteredException() noexcept = default;
 
        /// One-shot constructor to initialize all data members.
        /// @param id The identity of the observer.
        ObserverAlreadyRegisteredException(::Ice::Identity id) noexcept :
            id(std::move(id))
        {
        }
 
        /// Copy constructor.
        ObserverAlreadyRegisteredException(const ObserverAlreadyRegisteredException&) 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 ::Ice::Identity&> ice_tuple() const
        {
            return std::tie(id);
        }
 
        void ice_printFields(std::ostream& os) const override;
        /// Gets the type ID of the associated Slice exception.
        /// @return The string `"::IceGrid::ObserverAlreadyRegisteredException"`.
        static const char* ice_staticId() noexcept;
 
        [[nodiscard]] const char* ice_id() const noexcept override;
 
        void ice_throw() const override;
 
        /// The identity of the observer.
        ::Ice::Identity id;
 
    protected:
        /// @private
        void _writeImpl(Ice::OutputStream*) const override;
 
        /// @private
        void _readImpl(Ice::InputStream*) override;
    };
 
    /// The exception that is thrown when a log file is not available.
    /// @see AdminSession#openServerStdOut
    /// @see AdminSession#openServerStdErr
    /// @see AdminSession#openNodeStdOut
    /// @see AdminSession#openNodeStdErr
    /// @see AdminSession#openRegistryStdOut
    /// @see AdminSession#openRegistryStdErr
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API FileNotAvailableException : public Ice::UserException
    {
    public:
        /// Default constructor.
        FileNotAvailableException() noexcept = default;
 
        /// One-shot constructor to initialize all data members.
        /// @param reason The reason for the failure.
        FileNotAvailableException(std::string reason) noexcept :
            reason(std::move(reason))
        {
        }
 
        /// Copy constructor.
        FileNotAvailableException(const FileNotAvailableException&) 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 `"::IceGrid::FileNotAvailableException"`.
        static const char* ice_staticId() noexcept;
 
        [[nodiscard]] const char* ice_id() const noexcept override;
 
        void ice_throw() const override;
 
        /// The reason for the failure.
        std::string reason;
 
    protected:
        /// @private
        void _writeImpl(Ice::OutputStream*) const override;
 
        /// @private
        void _readImpl(Ice::InputStream*) override;
    };
}
 
// NOLINTEND(modernize-concat-nested-namespaces)
 
#include <Ice/PopDisableWarnings.h>
#endif