Descriptor.h

// Copyright (c) ZeroC, Inc.
 
// slice2cpp version 3.8.0
// <auto-generated>Generated from Slice file 'Descriptor.ice'.</auto-generated>
// clang-format off
 
#ifndef IceGrid_Descriptor_h_
#define IceGrid_Descriptor_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 / 100 != 308
#       error Ice version mismatch!
#   endif
#   if ICE_INT_VERSION % 100 >= 50
#       error Beta header file detected
#   endif
#   if ICE_INT_VERSION % 100 < 0
#       error Ice patch level mismatch!
#   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
{
    /// A mapping of string to string.
    using StringStringDict = std::map<std::string, std::string>;
 
    struct PropertyDescriptor;
 
    /// A sequence of PropertyDescriptor.
    using PropertyDescriptorSeq = std::vector<PropertyDescriptor>;
 
    struct PropertySetDescriptor;
 
    /// A mapping of property set name to property set descriptor.
    using PropertySetDescriptorDict = std::map<std::string, PropertySetDescriptor>;
 
    struct ObjectDescriptor;
 
    /// A sequence of ObjectDescriptor.
    using ObjectDescriptorSeq = std::vector<ObjectDescriptor>;
 
    struct AdapterDescriptor;
 
    /// A sequence of AdapterDescriptor.
    using AdapterDescriptorSeq = std::vector<AdapterDescriptor>;
 
    struct [[deprecated("This descriptor is provided for schema compatibility. It is no longer used.")]] DbEnvDescriptor;
 
    /// A sequence of DbEnvDescriptor.
    using DbEnvDescriptorSeq [[deprecated("This descriptor is provided for schema compatibility. It is no longer used.")]] = std::vector<DbEnvDescriptor>;
 
    class CommunicatorDescriptor;
 
    /// A shared pointer to a CommunicatorDescriptor.
    using CommunicatorDescriptorPtr = std::shared_ptr<CommunicatorDescriptor>;
 
    struct [[deprecated("This descriptor is provided for schema compatibility. It is no longer used.")]] DistributionDescriptor;
 
    class ServerDescriptor;
 
    /// A shared pointer to a ServerDescriptor.
    using ServerDescriptorPtr = std::shared_ptr<ServerDescriptor>;
 
    /// A sequence of ServerDescriptor.
    using ServerDescriptorSeq = std::vector<ServerDescriptorPtr>;
 
    class ServiceDescriptor;
 
    /// A shared pointer to a ServiceDescriptor.
    using ServiceDescriptorPtr = std::shared_ptr<ServiceDescriptor>;
 
    /// A sequence of ServiceDescriptor.
    using ServiceDescriptorSeq = std::vector<ServiceDescriptorPtr>;
 
    struct ServerInstanceDescriptor;
 
    /// A sequence of ServerInstanceDescriptor.
    using ServerInstanceDescriptorSeq = std::vector<ServerInstanceDescriptor>;
 
    struct TemplateDescriptor;
 
    /// A mapping of template identifier to template descriptor.
    using TemplateDescriptorDict = std::map<std::string, TemplateDescriptor>;
 
    struct ServiceInstanceDescriptor;
 
    /// A sequence of ServiceInstanceDescriptor.
    using ServiceInstanceDescriptorSeq = std::vector<ServiceInstanceDescriptor>;
 
    class IceBoxDescriptor;
 
    /// A shared pointer to an IceBoxDescriptor.
    using IceBoxDescriptorPtr = std::shared_ptr<IceBoxDescriptor>;
 
    struct NodeDescriptor;
 
    /// Mapping of node name to node descriptor.
    using NodeDescriptorDict = std::map<std::string, NodeDescriptor>;
 
    class LoadBalancingPolicy;
 
    /// A shared pointer to a LoadBalancingPolicy.
    using LoadBalancingPolicyPtr = std::shared_ptr<LoadBalancingPolicy>;
 
    class RandomLoadBalancingPolicy;
 
    /// A shared pointer to a RandomLoadBalancingPolicy.
    using RandomLoadBalancingPolicyPtr = std::shared_ptr<RandomLoadBalancingPolicy>;
 
    class OrderedLoadBalancingPolicy;
 
    /// A shared pointer to an OrderedLoadBalancingPolicy.
    using OrderedLoadBalancingPolicyPtr = std::shared_ptr<OrderedLoadBalancingPolicy>;
 
    class RoundRobinLoadBalancingPolicy;
 
    /// A shared pointer to a RoundRobinLoadBalancingPolicy.
    using RoundRobinLoadBalancingPolicyPtr = std::shared_ptr<RoundRobinLoadBalancingPolicy>;
 
    class AdaptiveLoadBalancingPolicy;
 
    /// A shared pointer to an AdaptiveLoadBalancingPolicy.
    using AdaptiveLoadBalancingPolicyPtr = std::shared_ptr<AdaptiveLoadBalancingPolicy>;
 
    struct ReplicaGroupDescriptor;
 
    /// A sequence of ReplicaGroupDescriptor.
    using ReplicaGroupDescriptorSeq = std::vector<ReplicaGroupDescriptor>;
 
    struct ApplicationDescriptor;
 
    /// A sequence of ApplicationDescriptor.
    using ApplicationDescriptorSeq = std::vector<ApplicationDescriptor>;
 
    class BoxedString;
 
    /// A shared pointer to a BoxedString.
    using BoxedStringPtr = std::shared_ptr<BoxedString>;
 
    struct NodeUpdateDescriptor;
 
    /// A sequence of NodeUpdateDescriptor.
    using NodeUpdateDescriptorSeq = std::vector<NodeUpdateDescriptor>;
 
    class BoxedDistributionDescriptor;
 
    /// A shared pointer to a BoxedDistributionDescriptor.
    using BoxedDistributionDescriptorPtr [[deprecated]] = std::shared_ptr<BoxedDistributionDescriptor>;
 
    struct ApplicationUpdateDescriptor;
}
 
namespace IceGrid
{
    /// Describes an Ice property.
    /// @remarks The Slice compiler generated this struct from Slice struct `::IceGrid::PropertyDescriptor`.
    /// @headerfile IceGrid/IceGrid.h
    struct PropertyDescriptor
    {
        /// The name of the property.
        std::string name;
 
        /// The value of the property.
        std::string value;
 
        /// Creates a tuple with all the fields of this struct.
        /// @return A tuple with all the fields of this struct.
        [[nodiscard]] std::tuple<const std::string&, const std::string&> ice_tuple() const
        {
            return std::tie(name, value);
        }
 
        /// Outputs the name and value of each field of this instance to the stream.
        /// @param os The output stream.
        ICEGRID_API void ice_printFields(std::ostream& os) const;
    };
 
    /// Outputs the description of a PropertyDescriptor to a stream, including all its fields.
    /// @param os The output stream.
    /// @param value The instance to output.
    /// @return The output stream.
    ICEGRID_API std::ostream& operator<<(std::ostream& os, const PropertyDescriptor& value);
 
    /// A property set descriptor.
    /// @remarks The Slice compiler generated this struct from Slice struct `::IceGrid::PropertySetDescriptor`.
    /// @headerfile IceGrid/IceGrid.h
    struct PropertySetDescriptor
    {
        /// References to named property sets.
        ::Ice::StringSeq references;
 
        /// The property set properties.
        ::IceGrid::PropertyDescriptorSeq properties;
 
        /// Creates a tuple with all the fields of this struct.
        /// @return A tuple with all the fields of this struct.
        [[nodiscard]] std::tuple<const ::Ice::StringSeq&, const ::IceGrid::PropertyDescriptorSeq&> ice_tuple() const
        {
            return std::tie(references, properties);
        }
 
        /// Outputs the name and value of each field of this instance to the stream.
        /// @param os The output stream.
        ICEGRID_API void ice_printFields(std::ostream& os) const;
    };
 
    /// Outputs the description of a PropertySetDescriptor to a stream, including all its fields.
    /// @param os The output stream.
    /// @param value The instance to output.
    /// @return The output stream.
    ICEGRID_API std::ostream& operator<<(std::ostream& os, const PropertySetDescriptor& value);
 
    /// Describes a well-known Ice object.
    /// @remarks The Slice compiler generated this struct from Slice struct `::IceGrid::ObjectDescriptor`.
    /// @headerfile IceGrid/IceGrid.h
    struct ObjectDescriptor
    {
        /// The identity of the object.
        ::Ice::Identity id;
 
        /// The object type.
        std::string type;
 
        /// The proxy options to use when creating a proxy for this well-known object. If empty, the proxy is created
        /// with the proxy options specified on the object adapter or replica group.
        std::string proxyOptions;
 
        /// Creates a tuple with all the fields of this struct.
        /// @return A tuple with all the fields of this struct.
        [[nodiscard]] std::tuple<const ::Ice::Identity&, const std::string&, const std::string&> ice_tuple() const
        {
            return std::tie(id, type, proxyOptions);
        }
 
        /// Outputs the name and value of each field of this instance to the stream.
        /// @param os The output stream.
        ICEGRID_API void ice_printFields(std::ostream& os) const;
    };
 
    /// Outputs the description of an ObjectDescriptor to a stream, including all its fields.
    /// @param os The output stream.
    /// @param value The instance to output.
    /// @return The output stream.
    ICEGRID_API std::ostream& operator<<(std::ostream& os, const ObjectDescriptor& value);
 
    /// Describes an indirect object adapter.
    /// @remarks The Slice compiler generated this struct from Slice struct `::IceGrid::AdapterDescriptor`.
    /// @headerfile IceGrid/IceGrid.h
    struct AdapterDescriptor
    {
        /// The object adapter name.
        std::string name;
 
        /// A description of this object adapter.
        std::string description;
 
        /// The adapter ID.
        std::string id;
 
        /// The replica group ID. It's empty when the adapter is not part of a replica group.
        std::string replicaGroupId;
 
        /// The adapter priority. Only relevant when the adapter is in a replica group.
        std::string priority;
 
        /// When `true`, the object adapter registers a process object.
        [[deprecated("This field is provided for schema compatibility. It is no longer used.")]] bool registerProcess{false};
 
        /// When `true`, the lifetime of this object adapter is the same of the server lifetime. This information is
        /// used by the IceGrid node to figure out the server state: the server is active when all its "server lifetime"
        /// adapters are active.
        bool serverLifetime;
 
        /// The descriptors of well-known objects.
        ::IceGrid::ObjectDescriptorSeq objects;
 
        /// The descriptors of allocatable objects.
        ::IceGrid::ObjectDescriptorSeq allocatables;
 
        /// Creates a tuple with all the fields of this struct.
        /// @return A tuple with all the fields of this struct.
        [[nodiscard]] std::tuple<const std::string&, const std::string&, const std::string&, const std::string&, const std::string&, const bool&, const bool&, const ::IceGrid::ObjectDescriptorSeq&, const ::IceGrid::ObjectDescriptorSeq&> ice_tuple() const
        {
            return std::tie(name, description, id, replicaGroupId, priority, registerProcess, serverLifetime, objects, allocatables);
        }
 
        /// Outputs the name and value of each field of this instance to the stream.
        /// @param os The output stream.
        ICEGRID_API void ice_printFields(std::ostream& os) const;
    };
 
    /// Outputs the description of an AdapterDescriptor to a stream, including all its fields.
    /// @param os The output stream.
    /// @param value The instance to output.
    /// @return The output stream.
    ICEGRID_API std::ostream& operator<<(std::ostream& os, const AdapterDescriptor& value);
 
    /// A Freeze database environment descriptor (deprecated, no longer used).
    /// @remarks The Slice compiler generated this struct from Slice struct `::IceGrid::DbEnvDescriptor`.
    /// @headerfile IceGrid/IceGrid.h
    struct [[deprecated("This descriptor is provided for schema compatibility. It is no longer used.")]] DbEnvDescriptor
    {
        /// The name of the database environment.
        std::string name;
 
        /// The description of this database environment.
        std::string description;
 
        /// The home of the database environment.
        std::string dbHome;
 
        /// The configuration properties of the database environment.
        ::IceGrid::PropertyDescriptorSeq properties;
 
        /// Creates a tuple with all the fields of this struct.
        /// @return A tuple with all the fields of this struct.
        [[nodiscard]] std::tuple<const std::string&, const std::string&, const std::string&, const ::IceGrid::PropertyDescriptorSeq&> ice_tuple() const
        {
            return std::tie(name, description, dbHome, properties);
        }
 
        /// Outputs the name and value of each field of this instance to the stream.
        /// @param os The output stream.
        ICEGRID_API void ice_printFields(std::ostream& os) const;
    };
 
    /// Outputs the description of a DbEnvDescriptor to a stream, including all its fields.
    /// @param os The output stream.
    /// @param value The instance to output.
    /// @return The output stream.
    ICEGRID_API std::ostream& operator<<(std::ostream& os, const DbEnvDescriptor& value);
 
    /// Describes an Ice communicator.
    /// @remarks The Slice compiler generated this class from Slice class `::IceGrid::CommunicatorDescriptor`.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API CommunicatorDescriptor : public Ice::Value
    {
    public:
        /// Default constructor.
        CommunicatorDescriptor() noexcept = default;
 
        /// One-shot constructor to initialize all data members.
        /// @param adapters The indirect object adapters.
        /// @param propertySet The property set.
        /// @param dbEnvs The database environments.
        /// @param logs The path of each log file.
        /// @param description A description of this descriptor.
        CommunicatorDescriptor(::IceGrid::AdapterDescriptorSeq adapters, ::IceGrid::PropertySetDescriptor propertySet, ::IceGrid::DbEnvDescriptorSeq dbEnvs, ::Ice::StringSeq logs, std::string description) noexcept :
            adapters(std::move(adapters)),
            propertySet(std::move(propertySet)),
            dbEnvs(std::move(dbEnvs)),
            logs(std::move(logs)),
            description(std::move(description))
        {
        }
 
        /// Gets the type ID of the associated Slice class.
        /// @return The string `"::IceGrid::CommunicatorDescriptor"`.
        static const char* ice_staticId() noexcept;
 
        [[nodiscard]] const char* ice_id() const noexcept override;
 
        /// Creates a tuple with all the fields of this class.
        /// @return A tuple with all the fields of this class.
        [[nodiscard]] std::tuple<const ::IceGrid::AdapterDescriptorSeq&, const ::IceGrid::PropertySetDescriptor&, const ::IceGrid::DbEnvDescriptorSeq&, const ::Ice::StringSeq&, const std::string&> ice_tuple() const
        {
            return std::tie(adapters, propertySet, dbEnvs, logs, description);
        }
 
        /// Creates a shallow polymorphic copy of this instance.
        /// @return The cloned value.
        [[nodiscard]] CommunicatorDescriptorPtr ice_clone() const { return std::static_pointer_cast<CommunicatorDescriptor>(_iceCloneImpl()); }
 
        void ice_printFields(std::ostream& os) const override;
 
        /// The indirect object adapters.
        ::IceGrid::AdapterDescriptorSeq adapters;
 
        /// The property set.
        ::IceGrid::PropertySetDescriptor propertySet;
 
        /// The database environments.
        [[deprecated]] ::IceGrid::DbEnvDescriptorSeq dbEnvs;
 
        /// The path of each log file.
        ::Ice::StringSeq logs;
 
        /// A description of this descriptor.
        std::string description;
 
    protected:
        /// Copy constructor.
        CommunicatorDescriptor(const CommunicatorDescriptor&) = default;
 
        /// @private
        [[nodiscard]] Ice::ValuePtr _iceCloneImpl() const override;
 
        /// @private
        void _iceWriteImpl(Ice::OutputStream*) const override;
 
        /// @private
        void _iceReadImpl(Ice::InputStream*) override;
    };
 
    /// Describes a distribution.
    /// @remarks The Slice compiler generated this struct from Slice struct `::IceGrid::DistributionDescriptor`.
    /// @headerfile IceGrid/IceGrid.h
    struct [[deprecated("This descriptor is provided for schema compatibility. It is no longer used.")]] DistributionDescriptor
    {
        /// The proxy of the IcePatch2 server.
        std::string icepatch;
 
        /// The source directories.
        ::Ice::StringSeq directories;
 
        /// Creates a tuple with all the fields of this struct.
        /// @return A tuple with all the fields of this struct.
        [[nodiscard]] std::tuple<const std::string&, const ::Ice::StringSeq&> ice_tuple() const
        {
            return std::tie(icepatch, directories);
        }
 
        /// Outputs the name and value of each field of this instance to the stream.
        /// @param os The output stream.
        ICEGRID_API void ice_printFields(std::ostream& os) const;
    };
 
    /// Outputs the description of a DistributionDescriptor to a stream, including all its fields.
    /// @param os The output stream.
    /// @param value The instance to output.
    /// @return The output stream.
    ICEGRID_API std::ostream& operator<<(std::ostream& os, const DistributionDescriptor& value);
 
    /// Describes an Ice server.
    /// @remarks The Slice compiler generated this class from Slice class `::IceGrid::ServerDescriptor`.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API ServerDescriptor : public CommunicatorDescriptor
    {
    public:
        /// Default constructor.
        ServerDescriptor() noexcept = default;
 
        /// One-shot constructor to initialize all data members.
        /// @param adapters The indirect object adapters.
        /// @param propertySet The property set.
        /// @param dbEnvs The database environments.
        /// @param logs The path of each log file.
        /// @param description A description of this descriptor.
        /// @param id The server ID.
        /// @param exe The path of the server executable.
        /// @param iceVersion The Ice version used by this server.
        /// @param pwd The path to the server working directory.
        /// @param options The command line options to pass to the server executable.
        /// @param envs The server environment variables.
        /// @param activation The server activation mode.
        /// @param activationTimeout The activation timeout.
        /// @param deactivationTimeout The deactivation timeout.
        /// @param applicationDistrib Specifies if the server depends on the application distribution.
        /// @param distrib The distribution descriptor.
        /// @param allocatable Specifies if the server is allocatable.
        /// @param user The user account used to run the server.
        ServerDescriptor(::IceGrid::AdapterDescriptorSeq adapters, ::IceGrid::PropertySetDescriptor propertySet, ::IceGrid::DbEnvDescriptorSeq dbEnvs, ::Ice::StringSeq logs, std::string description, std::string id, std::string exe, std::string iceVersion, std::string pwd, ::Ice::StringSeq options, ::Ice::StringSeq envs, std::string activation, std::string activationTimeout, std::string deactivationTimeout, bool applicationDistrib, ::IceGrid::DistributionDescriptor distrib, bool allocatable, std::string user) noexcept :
            CommunicatorDescriptor(std::move(adapters), std::move(propertySet), std::move(dbEnvs), std::move(logs), std::move(description)),
            id(std::move(id)),
            exe(std::move(exe)),
            iceVersion(std::move(iceVersion)),
            pwd(std::move(pwd)),
            options(std::move(options)),
            envs(std::move(envs)),
            activation(std::move(activation)),
            activationTimeout(std::move(activationTimeout)),
            deactivationTimeout(std::move(deactivationTimeout)),
            applicationDistrib(applicationDistrib),
            distrib(std::move(distrib)),
            allocatable(allocatable),
            user(std::move(user))
        {
        }
 
        /// Gets the type ID of the associated Slice class.
        /// @return The string `"::IceGrid::ServerDescriptor"`.
        static const char* ice_staticId() noexcept;
 
        [[nodiscard]] const char* ice_id() const noexcept override;
 
        /// Creates a tuple with all the fields of this class.
        /// @return A tuple with all the fields of this class.
        [[nodiscard]] std::tuple<const ::IceGrid::AdapterDescriptorSeq&, const ::IceGrid::PropertySetDescriptor&, const ::IceGrid::DbEnvDescriptorSeq&, const ::Ice::StringSeq&, const std::string&, const std::string&, const std::string&, const std::string&, const std::string&, const ::Ice::StringSeq&, const ::Ice::StringSeq&, const std::string&, const std::string&, const std::string&, const bool&, const ::IceGrid::DistributionDescriptor&, const bool&, const std::string&> ice_tuple() const
        {
            return std::tie(adapters, propertySet, dbEnvs, logs, description, id, exe, iceVersion, pwd, options, envs, activation, activationTimeout, deactivationTimeout, applicationDistrib, distrib, allocatable, user);
        }
 
        /// Creates a shallow polymorphic copy of this instance.
        /// @return The cloned value.
        [[nodiscard]] ServerDescriptorPtr ice_clone() const { return std::static_pointer_cast<ServerDescriptor>(_iceCloneImpl()); }
 
        void ice_printFields(std::ostream& os) const override;
 
        /// The server ID.
        std::string id;
 
        /// The path of the server executable.
        std::string exe;
 
        /// The Ice version used by this server. This is only required if backward compatibility with servers using old
        /// Ice versions is needed (otherwise the registry assumes the server is using the same Ice version as the
        /// registry itself). For example `"3.7.5"`.
        std::string iceVersion;
 
        /// The path to the server working directory.
        std::string pwd;
 
        /// The command line options to pass to the server executable.
        ::Ice::StringSeq options;
 
        /// The server environment variables.
        ::Ice::StringSeq envs;
 
        /// The server activation mode. Possible values are `"on-demand"` and `"manual"`.
        std::string activation;
 
        /// The activation timeout. It's an integer (in string format) that represents the number of seconds to wait for
        /// activation.
        std::string activationTimeout;
 
        /// The deactivation timeout. It's an integer (in string format) that represents the number of seconds to wait
        /// for deactivation.
        std::string deactivationTimeout;
 
        /// Specifies if the server depends on the application distribution.
        [[deprecated]] bool applicationDistrib{false};
 
        /// The distribution descriptor.
        [[deprecated]] ::IceGrid::DistributionDescriptor distrib;
 
        /// Specifies if the server is allocatable.
        bool allocatable;
 
        /// The user account used to run the server.
        std::string user;
 
    protected:
        /// Copy constructor.
        ServerDescriptor(const ServerDescriptor&) = default;
 
        /// @private
        [[nodiscard]] Ice::ValuePtr _iceCloneImpl() const override;
 
        /// @private
        void _iceWriteImpl(Ice::OutputStream*) const override;
 
        /// @private
        void _iceReadImpl(Ice::InputStream*) override;
    };
 
    /// Describes an IceBox service.
    /// @remarks The Slice compiler generated this class from Slice class `::IceGrid::ServiceDescriptor`.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API ServiceDescriptor : public CommunicatorDescriptor
    {
    public:
        /// Default constructor.
        ServiceDescriptor() noexcept = default;
 
        /// One-shot constructor to initialize all data members.
        /// @param adapters The indirect object adapters.
        /// @param propertySet The property set.
        /// @param dbEnvs The database environments.
        /// @param logs The path of each log file.
        /// @param description A description of this descriptor.
        /// @param name The service name.
        /// @param entry The entry point of the IceBox service.
        ServiceDescriptor(::IceGrid::AdapterDescriptorSeq adapters, ::IceGrid::PropertySetDescriptor propertySet, ::IceGrid::DbEnvDescriptorSeq dbEnvs, ::Ice::StringSeq logs, std::string description, std::string name, std::string entry) noexcept :
            CommunicatorDescriptor(std::move(adapters), std::move(propertySet), std::move(dbEnvs), std::move(logs), std::move(description)),
            name(std::move(name)),
            entry(std::move(entry))
        {
        }
 
        /// Gets the type ID of the associated Slice class.
        /// @return The string `"::IceGrid::ServiceDescriptor"`.
        static const char* ice_staticId() noexcept;
 
        [[nodiscard]] const char* ice_id() const noexcept override;
 
        /// Creates a tuple with all the fields of this class.
        /// @return A tuple with all the fields of this class.
        [[nodiscard]] std::tuple<const ::IceGrid::AdapterDescriptorSeq&, const ::IceGrid::PropertySetDescriptor&, const ::IceGrid::DbEnvDescriptorSeq&, const ::Ice::StringSeq&, const std::string&, const std::string&, const std::string&> ice_tuple() const
        {
            return std::tie(adapters, propertySet, dbEnvs, logs, description, name, entry);
        }
 
        /// Creates a shallow polymorphic copy of this instance.
        /// @return The cloned value.
        [[nodiscard]] ServiceDescriptorPtr ice_clone() const { return std::static_pointer_cast<ServiceDescriptor>(_iceCloneImpl()); }
 
        void ice_printFields(std::ostream& os) const override;
 
        /// The service name.
        std::string name;
 
        /// The entry point of the IceBox service.
        std::string entry;
 
    protected:
        /// Copy constructor.
        ServiceDescriptor(const ServiceDescriptor&) = default;
 
        /// @private
        [[nodiscard]] Ice::ValuePtr _iceCloneImpl() const override;
 
        /// @private
        void _iceWriteImpl(Ice::OutputStream*) const override;
 
        /// @private
        void _iceReadImpl(Ice::InputStream*) override;
    };
 
    /// Describes a template instantiation that creates a server.
    /// @remarks The Slice compiler generated this struct from Slice struct `::IceGrid::ServerInstanceDescriptor`.
    /// @headerfile IceGrid/IceGrid.h
    struct ServerInstanceDescriptor
    {
        /// The template used by this instance. It's never empty.
        std::string templateName;
 
        /// The template parameter values.
        ::IceGrid::StringStringDict parameterValues;
 
        /// The property set.
        ::IceGrid::PropertySetDescriptor propertySet;
 
        /// The services property sets.
        /// It's only valid to set these property sets when the template is an IceBox server template.
        ::IceGrid::PropertySetDescriptorDict servicePropertySets;
 
        /// Creates a tuple with all the fields of this struct.
        /// @return A tuple with all the fields of this struct.
        [[nodiscard]] std::tuple<const std::string&, const ::IceGrid::StringStringDict&, const ::IceGrid::PropertySetDescriptor&, const ::IceGrid::PropertySetDescriptorDict&> ice_tuple() const
        {
            return std::tie(templateName, parameterValues, propertySet, servicePropertySets);
        }
 
        /// Outputs the name and value of each field of this instance to the stream.
        /// @param os The output stream.
        ICEGRID_API void ice_printFields(std::ostream& os) const;
    };
 
    /// Outputs the description of a ServerInstanceDescriptor to a stream, including all its fields.
    /// @param os The output stream.
    /// @param value The instance to output.
    /// @return The output stream.
    ICEGRID_API std::ostream& operator<<(std::ostream& os, const ServerInstanceDescriptor& value);
 
    /// Describes a template for a server or an IceBox service.
    /// @remarks The Slice compiler generated this struct from Slice struct `::IceGrid::TemplateDescriptor`.
    /// @headerfile IceGrid/IceGrid.h
    struct TemplateDescriptor
    {
        /// The communicator.
        ::IceGrid::CommunicatorDescriptorPtr descriptor;
 
        /// The parameters required to instantiate the template.
        ::Ice::StringSeq parameters;
 
        /// The parameters' default values.
        ::IceGrid::StringStringDict parameterDefaults;
 
        /// Creates a tuple with all the fields of this struct.
        /// @return A tuple with all the fields of this struct.
        [[nodiscard]] std::tuple<const ::IceGrid::CommunicatorDescriptorPtr&, const ::Ice::StringSeq&, const ::IceGrid::StringStringDict&> ice_tuple() const
        {
            return std::tie(descriptor, parameters, parameterDefaults);
        }
 
        /// Outputs the name and value of each field of this instance to the stream.
        /// @param os The output stream.
        ICEGRID_API void ice_printFields(std::ostream& os) const;
    };
 
    /// Outputs the description of a TemplateDescriptor to a stream, including all its fields.
    /// @param os The output stream.
    /// @param value The instance to output.
    /// @return The output stream.
    ICEGRID_API std::ostream& operator<<(std::ostream& os, const TemplateDescriptor& value);
 
    /// Describes an IceBox service.
    /// @remarks The Slice compiler generated this struct from Slice struct `::IceGrid::ServiceInstanceDescriptor`.
    /// @headerfile IceGrid/IceGrid.h
    struct ServiceInstanceDescriptor
    {
        /// The template used by this instance. It's empty when this instance does not use a template.
        std::string templateName;
 
        /// The template parameter values.
        ::IceGrid::StringStringDict parameterValues;
 
        /// The service definition if the instance isn't a template instance (i.e.: if the template attribute is empty).
        ::IceGrid::ServiceDescriptorPtr descriptor;
 
        /// The property set.
        ::IceGrid::PropertySetDescriptor propertySet;
 
        /// Creates a tuple with all the fields of this struct.
        /// @return A tuple with all the fields of this struct.
        [[nodiscard]] std::tuple<const std::string&, const ::IceGrid::StringStringDict&, const ::IceGrid::ServiceDescriptorPtr&, const ::IceGrid::PropertySetDescriptor&> ice_tuple() const
        {
            return std::tie(templateName, parameterValues, descriptor, propertySet);
        }
 
        /// Outputs the name and value of each field of this instance to the stream.
        /// @param os The output stream.
        ICEGRID_API void ice_printFields(std::ostream& os) const;
    };
 
    /// Outputs the description of a ServiceInstanceDescriptor to a stream, including all its fields.
    /// @param os The output stream.
    /// @param value The instance to output.
    /// @return The output stream.
    ICEGRID_API std::ostream& operator<<(std::ostream& os, const ServiceInstanceDescriptor& value);
 
    /// Describes an IceBox server.
    /// @remarks The Slice compiler generated this class from Slice class `::IceGrid::IceBoxDescriptor`.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API IceBoxDescriptor : public ServerDescriptor
    {
    public:
        /// Default constructor.
        IceBoxDescriptor() noexcept = default;
 
        /// One-shot constructor to initialize all data members.
        /// @param adapters The indirect object adapters.
        /// @param propertySet The property set.
        /// @param dbEnvs The database environments.
        /// @param logs The path of each log file.
        /// @param description A description of this descriptor.
        /// @param id The server ID.
        /// @param exe The path of the server executable.
        /// @param iceVersion The Ice version used by this server.
        /// @param pwd The path to the server working directory.
        /// @param options The command line options to pass to the server executable.
        /// @param envs The server environment variables.
        /// @param activation The server activation mode.
        /// @param activationTimeout The activation timeout.
        /// @param deactivationTimeout The deactivation timeout.
        /// @param applicationDistrib Specifies if the server depends on the application distribution.
        /// @param distrib The distribution descriptor.
        /// @param allocatable Specifies if the server is allocatable.
        /// @param user The user account used to run the server.
        /// @param services The service instances.
        IceBoxDescriptor(::IceGrid::AdapterDescriptorSeq adapters, ::IceGrid::PropertySetDescriptor propertySet, ::IceGrid::DbEnvDescriptorSeq dbEnvs, ::Ice::StringSeq logs, std::string description, std::string id, std::string exe, std::string iceVersion, std::string pwd, ::Ice::StringSeq options, ::Ice::StringSeq envs, std::string activation, std::string activationTimeout, std::string deactivationTimeout, bool applicationDistrib, ::IceGrid::DistributionDescriptor distrib, bool allocatable, std::string user, ::IceGrid::ServiceInstanceDescriptorSeq services) noexcept :
            ServerDescriptor(std::move(adapters), std::move(propertySet), std::move(dbEnvs), std::move(logs), std::move(description), std::move(id), std::move(exe), std::move(iceVersion), std::move(pwd), std::move(options), std::move(envs), std::move(activation), std::move(activationTimeout), std::move(deactivationTimeout), applicationDistrib, std::move(distrib), allocatable, std::move(user)),
            services(std::move(services))
        {
        }
 
        /// Gets the type ID of the associated Slice class.
        /// @return The string `"::IceGrid::IceBoxDescriptor"`.
        static const char* ice_staticId() noexcept;
 
        [[nodiscard]] const char* ice_id() const noexcept override;
 
        /// Creates a tuple with all the fields of this class.
        /// @return A tuple with all the fields of this class.
        [[nodiscard]] std::tuple<const ::IceGrid::AdapterDescriptorSeq&, const ::IceGrid::PropertySetDescriptor&, const ::IceGrid::DbEnvDescriptorSeq&, const ::Ice::StringSeq&, const std::string&, const std::string&, const std::string&, const std::string&, const std::string&, const ::Ice::StringSeq&, const ::Ice::StringSeq&, const std::string&, const std::string&, const std::string&, const bool&, const ::IceGrid::DistributionDescriptor&, const bool&, const std::string&, const ::IceGrid::ServiceInstanceDescriptorSeq&> ice_tuple() const
        {
            return std::tie(adapters, propertySet, dbEnvs, logs, description, id, exe, iceVersion, pwd, options, envs, activation, activationTimeout, deactivationTimeout, applicationDistrib, distrib, allocatable, user, services);
        }
 
        /// Creates a shallow polymorphic copy of this instance.
        /// @return The cloned value.
        [[nodiscard]] IceBoxDescriptorPtr ice_clone() const { return std::static_pointer_cast<IceBoxDescriptor>(_iceCloneImpl()); }
 
        void ice_printFields(std::ostream& os) const override;
 
        /// The service instances.
        ::IceGrid::ServiceInstanceDescriptorSeq services;
 
    protected:
        /// Copy constructor.
        IceBoxDescriptor(const IceBoxDescriptor&) = default;
 
        /// @private
        [[nodiscard]] Ice::ValuePtr _iceCloneImpl() const override;
 
        /// @private
        void _iceWriteImpl(Ice::OutputStream*) const override;
 
        /// @private
        void _iceReadImpl(Ice::InputStream*) override;
    };
 
    /// Describes an IceGrid node.
    /// @remarks The Slice compiler generated this struct from Slice struct `::IceGrid::NodeDescriptor`.
    /// @headerfile IceGrid/IceGrid.h
    struct NodeDescriptor
    {
        /// The variables defined for the node.
        ::IceGrid::StringStringDict variables;
 
        /// The server instances (template instances).
        ::IceGrid::ServerInstanceDescriptorSeq serverInstances;
 
        /// Servers that are not template instances.
        ::IceGrid::ServerDescriptorSeq servers;
 
        /// Load factor of the node.
        std::string loadFactor;
 
        /// The description of this node.
        std::string description;
 
        /// Property set descriptors.
        ::IceGrid::PropertySetDescriptorDict propertySets;
 
        /// Creates a tuple with all the fields of this struct.
        /// @return A tuple with all the fields of this struct.
        [[nodiscard]] std::tuple<const ::IceGrid::StringStringDict&, const ::IceGrid::ServerInstanceDescriptorSeq&, const ::IceGrid::ServerDescriptorSeq&, const std::string&, const std::string&, const ::IceGrid::PropertySetDescriptorDict&> ice_tuple() const
        {
            return std::tie(variables, serverInstances, servers, loadFactor, description, propertySets);
        }
 
        /// Outputs the name and value of each field of this instance to the stream.
        /// @param os The output stream.
        ICEGRID_API void ice_printFields(std::ostream& os) const;
    };
 
    /// Outputs the description of a NodeDescriptor to a stream, including all its fields.
    /// @param os The output stream.
    /// @param value The instance to output.
    /// @return The output stream.
    ICEGRID_API std::ostream& operator<<(std::ostream& os, const NodeDescriptor& value);
 
    /// The base class for load balancing policies.
    /// @remarks The Slice compiler generated this class from Slice class `::IceGrid::LoadBalancingPolicy`.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API LoadBalancingPolicy : public Ice::Value
    {
    public:
        /// Default constructor.
        LoadBalancingPolicy() noexcept = default;
 
        /// One-shot constructor to initialize all data members.
        /// @param nReplicas The number of replicas that will be used to gather the endpoints of a replica group.
        explicit LoadBalancingPolicy(std::string nReplicas) noexcept :
            nReplicas(std::move(nReplicas))
        {
        }
 
        /// Gets the type ID of the associated Slice class.
        /// @return The string `"::IceGrid::LoadBalancingPolicy"`.
        static const char* ice_staticId() noexcept;
 
        [[nodiscard]] const char* ice_id() const noexcept override;
 
        /// Creates a tuple with all the fields of this class.
        /// @return A tuple with all the fields of this class.
        [[nodiscard]] std::tuple<const std::string&> ice_tuple() const
        {
            return std::tie(nReplicas);
        }
 
        /// Creates a shallow polymorphic copy of this instance.
        /// @return The cloned value.
        [[nodiscard]] LoadBalancingPolicyPtr ice_clone() const { return std::static_pointer_cast<LoadBalancingPolicy>(_iceCloneImpl()); }
 
        void ice_printFields(std::ostream& os) const override;
 
        /// The number of replicas that will be used to gather the endpoints of a replica group.
        std::string nReplicas;
 
    protected:
        /// Copy constructor.
        LoadBalancingPolicy(const LoadBalancingPolicy&) = default;
 
        /// @private
        [[nodiscard]] Ice::ValuePtr _iceCloneImpl() const override;
 
        /// @private
        void _iceWriteImpl(Ice::OutputStream*) const override;
 
        /// @private
        void _iceReadImpl(Ice::InputStream*) override;
    };
 
    /// The load balancing policy that returns endpoints in a random order.
    /// @remarks The Slice compiler generated this class from Slice class `::IceGrid::RandomLoadBalancingPolicy`.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API RandomLoadBalancingPolicy : public LoadBalancingPolicy
    {
    public:using LoadBalancingPolicy::LoadBalancingPolicy;
 
        /// Gets the type ID of the associated Slice class.
        /// @return The string `"::IceGrid::RandomLoadBalancingPolicy"`.
        static const char* ice_staticId() noexcept;
 
        [[nodiscard]] const char* ice_id() const noexcept override;
 
        /// Creates a shallow polymorphic copy of this instance.
        /// @return The cloned value.
        [[nodiscard]] RandomLoadBalancingPolicyPtr ice_clone() const { return std::static_pointer_cast<RandomLoadBalancingPolicy>(_iceCloneImpl()); }
 
    protected:
        /// Copy constructor.
        RandomLoadBalancingPolicy(const RandomLoadBalancingPolicy&) = default;
 
        /// @private
        [[nodiscard]] Ice::ValuePtr _iceCloneImpl() const override;
 
        /// @private
        void _iceWriteImpl(Ice::OutputStream*) const override;
 
        /// @private
        void _iceReadImpl(Ice::InputStream*) override;
    };
 
    /// The load balancing policy that returns endpoints in order.
    /// @remarks The Slice compiler generated this class from Slice class `::IceGrid::OrderedLoadBalancingPolicy`.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API OrderedLoadBalancingPolicy : public LoadBalancingPolicy
    {
    public:using LoadBalancingPolicy::LoadBalancingPolicy;
 
        /// Gets the type ID of the associated Slice class.
        /// @return The string `"::IceGrid::OrderedLoadBalancingPolicy"`.
        static const char* ice_staticId() noexcept;
 
        [[nodiscard]] const char* ice_id() const noexcept override;
 
        /// Creates a shallow polymorphic copy of this instance.
        /// @return The cloned value.
        [[nodiscard]] OrderedLoadBalancingPolicyPtr ice_clone() const { return std::static_pointer_cast<OrderedLoadBalancingPolicy>(_iceCloneImpl()); }
 
    protected:
        /// Copy constructor.
        OrderedLoadBalancingPolicy(const OrderedLoadBalancingPolicy&) = default;
 
        /// @private
        [[nodiscard]] Ice::ValuePtr _iceCloneImpl() const override;
 
        /// @private
        void _iceWriteImpl(Ice::OutputStream*) const override;
 
        /// @private
        void _iceReadImpl(Ice::InputStream*) override;
    };
 
    /// The load balancing policy that returns endpoints using round-robin.
    /// @remarks The Slice compiler generated this class from Slice class `::IceGrid::RoundRobinLoadBalancingPolicy`.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API RoundRobinLoadBalancingPolicy : public LoadBalancingPolicy
    {
    public:using LoadBalancingPolicy::LoadBalancingPolicy;
 
        /// Gets the type ID of the associated Slice class.
        /// @return The string `"::IceGrid::RoundRobinLoadBalancingPolicy"`.
        static const char* ice_staticId() noexcept;
 
        [[nodiscard]] const char* ice_id() const noexcept override;
 
        /// Creates a shallow polymorphic copy of this instance.
        /// @return The cloned value.
        [[nodiscard]] RoundRobinLoadBalancingPolicyPtr ice_clone() const { return std::static_pointer_cast<RoundRobinLoadBalancingPolicy>(_iceCloneImpl()); }
 
    protected:
        /// Copy constructor.
        RoundRobinLoadBalancingPolicy(const RoundRobinLoadBalancingPolicy&) = default;
 
        /// @private
        [[nodiscard]] Ice::ValuePtr _iceCloneImpl() const override;
 
        /// @private
        void _iceWriteImpl(Ice::OutputStream*) const override;
 
        /// @private
        void _iceReadImpl(Ice::InputStream*) override;
    };
 
    /// The load balancing policy that returns the endpoints of the server(s) with the lowest load average.
    /// @remarks The Slice compiler generated this class from Slice class `::IceGrid::AdaptiveLoadBalancingPolicy`.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API AdaptiveLoadBalancingPolicy : public LoadBalancingPolicy
    {
    public:
        /// Default constructor.
        AdaptiveLoadBalancingPolicy() noexcept = default;
 
        /// One-shot constructor to initialize all data members.
        /// @param nReplicas The number of replicas that will be used to gather the endpoints of a replica group.
        /// @param loadSample The load sample to use for the load balancing.
        AdaptiveLoadBalancingPolicy(std::string nReplicas, std::string loadSample) noexcept :
            LoadBalancingPolicy(std::move(nReplicas)),
            loadSample(std::move(loadSample))
        {
        }
 
        /// Gets the type ID of the associated Slice class.
        /// @return The string `"::IceGrid::AdaptiveLoadBalancingPolicy"`.
        static const char* ice_staticId() noexcept;
 
        [[nodiscard]] const char* ice_id() const noexcept override;
 
        /// Creates a tuple with all the fields of this class.
        /// @return A tuple with all the fields of this class.
        [[nodiscard]] std::tuple<const std::string&, const std::string&> ice_tuple() const
        {
            return std::tie(nReplicas, loadSample);
        }
 
        /// Creates a shallow polymorphic copy of this instance.
        /// @return The cloned value.
        [[nodiscard]] AdaptiveLoadBalancingPolicyPtr ice_clone() const { return std::static_pointer_cast<AdaptiveLoadBalancingPolicy>(_iceCloneImpl()); }
 
        void ice_printFields(std::ostream& os) const override;
 
        /// The load sample to use for the load balancing. The allowed values for this attribute are "1", "5" and "15",
        /// representing respectively the load average over the past minute, the past 5 minutes and the past 15 minutes.
        std::string loadSample;
 
    protected:
        /// Copy constructor.
        AdaptiveLoadBalancingPolicy(const AdaptiveLoadBalancingPolicy&) = default;
 
        /// @private
        [[nodiscard]] Ice::ValuePtr _iceCloneImpl() const override;
 
        /// @private
        void _iceWriteImpl(Ice::OutputStream*) const override;
 
        /// @private
        void _iceReadImpl(Ice::InputStream*) override;
    };
 
    /// Describes a replica group.
    /// @remarks The Slice compiler generated this struct from Slice struct `::IceGrid::ReplicaGroupDescriptor`.
    /// @headerfile IceGrid/IceGrid.h
    struct ReplicaGroupDescriptor
    {
        /// The replica group ID.
        std::string id;
 
        /// The load balancing policy.
        ::IceGrid::LoadBalancingPolicyPtr loadBalancing;
 
        /// Default options for proxies created for the replica group.
        std::string proxyOptions;
 
        /// The descriptors for the well-known objects.
        ::IceGrid::ObjectDescriptorSeq objects;
 
        /// The description of this replica group.
        std::string description;
 
        /// The filter to use for this replica group.
        std::string filter;
 
        /// Creates a tuple with all the fields of this struct.
        /// @return A tuple with all the fields of this struct.
        [[nodiscard]] std::tuple<const std::string&, const ::IceGrid::LoadBalancingPolicyPtr&, const std::string&, const ::IceGrid::ObjectDescriptorSeq&, const std::string&, const std::string&> ice_tuple() const
        {
            return std::tie(id, loadBalancing, proxyOptions, objects, description, filter);
        }
 
        /// Outputs the name and value of each field of this instance to the stream.
        /// @param os The output stream.
        ICEGRID_API void ice_printFields(std::ostream& os) const;
    };
 
    /// Outputs the description of a ReplicaGroupDescriptor to a stream, including all its fields.
    /// @param os The output stream.
    /// @param value The instance to output.
    /// @return The output stream.
    ICEGRID_API std::ostream& operator<<(std::ostream& os, const ReplicaGroupDescriptor& value);
 
    /// Describes an application.
    /// @remarks The Slice compiler generated this struct from Slice struct `::IceGrid::ApplicationDescriptor`.
    /// @headerfile IceGrid/IceGrid.h
    struct ApplicationDescriptor
    {
        /// The application name.
        std::string name;
 
        /// The variables defined in the application descriptor.
        ::IceGrid::StringStringDict variables;
 
        /// The replica groups.
        ::IceGrid::ReplicaGroupDescriptorSeq replicaGroups;
 
        /// The server templates.
        ::IceGrid::TemplateDescriptorDict serverTemplates;
 
        /// The service templates.
        ::IceGrid::TemplateDescriptorDict serviceTemplates;
 
        /// The node descriptors.
        ::IceGrid::NodeDescriptorDict nodes;
 
        /// The application distribution.
        [[deprecated]] ::IceGrid::DistributionDescriptor distrib;
 
        /// The description of this application.
        std::string description;
 
        /// Property set descriptors.
        ::IceGrid::PropertySetDescriptorDict propertySets;
 
        /// Creates a tuple with all the fields of this struct.
        /// @return A tuple with all the fields of this struct.
        [[nodiscard]] std::tuple<const std::string&, const ::IceGrid::StringStringDict&, const ::IceGrid::ReplicaGroupDescriptorSeq&, const ::IceGrid::TemplateDescriptorDict&, const ::IceGrid::TemplateDescriptorDict&, const ::IceGrid::NodeDescriptorDict&, const ::IceGrid::DistributionDescriptor&, const std::string&, const ::IceGrid::PropertySetDescriptorDict&> ice_tuple() const
        {
            return std::tie(name, variables, replicaGroups, serverTemplates, serviceTemplates, nodes, distrib, description, propertySets);
        }
 
        /// Outputs the name and value of each field of this instance to the stream.
        /// @param os The output stream.
        ICEGRID_API void ice_printFields(std::ostream& os) const;
    };
 
    /// Outputs the description of an ApplicationDescriptor to a stream, including all its fields.
    /// @param os The output stream.
    /// @param value The instance to output.
    /// @return The output stream.
    ICEGRID_API std::ostream& operator<<(std::ostream& os, const ApplicationDescriptor& value);
 
    /// A "boxed" string.
    /// @remarks The Slice compiler generated this class from Slice class `::IceGrid::BoxedString`.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API BoxedString : public Ice::Value
    {
    public:
        /// Default constructor.
        BoxedString() noexcept = default;
 
        /// One-shot constructor to initialize all data members.
        /// @param value The value of the boxed string.
        explicit BoxedString(std::string value) noexcept :
            value(std::move(value))
        {
        }
 
        /// Gets the type ID of the associated Slice class.
        /// @return The string `"::IceGrid::BoxedString"`.
        static const char* ice_staticId() noexcept;
 
        [[nodiscard]] const char* ice_id() const noexcept override;
 
        /// Creates a tuple with all the fields of this class.
        /// @return A tuple with all the fields of this class.
        [[nodiscard]] std::tuple<const std::string&> ice_tuple() const
        {
            return std::tie(value);
        }
 
        /// Creates a shallow polymorphic copy of this instance.
        /// @return The cloned value.
        [[nodiscard]] BoxedStringPtr ice_clone() const { return std::static_pointer_cast<BoxedString>(_iceCloneImpl()); }
 
        void ice_printFields(std::ostream& os) const override;
 
        /// The value of the boxed string.
        std::string value;
 
    protected:
        /// Copy constructor.
        BoxedString(const BoxedString&) = default;
 
        /// @private
        [[nodiscard]] Ice::ValuePtr _iceCloneImpl() const override;
 
        /// @private
        void _iceWriteImpl(Ice::OutputStream*) const override;
 
        /// @private
        void _iceReadImpl(Ice::InputStream*) override;
    };
 
    /// Describes the updates to apply to a node in a deployed application.
    /// @remarks The Slice compiler generated this struct from Slice struct `::IceGrid::NodeUpdateDescriptor`.
    /// @headerfile IceGrid/IceGrid.h
    struct NodeUpdateDescriptor
    {
        /// The name of the node to update.
        std::string name;
 
        /// The updated description (or null if the description wasn't updated.)
        ::IceGrid::BoxedStringPtr description;
 
        /// The variables to update.
        ::IceGrid::StringStringDict variables;
 
        /// The variables to remove.
        ::Ice::StringSeq removeVariables;
 
        /// The property sets to update.
        ::IceGrid::PropertySetDescriptorDict propertySets;
 
        /// The property sets to remove.
        ::Ice::StringSeq removePropertySets;
 
        /// The server instances to update.
        ::IceGrid::ServerInstanceDescriptorSeq serverInstances;
 
        /// The servers which are not template instances to update.
        ::IceGrid::ServerDescriptorSeq servers;
 
        /// The IDs of the servers to remove.
        ::Ice::StringSeq removeServers;
 
        /// The updated load factor of the node (or null if the load factor was not updated).
        ::IceGrid::BoxedStringPtr loadFactor;
 
        /// Creates a tuple with all the fields of this struct.
        /// @return A tuple with all the fields of this struct.
        [[nodiscard]] std::tuple<const std::string&, const ::IceGrid::BoxedStringPtr&, const ::IceGrid::StringStringDict&, const ::Ice::StringSeq&, const ::IceGrid::PropertySetDescriptorDict&, const ::Ice::StringSeq&, const ::IceGrid::ServerInstanceDescriptorSeq&, const ::IceGrid::ServerDescriptorSeq&, const ::Ice::StringSeq&, const ::IceGrid::BoxedStringPtr&> ice_tuple() const
        {
            return std::tie(name, description, variables, removeVariables, propertySets, removePropertySets, serverInstances, servers, removeServers, loadFactor);
        }
 
        /// Outputs the name and value of each field of this instance to the stream.
        /// @param os The output stream.
        ICEGRID_API void ice_printFields(std::ostream& os) const;
    };
 
    /// Outputs the description of a NodeUpdateDescriptor to a stream, including all its fields.
    /// @param os The output stream.
    /// @param value The instance to output.
    /// @return The output stream.
    ICEGRID_API std::ostream& operator<<(std::ostream& os, const NodeUpdateDescriptor& value);
 
    /// A "boxed" distribution descriptor.
    /// @remarks The Slice compiler generated this class from Slice class `::IceGrid::BoxedDistributionDescriptor`.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API [[deprecated]] BoxedDistributionDescriptor : public Ice::Value
    {
    public:
        /// Default constructor.
        BoxedDistributionDescriptor() noexcept = default;
 
        /// One-shot constructor to initialize all data members.
        /// @param value The value of the boxed distribution descriptor.
        explicit BoxedDistributionDescriptor(::IceGrid::DistributionDescriptor value) noexcept :
            value(std::move(value))
        {
        }
 
        /// Gets the type ID of the associated Slice class.
        /// @return The string `"::IceGrid::BoxedDistributionDescriptor"`.
        static const char* ice_staticId() noexcept;
 
        [[nodiscard]] const char* ice_id() const noexcept override;
 
        /// Creates a tuple with all the fields of this class.
        /// @return A tuple with all the fields of this class.
        [[nodiscard]] std::tuple<const ::IceGrid::DistributionDescriptor&> ice_tuple() const
        {
            return std::tie(value);
        }
 
        /// Creates a shallow polymorphic copy of this instance.
        /// @return The cloned value.
        [[nodiscard]] BoxedDistributionDescriptorPtr ice_clone() const { return std::static_pointer_cast<BoxedDistributionDescriptor>(_iceCloneImpl()); }
 
        void ice_printFields(std::ostream& os) const override;
 
        /// The value of the boxed distribution descriptor.
        ::IceGrid::DistributionDescriptor value;
 
    protected:
        /// Copy constructor.
        BoxedDistributionDescriptor(const BoxedDistributionDescriptor&) = default;
 
        /// @private
        [[nodiscard]] Ice::ValuePtr _iceCloneImpl() const override;
 
        /// @private
        void _iceWriteImpl(Ice::OutputStream*) const override;
 
        /// @private
        void _iceReadImpl(Ice::InputStream*) override;
    };
 
    /// An application update descriptor to describe the updates to apply to a deployed application.
    /// @remarks The Slice compiler generated this struct from Slice struct `::IceGrid::ApplicationUpdateDescriptor`.
    /// @headerfile IceGrid/IceGrid.h
    struct ApplicationUpdateDescriptor
    {
        /// The name of the application to update.
        std::string name;
 
        /// The updated description (or null if the description wasn't updated).
        ::IceGrid::BoxedStringPtr description;
 
        /// The updated distribution application descriptor.
        [[deprecated]] ::IceGrid::BoxedDistributionDescriptorPtr distrib;
 
        /// The variables to update.
        ::IceGrid::StringStringDict variables;
 
        /// The variables to remove.
        ::Ice::StringSeq removeVariables;
 
        /// The property sets to update.
        ::IceGrid::PropertySetDescriptorDict propertySets;
 
        /// The property sets to remove.
        ::Ice::StringSeq removePropertySets;
 
        /// The replica groups to update.
        ::IceGrid::ReplicaGroupDescriptorSeq replicaGroups;
 
        /// The replica groups to remove.
        ::Ice::StringSeq removeReplicaGroups;
 
        /// The server templates to update.
        ::IceGrid::TemplateDescriptorDict serverTemplates;
 
        /// The IDs of the server template to remove.
        ::Ice::StringSeq removeServerTemplates;
 
        /// The service templates to update.
        ::IceGrid::TemplateDescriptorDict serviceTemplates;
 
        /// The IDs of the service template to remove.
        ::Ice::StringSeq removeServiceTemplates;
 
        /// The application nodes to update.
        ::IceGrid::NodeUpdateDescriptorSeq nodes;
 
        /// The nodes to remove.
        ::Ice::StringSeq removeNodes;
 
        /// Creates a tuple with all the fields of this struct.
        /// @return A tuple with all the fields of this struct.
        [[nodiscard]] std::tuple<const std::string&, const ::IceGrid::BoxedStringPtr&, const ::IceGrid::BoxedDistributionDescriptorPtr&, const ::IceGrid::StringStringDict&, const ::Ice::StringSeq&, const ::IceGrid::PropertySetDescriptorDict&, const ::Ice::StringSeq&, const ::IceGrid::ReplicaGroupDescriptorSeq&, const ::Ice::StringSeq&, const ::IceGrid::TemplateDescriptorDict&, const ::Ice::StringSeq&, const ::IceGrid::TemplateDescriptorDict&, const ::Ice::StringSeq&, const ::IceGrid::NodeUpdateDescriptorSeq&, const ::Ice::StringSeq&> ice_tuple() const
        {
            return std::tie(name, description, distrib, variables, removeVariables, propertySets, removePropertySets, replicaGroups, removeReplicaGroups, serverTemplates, removeServerTemplates, serviceTemplates, removeServiceTemplates, nodes, removeNodes);
        }
 
        /// Outputs the name and value of each field of this instance to the stream.
        /// @param os The output stream.
        ICEGRID_API void ice_printFields(std::ostream& os) const;
    };
 
    /// Outputs the description of an ApplicationUpdateDescriptor to a stream, including all its fields.
    /// @param os The output stream.
    /// @param value The instance to output.
    /// @return The output stream.
    ICEGRID_API std::ostream& operator<<(std::ostream& os, const ApplicationUpdateDescriptor& value);
 
    /// @cond INTERNAL
    using Ice::Tuple::operator<;
    using Ice::Tuple::operator<=;
    using Ice::Tuple::operator>;
    using Ice::Tuple::operator>=;
    using Ice::Tuple::operator==;
    using Ice::Tuple::operator!=;
    /// @endcond
}
 
namespace Ice
{
    /// @cond INTERNAL
    template<>
    struct StreamableTraits<::IceGrid::PropertyDescriptor>
    {
        static constexpr StreamHelperCategory helper = StreamHelperCategoryStruct;
        static constexpr int minWireSize = 2;
        static constexpr bool fixedLength = false;
    };
 
    template<>
    struct StreamReader<::IceGrid::PropertyDescriptor>
    {
        /// Unmarshals a ::IceGrid::PropertyDescriptor from the input stream.
        static void read(InputStream* istr, ::IceGrid::PropertyDescriptor& v)
        {
            istr->readAll(v.name, v.value);
        }
    };
    /// @endcond
 
    /// @cond INTERNAL
    template<>
    struct StreamableTraits<::IceGrid::PropertySetDescriptor>
    {
        static constexpr StreamHelperCategory helper = StreamHelperCategoryStruct;
        static constexpr int minWireSize = 2;
        static constexpr bool fixedLength = false;
    };
 
    template<>
    struct StreamReader<::IceGrid::PropertySetDescriptor>
    {
        /// Unmarshals a ::IceGrid::PropertySetDescriptor from the input stream.
        static void read(InputStream* istr, ::IceGrid::PropertySetDescriptor& v)
        {
            istr->readAll(v.references, v.properties);
        }
    };
    /// @endcond
 
    /// @cond INTERNAL
    template<>
    struct StreamableTraits<::IceGrid::ObjectDescriptor>
    {
        static constexpr StreamHelperCategory helper = StreamHelperCategoryStruct;
        static constexpr int minWireSize = 4;
        static constexpr bool fixedLength = false;
    };
 
    template<>
    struct StreamReader<::IceGrid::ObjectDescriptor>
    {
        /// Unmarshals a ::IceGrid::ObjectDescriptor from the input stream.
        static void read(InputStream* istr, ::IceGrid::ObjectDescriptor& v)
        {
            istr->readAll(v.id, v.type, v.proxyOptions);
        }
    };
    /// @endcond
 
    /// @cond INTERNAL
    template<>
    struct StreamableTraits<::IceGrid::AdapterDescriptor>
    {
        static constexpr StreamHelperCategory helper = StreamHelperCategoryStruct;
        static constexpr int minWireSize = 9;
        static constexpr bool fixedLength = false;
    };
 
    template<>
    struct StreamReader<::IceGrid::AdapterDescriptor>
    {
        /// Unmarshals a ::IceGrid::AdapterDescriptor from the input stream.
        static void read(InputStream* istr, ::IceGrid::AdapterDescriptor& v)
        {
            istr->readAll(v.name, v.description, v.id, v.replicaGroupId, v.priority, v.registerProcess, v.serverLifetime, v.objects, v.allocatables);
        }
    };
    /// @endcond
 
    /// @cond INTERNAL
    template<>
    struct StreamableTraits<::IceGrid::DbEnvDescriptor>
    {
        static constexpr StreamHelperCategory helper = StreamHelperCategoryStruct;
        static constexpr int minWireSize = 4;
        static constexpr bool fixedLength = false;
    };
 
    template<>
    struct StreamReader<::IceGrid::DbEnvDescriptor>
    {
        /// Unmarshals a ::IceGrid::DbEnvDescriptor from the input stream.
        static void read(InputStream* istr, ::IceGrid::DbEnvDescriptor& v)
        {
            istr->readAll(v.name, v.description, v.dbHome, v.properties);
        }
    };
    /// @endcond
 
    /// @cond INTERNAL
    template<>
    struct StreamableTraits<::IceGrid::DistributionDescriptor>
    {
        static constexpr StreamHelperCategory helper = StreamHelperCategoryStruct;
        static constexpr int minWireSize = 2;
        static constexpr bool fixedLength = false;
    };
 
    template<>
    struct StreamReader<::IceGrid::DistributionDescriptor>
    {
        /// Unmarshals a ::IceGrid::DistributionDescriptor from the input stream.
        static void read(InputStream* istr, ::IceGrid::DistributionDescriptor& v)
        {
            istr->readAll(v.icepatch, v.directories);
        }
    };
    /// @endcond
 
    /// @cond INTERNAL
    template<>
    struct StreamableTraits<::IceGrid::ServerInstanceDescriptor>
    {
        static constexpr StreamHelperCategory helper = StreamHelperCategoryStruct;
        static constexpr int minWireSize = 5;
        static constexpr bool fixedLength = false;
    };
 
    template<>
    struct StreamReader<::IceGrid::ServerInstanceDescriptor>
    {
        /// Unmarshals a ::IceGrid::ServerInstanceDescriptor from the input stream.
        static void read(InputStream* istr, ::IceGrid::ServerInstanceDescriptor& v)
        {
            istr->readAll(v.templateName, v.parameterValues, v.propertySet, v.servicePropertySets);
        }
    };
    /// @endcond
 
    /// @cond INTERNAL
    template<>
    struct StreamableTraits<::IceGrid::TemplateDescriptor>
    {
        static constexpr StreamHelperCategory helper = StreamHelperCategoryStruct;
        static constexpr int minWireSize = 3;
        static constexpr bool fixedLength = false;
    };
 
    template<>
    struct StreamReader<::IceGrid::TemplateDescriptor>
    {
        /// Unmarshals a ::IceGrid::TemplateDescriptor from the input stream.
        static void read(InputStream* istr, ::IceGrid::TemplateDescriptor& v)
        {
            istr->readAll(v.descriptor, v.parameters, v.parameterDefaults);
        }
    };
    /// @endcond
 
    /// @cond INTERNAL
    template<>
    struct StreamableTraits<::IceGrid::ServiceInstanceDescriptor>
    {
        static constexpr StreamHelperCategory helper = StreamHelperCategoryStruct;
        static constexpr int minWireSize = 5;
        static constexpr bool fixedLength = false;
    };
 
    template<>
    struct StreamReader<::IceGrid::ServiceInstanceDescriptor>
    {
        /// Unmarshals a ::IceGrid::ServiceInstanceDescriptor from the input stream.
        static void read(InputStream* istr, ::IceGrid::ServiceInstanceDescriptor& v)
        {
            istr->readAll(v.templateName, v.parameterValues, v.descriptor, v.propertySet);
        }
    };
    /// @endcond
 
    /// @cond INTERNAL
    template<>
    struct StreamableTraits<::IceGrid::NodeDescriptor>
    {
        static constexpr StreamHelperCategory helper = StreamHelperCategoryStruct;
        static constexpr int minWireSize = 6;
        static constexpr bool fixedLength = false;
    };
 
    template<>
    struct StreamReader<::IceGrid::NodeDescriptor>
    {
        /// Unmarshals a ::IceGrid::NodeDescriptor from the input stream.
        static void read(InputStream* istr, ::IceGrid::NodeDescriptor& v)
        {
            istr->readAll(v.variables, v.serverInstances, v.servers, v.loadFactor, v.description, v.propertySets);
        }
    };
    /// @endcond
 
    /// @cond INTERNAL
    template<>
    struct StreamableTraits<::IceGrid::ReplicaGroupDescriptor>
    {
        static constexpr StreamHelperCategory helper = StreamHelperCategoryStruct;
        static constexpr int minWireSize = 6;
        static constexpr bool fixedLength = false;
    };
 
    template<>
    struct StreamReader<::IceGrid::ReplicaGroupDescriptor>
    {
        /// Unmarshals a ::IceGrid::ReplicaGroupDescriptor from the input stream.
        static void read(InputStream* istr, ::IceGrid::ReplicaGroupDescriptor& v)
        {
            istr->readAll(v.id, v.loadBalancing, v.proxyOptions, v.objects, v.description, v.filter);
        }
    };
    /// @endcond
 
    /// @cond INTERNAL
    template<>
    struct StreamableTraits<::IceGrid::ApplicationDescriptor>
    {
        static constexpr StreamHelperCategory helper = StreamHelperCategoryStruct;
        static constexpr int minWireSize = 10;
        static constexpr bool fixedLength = false;
    };
 
    template<>
    struct StreamReader<::IceGrid::ApplicationDescriptor>
    {
        /// Unmarshals a ::IceGrid::ApplicationDescriptor from the input stream.
        static void read(InputStream* istr, ::IceGrid::ApplicationDescriptor& v)
        {
            istr->readAll(v.name, v.variables, v.replicaGroups, v.serverTemplates, v.serviceTemplates, v.nodes, v.distrib, v.description, v.propertySets);
        }
    };
    /// @endcond
 
    /// @cond INTERNAL
    template<>
    struct StreamableTraits<::IceGrid::NodeUpdateDescriptor>
    {
        static constexpr StreamHelperCategory helper = StreamHelperCategoryStruct;
        static constexpr int minWireSize = 10;
        static constexpr bool fixedLength = false;
    };
 
    template<>
    struct StreamReader<::IceGrid::NodeUpdateDescriptor>
    {
        /// Unmarshals a ::IceGrid::NodeUpdateDescriptor from the input stream.
        static void read(InputStream* istr, ::IceGrid::NodeUpdateDescriptor& v)
        {
            istr->readAll(v.name, v.description, v.variables, v.removeVariables, v.propertySets, v.removePropertySets, v.serverInstances, v.servers, v.removeServers, v.loadFactor);
        }
    };
    /// @endcond
 
    /// @cond INTERNAL
    template<>
    struct StreamableTraits<::IceGrid::ApplicationUpdateDescriptor>
    {
        static constexpr StreamHelperCategory helper = StreamHelperCategoryStruct;
        static constexpr int minWireSize = 15;
        static constexpr bool fixedLength = false;
    };
 
    template<>
    struct StreamReader<::IceGrid::ApplicationUpdateDescriptor>
    {
        /// Unmarshals a ::IceGrid::ApplicationUpdateDescriptor from the input stream.
        static void read(InputStream* istr, ::IceGrid::ApplicationUpdateDescriptor& v)
        {
            istr->readAll(v.name, v.description, v.distrib, v.variables, v.removeVariables, v.propertySets, v.removePropertySets, v.replicaGroups, v.removeReplicaGroups, v.serverTemplates, v.removeServerTemplates, v.serviceTemplates, v.removeServiceTemplates, v.nodes, v.removeNodes);
        }
    };
    /// @endcond
}
 
// NOLINTEND(modernize-concat-nested-namespaces)
 
#include <Ice/PopDisableWarnings.h>
#endif