Ice 3.7 C++11 API Reference
Descriptor.h
Go to the documentation of this file.
1 //
2 // Copyright (c) ZeroC, Inc. All rights reserved.
3 //
4 //
5 // Ice version 3.7.10
6 //
7 // <auto-generated>
8 //
9 // Generated from file `Descriptor.ice'
10 //
11 // Warning: do not edit this file.
12 //
13 // </auto-generated>
14 //
15 
16 #ifndef __IceGrid_Descriptor_h__
17 #define __IceGrid_Descriptor_h__
18 
19 #include <IceUtil/PushDisableWarnings.h>
20 #include <Ice/ProxyF.h>
21 #include <Ice/ObjectF.h>
22 #include <Ice/ValueF.h>
23 #include <Ice/Exception.h>
24 #include <Ice/LocalObject.h>
25 #include <Ice/StreamHelpers.h>
26 #include <Ice/Comparable.h>
27 #include <Ice/Proxy.h>
28 #include <Ice/Object.h>
29 #include <Ice/GCObject.h>
30 #include <Ice/Value.h>
31 #include <Ice/Incoming.h>
32 #include <Ice/FactoryTableInit.h>
33 #include <IceUtil/ScopedArray.h>
34 #include <Ice/Optional.h>
35 #include <Ice/Identity.h>
36 #include <Ice/BuiltinSequences.h>
37 #include <IceUtil/UndefSysMacros.h>
38 #include <IceGrid/Config.h>
39 
40 #ifndef ICE_IGNORE_VERSION
41 # if ICE_INT_VERSION / 100 != 307
42 # error Ice version mismatch!
43 # endif
44 # if ICE_INT_VERSION % 100 >= 50
45 # error Beta header file detected
46 # endif
47 # if ICE_INT_VERSION % 100 < 10
48 # error Ice patch level mismatch!
49 # endif
50 #endif
51 
52 #ifndef ICEGRID_API
53 # if defined(ICE_STATIC_LIBS)
54 # define ICEGRID_API
55 # elif defined(ICEGRID_API_EXPORTS)
56 # define ICEGRID_API ICE_DECLSPEC_EXPORT
57 # else
58 # define ICEGRID_API ICE_DECLSPEC_IMPORT
59 # endif
60 #endif
61 
62 #ifdef ICE_CPP11_MAPPING // C++11 mapping
63 
64 namespace IceGrid
65 {
66 
67 class CommunicatorDescriptor;
68 class ServerDescriptor;
69 class ServiceDescriptor;
70 class IceBoxDescriptor;
71 class LoadBalancingPolicy;
72 class RandomLoadBalancingPolicy;
73 class OrderedLoadBalancingPolicy;
74 class RoundRobinLoadBalancingPolicy;
75 class AdaptiveLoadBalancingPolicy;
76 class BoxedString;
77 class BoxedDistributionDescriptor;
78 
79 }
80 
81 namespace IceGrid
82 {
83 
87 using StringStringDict = ::std::map<::std::string, ::std::string>;
88 
93 struct PropertyDescriptor
94 {
98  ::std::string name;
102  ::std::string value;
103 
108  std::tuple<const ::std::string&, const ::std::string&> ice_tuple() const
109  {
110  return std::tie(name, value);
111  }
112 };
113 
117 using PropertyDescriptorSeq = ::std::vector<PropertyDescriptor>;
118 
123 struct PropertySetDescriptor
124 {
128  ::Ice::StringSeq references;
132  ::IceGrid::PropertyDescriptorSeq properties;
133 
138  std::tuple<const ::Ice::StringSeq&, const ::IceGrid::PropertyDescriptorSeq&> ice_tuple() const
139  {
140  return std::tie(references, properties);
141  }
142 };
143 
147 using PropertySetDescriptorDict = ::std::map<::std::string, PropertySetDescriptor>;
148 
153 struct ObjectDescriptor
154 {
158  ::Ice::Identity id;
162  ::std::string type;
168  ::std::string proxyOptions;
169 
174  std::tuple<const ::Ice::Identity&, const ::std::string&, const ::std::string&> ice_tuple() const
175  {
176  return std::tie(id, type, proxyOptions);
177  }
178 };
179 
183 using ObjectDescriptorSeq = ::std::vector<ObjectDescriptor>;
184 
189 struct AdapterDescriptor
190 {
194  ::std::string name;
198  ::std::string description;
202  ::std::string id;
206  ::std::string replicaGroupId;
212  ::std::string priority;
216  bool registerProcess;
223  bool serverLifetime;
227  ::IceGrid::ObjectDescriptorSeq objects;
231  ::IceGrid::ObjectDescriptorSeq allocatables;
232 
237  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
238  {
239  return std::tie(name, description, id, replicaGroupId, priority, registerProcess, serverLifetime, objects, allocatables);
240  }
241 };
242 
246 using AdapterDescriptorSeq = ::std::vector<AdapterDescriptor>;
247 
252 struct DbEnvDescriptor
253 {
257  ::std::string name;
261  ::std::string description;
268  ::std::string dbHome;
272  ::IceGrid::PropertyDescriptorSeq properties;
273 
278  std::tuple<const ::std::string&, const ::std::string&, const ::std::string&, const ::IceGrid::PropertyDescriptorSeq&> ice_tuple() const
279  {
280  return std::tie(name, description, dbHome, properties);
281  }
282 };
283 
287 using DbEnvDescriptorSeq = ::std::vector<DbEnvDescriptor>;
288 
294 struct DistributionDescriptor
295 {
299  ::std::string icepatch;
303  ::Ice::StringSeq directories;
304 
309  std::tuple<const ::std::string&, const ::Ice::StringSeq&> ice_tuple() const
310  {
311  return std::tie(icepatch, directories);
312  }
313 };
314 
318 using ServerDescriptorSeq = ::std::vector<::std::shared_ptr<ServerDescriptor>>;
319 
323 using ServiceDescriptorSeq = ::std::vector<::std::shared_ptr<ServiceDescriptor>>;
324 
329 struct ServerInstanceDescriptor
330 {
334  ::std::string _cpp_template;
338  ::IceGrid::StringStringDict parameterValues;
342  ::IceGrid::PropertySetDescriptor propertySet;
347  ::IceGrid::PropertySetDescriptorDict servicePropertySets;
348 
353  std::tuple<const ::std::string&, const ::IceGrid::StringStringDict&, const ::IceGrid::PropertySetDescriptor&, const ::IceGrid::PropertySetDescriptorDict&> ice_tuple() const
354  {
355  return std::tie(_cpp_template, parameterValues, propertySet, servicePropertySets);
356  }
357 };
358 
362 using ServerInstanceDescriptorSeq = ::std::vector<ServerInstanceDescriptor>;
363 
368 struct TemplateDescriptor
369 {
373  ::std::shared_ptr<::IceGrid::CommunicatorDescriptor> descriptor;
377  ::Ice::StringSeq parameters;
381  ::IceGrid::StringStringDict parameterDefaults;
382 
387  std::tuple<const ::std::shared_ptr<::IceGrid::CommunicatorDescriptor>&, const ::Ice::StringSeq&, const ::IceGrid::StringStringDict&> ice_tuple() const
388  {
389  return std::tie(descriptor, parameters, parameterDefaults);
390  }
391 };
392 
396 using TemplateDescriptorDict = ::std::map<::std::string, TemplateDescriptor>;
397 
402 struct ServiceInstanceDescriptor
403 {
407  ::std::string _cpp_template;
411  ::IceGrid::StringStringDict parameterValues;
416  ::std::shared_ptr<::IceGrid::ServiceDescriptor> descriptor;
420  ::IceGrid::PropertySetDescriptor propertySet;
421 
426  std::tuple<const ::std::string&, const ::IceGrid::StringStringDict&, const ::std::shared_ptr<::IceGrid::ServiceDescriptor>&, const ::IceGrid::PropertySetDescriptor&> ice_tuple() const
427  {
428  return std::tie(_cpp_template, parameterValues, descriptor, propertySet);
429  }
430 };
431 
435 using ServiceInstanceDescriptorSeq = ::std::vector<ServiceInstanceDescriptor>;
436 
441 struct NodeDescriptor
442 {
446  ::IceGrid::StringStringDict variables;
450  ::IceGrid::ServerInstanceDescriptorSeq serverInstances;
454  ::IceGrid::ServerDescriptorSeq servers;
458  ::std::string loadFactor;
462  ::std::string description;
466  ::IceGrid::PropertySetDescriptorDict propertySets;
467 
472  std::tuple<const ::IceGrid::StringStringDict&, const ::IceGrid::ServerInstanceDescriptorSeq&, const ::IceGrid::ServerDescriptorSeq&, const ::std::string&, const ::std::string&, const ::IceGrid::PropertySetDescriptorDict&> ice_tuple() const
473  {
474  return std::tie(variables, serverInstances, servers, loadFactor, description, propertySets);
475  }
476 };
477 
481 using NodeDescriptorDict = ::std::map<::std::string, NodeDescriptor>;
482 
487 struct ReplicaGroupDescriptor
488 {
492  ::std::string id;
496  ::std::shared_ptr<::IceGrid::LoadBalancingPolicy> loadBalancing;
500  ::std::string proxyOptions;
504  ::IceGrid::ObjectDescriptorSeq objects;
508  ::std::string description;
512  ::std::string filter;
513 
518  std::tuple<const ::std::string&, const ::std::shared_ptr<::IceGrid::LoadBalancingPolicy>&, const ::std::string&, const ::IceGrid::ObjectDescriptorSeq&, const ::std::string&, const ::std::string&> ice_tuple() const
519  {
520  return std::tie(id, loadBalancing, proxyOptions, objects, description, filter);
521  }
522 };
523 
527 using ReplicaGroupDescriptorSeq = ::std::vector<ReplicaGroupDescriptor>;
528 
533 struct ApplicationDescriptor
534 {
538  ::std::string name;
542  ::IceGrid::StringStringDict variables;
546  ::IceGrid::ReplicaGroupDescriptorSeq replicaGroups;
550  ::IceGrid::TemplateDescriptorDict serverTemplates;
554  ::IceGrid::TemplateDescriptorDict serviceTemplates;
558  ::IceGrid::NodeDescriptorDict nodes;
562  ::IceGrid::DistributionDescriptor distrib;
566  ::std::string description;
570  ::IceGrid::PropertySetDescriptorDict propertySets;
571 
576  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
577  {
578  return std::tie(name, variables, replicaGroups, serverTemplates, serviceTemplates, nodes, distrib, description, propertySets);
579  }
580 };
581 
585 using ApplicationDescriptorSeq = ::std::vector<ApplicationDescriptor>;
586 
592 struct NodeUpdateDescriptor
593 {
597  ::std::string name;
602  ::std::shared_ptr<::IceGrid::BoxedString> description;
606  ::IceGrid::StringStringDict variables;
610  ::Ice::StringSeq removeVariables;
614  ::IceGrid::PropertySetDescriptorDict propertySets;
618  ::Ice::StringSeq removePropertySets;
622  ::IceGrid::ServerInstanceDescriptorSeq serverInstances;
626  ::IceGrid::ServerDescriptorSeq servers;
630  ::Ice::StringSeq removeServers;
635  ::std::shared_ptr<::IceGrid::BoxedString> loadFactor;
636 
641  std::tuple<const ::std::string&, const ::std::shared_ptr<::IceGrid::BoxedString>&, const ::IceGrid::StringStringDict&, const ::Ice::StringSeq&, const ::IceGrid::PropertySetDescriptorDict&, const ::Ice::StringSeq&, const ::IceGrid::ServerInstanceDescriptorSeq&, const ::IceGrid::ServerDescriptorSeq&, const ::Ice::StringSeq&, const ::std::shared_ptr<::IceGrid::BoxedString>&> ice_tuple() const
642  {
643  return std::tie(name, description, variables, removeVariables, propertySets, removePropertySets, serverInstances, servers, removeServers, loadFactor);
644  }
645 };
646 
650 using NodeUpdateDescriptorSeq = ::std::vector<NodeUpdateDescriptor>;
651 
657 struct ApplicationUpdateDescriptor
658 {
662  ::std::string name;
667  ::std::shared_ptr<::IceGrid::BoxedString> description;
671  ::std::shared_ptr<::IceGrid::BoxedDistributionDescriptor> distrib;
675  ::IceGrid::StringStringDict variables;
679  ::Ice::StringSeq removeVariables;
683  ::IceGrid::PropertySetDescriptorDict propertySets;
687  ::Ice::StringSeq removePropertySets;
691  ::IceGrid::ReplicaGroupDescriptorSeq replicaGroups;
695  ::Ice::StringSeq removeReplicaGroups;
699  ::IceGrid::TemplateDescriptorDict serverTemplates;
703  ::Ice::StringSeq removeServerTemplates;
707  ::IceGrid::TemplateDescriptorDict serviceTemplates;
711  ::Ice::StringSeq removeServiceTemplates;
715  ::IceGrid::NodeUpdateDescriptorSeq nodes;
719  ::Ice::StringSeq removeNodes;
720 
725  std::tuple<const ::std::string&, const ::std::shared_ptr<::IceGrid::BoxedString>&, const ::std::shared_ptr<::IceGrid::BoxedDistributionDescriptor>&, 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
726  {
727  return std::tie(name, description, distrib, variables, removeVariables, propertySets, removePropertySets, replicaGroups, removeReplicaGroups, serverTemplates, removeServerTemplates, serviceTemplates, removeServiceTemplates, nodes, removeNodes);
728  }
729 };
730 
731 using Ice::operator<;
732 using Ice::operator<=;
733 using Ice::operator>;
734 using Ice::operator>=;
735 using Ice::operator==;
736 using Ice::operator!=;
737 
738 }
739 
740 namespace IceGrid
741 {
742 
747 class ICE_CLASS(ICEGRID_API) CommunicatorDescriptor : public ::Ice::ValueHelper<CommunicatorDescriptor, ::Ice::Value>
748 {
749 public:
750 
751  ICE_MEMBER(ICEGRID_API) virtual ~CommunicatorDescriptor();
752 
753  CommunicatorDescriptor() = default;
754 
755  CommunicatorDescriptor(const CommunicatorDescriptor&) = default;
756  CommunicatorDescriptor(CommunicatorDescriptor&&) = default;
757  CommunicatorDescriptor& operator=(const CommunicatorDescriptor&) = default;
758  CommunicatorDescriptor& operator=(CommunicatorDescriptor&&) = default;
759 
768  CommunicatorDescriptor(const ::IceGrid::AdapterDescriptorSeq& adapters, const ::IceGrid::PropertySetDescriptor& propertySet, const ::IceGrid::DbEnvDescriptorSeq& dbEnvs, const ::Ice::StringSeq& logs, const ::std::string& description) :
769  adapters(adapters),
770  propertySet(propertySet),
771  dbEnvs(dbEnvs),
772  logs(logs),
773  description(description)
774  {
775  }
776 
781  std::tuple<const ::IceGrid::AdapterDescriptorSeq&, const ::IceGrid::PropertySetDescriptor&, const ::IceGrid::DbEnvDescriptorSeq&, const ::Ice::StringSeq&, const ::std::string&> ice_tuple() const
782  {
783  return std::tie(adapters, propertySet, dbEnvs, logs, description);
784  }
785 
790  ICE_MEMBER(ICEGRID_API) static const ::std::string& ice_staticId();
791 
795  ::IceGrid::AdapterDescriptorSeq adapters;
799  ::IceGrid::PropertySetDescriptor propertySet;
803  ::IceGrid::DbEnvDescriptorSeq dbEnvs;
807  ::Ice::StringSeq logs;
811  ::std::string description;
812 };
813 
815 static CommunicatorDescriptor _iceS_CommunicatorDescriptor_init;
817 
822 class ICE_CLASS(ICEGRID_API) ServerDescriptor : public ::Ice::ValueHelper<ServerDescriptor, CommunicatorDescriptor>
823 {
824 public:
825 
826  ICE_MEMBER(ICEGRID_API) virtual ~ServerDescriptor();
827 
828  ServerDescriptor() = default;
829 
830  ServerDescriptor(const ServerDescriptor&) = default;
831  ServerDescriptor(ServerDescriptor&&) = default;
832  ServerDescriptor& operator=(const ServerDescriptor&) = default;
833  ServerDescriptor& operator=(ServerDescriptor&&) = default;
834 
856  ServerDescriptor(const ::IceGrid::AdapterDescriptorSeq& adapters, const ::IceGrid::PropertySetDescriptor& propertySet, const ::IceGrid::DbEnvDescriptorSeq& dbEnvs, const ::Ice::StringSeq& logs, const ::std::string& description, const ::std::string& id, const ::std::string& exe, const ::std::string& iceVersion, const ::std::string& pwd, const ::Ice::StringSeq& options, const ::Ice::StringSeq& envs, const ::std::string& activation, const ::std::string& activationTimeout, const ::std::string& deactivationTimeout, bool applicationDistrib, const ::IceGrid::DistributionDescriptor& distrib, bool allocatable, const ::std::string& user) :
857  Ice::ValueHelper<ServerDescriptor, CommunicatorDescriptor>(adapters, propertySet, dbEnvs, logs, description),
858  id(id),
859  exe(exe),
860  iceVersion(iceVersion),
861  pwd(pwd),
862  options(options),
863  envs(envs),
864  activation(activation),
865  activationTimeout(activationTimeout),
866  deactivationTimeout(deactivationTimeout),
867  applicationDistrib(applicationDistrib),
868  distrib(distrib),
869  allocatable(allocatable),
870  user(user)
871  {
872  }
873 
878  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
879  {
880  return std::tie(adapters, propertySet, dbEnvs, logs, description, id, exe, iceVersion, pwd, options, envs, activation, activationTimeout, deactivationTimeout, applicationDistrib, distrib, allocatable, user);
881  }
882 
887  ICE_MEMBER(ICEGRID_API) static const ::std::string& ice_staticId();
888 
892  ::std::string id;
896  ::std::string exe;
904  ::std::string iceVersion;
908  ::std::string pwd;
912  ::Ice::StringSeq options;
916  ::Ice::StringSeq envs;
921  ::std::string activation;
926  ::std::string activationTimeout;
931  ::std::string deactivationTimeout;
936  bool applicationDistrib;
940  ::IceGrid::DistributionDescriptor distrib;
944  bool allocatable;
948  ::std::string user;
949 };
950 
955 class ICE_CLASS(ICEGRID_API) ServiceDescriptor : public ::Ice::ValueHelper<ServiceDescriptor, CommunicatorDescriptor>
956 {
957 public:
958 
959  ICE_MEMBER(ICEGRID_API) virtual ~ServiceDescriptor();
960 
961  ServiceDescriptor() = default;
962 
963  ServiceDescriptor(const ServiceDescriptor&) = default;
964  ServiceDescriptor(ServiceDescriptor&&) = default;
965  ServiceDescriptor& operator=(const ServiceDescriptor&) = default;
966  ServiceDescriptor& operator=(ServiceDescriptor&&) = default;
967 
978  ServiceDescriptor(const ::IceGrid::AdapterDescriptorSeq& adapters, const ::IceGrid::PropertySetDescriptor& propertySet, const ::IceGrid::DbEnvDescriptorSeq& dbEnvs, const ::Ice::StringSeq& logs, const ::std::string& description, const ::std::string& name, const ::std::string& entry) :
979  Ice::ValueHelper<ServiceDescriptor, CommunicatorDescriptor>(adapters, propertySet, dbEnvs, logs, description),
980  name(name),
981  entry(entry)
982  {
983  }
984 
989  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
990  {
991  return std::tie(adapters, propertySet, dbEnvs, logs, description, name, entry);
992  }
993 
998  ICE_MEMBER(ICEGRID_API) static const ::std::string& ice_staticId();
999 
1003  ::std::string name;
1007  ::std::string entry;
1008 };
1009 
1014 class ICE_CLASS(ICEGRID_API) IceBoxDescriptor : public ::Ice::ValueHelper<IceBoxDescriptor, ServerDescriptor>
1015 {
1016 public:
1017 
1018  ICE_MEMBER(ICEGRID_API) virtual ~IceBoxDescriptor();
1019 
1020  IceBoxDescriptor() = default;
1021 
1022  IceBoxDescriptor(const IceBoxDescriptor&) = default;
1023  IceBoxDescriptor(IceBoxDescriptor&&) = default;
1024  IceBoxDescriptor& operator=(const IceBoxDescriptor&) = default;
1025  IceBoxDescriptor& operator=(IceBoxDescriptor&&) = default;
1026 
1049  IceBoxDescriptor(const ::IceGrid::AdapterDescriptorSeq& adapters, const ::IceGrid::PropertySetDescriptor& propertySet, const ::IceGrid::DbEnvDescriptorSeq& dbEnvs, const ::Ice::StringSeq& logs, const ::std::string& description, const ::std::string& id, const ::std::string& exe, const ::std::string& iceVersion, const ::std::string& pwd, const ::Ice::StringSeq& options, const ::Ice::StringSeq& envs, const ::std::string& activation, const ::std::string& activationTimeout, const ::std::string& deactivationTimeout, bool applicationDistrib, const ::IceGrid::DistributionDescriptor& distrib, bool allocatable, const ::std::string& user, const ::IceGrid::ServiceInstanceDescriptorSeq& services) :
1050  Ice::ValueHelper<IceBoxDescriptor, ServerDescriptor>(adapters, propertySet, dbEnvs, logs, description, id, exe, iceVersion, pwd, options, envs, activation, activationTimeout, deactivationTimeout, applicationDistrib, distrib, allocatable, user),
1051  services(services)
1052  {
1053  }
1054 
1059  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
1060  {
1061  return std::tie(adapters, propertySet, dbEnvs, logs, description, id, exe, iceVersion, pwd, options, envs, activation, activationTimeout, deactivationTimeout, applicationDistrib, distrib, allocatable, user, services);
1062  }
1063 
1068  ICE_MEMBER(ICEGRID_API) static const ::std::string& ice_staticId();
1069 
1073  ::IceGrid::ServiceInstanceDescriptorSeq services;
1074 };
1075 
1080 class ICE_CLASS(ICEGRID_API) LoadBalancingPolicy : public ::Ice::ValueHelper<LoadBalancingPolicy, ::Ice::Value>
1081 {
1082 public:
1083 
1084  ICE_MEMBER(ICEGRID_API) virtual ~LoadBalancingPolicy();
1085 
1086  LoadBalancingPolicy() = default;
1087 
1088  LoadBalancingPolicy(const LoadBalancingPolicy&) = default;
1089  LoadBalancingPolicy(LoadBalancingPolicy&&) = default;
1090  LoadBalancingPolicy& operator=(const LoadBalancingPolicy&) = default;
1091  LoadBalancingPolicy& operator=(LoadBalancingPolicy&&) = default;
1092 
1097  explicit LoadBalancingPolicy(const ::std::string& nReplicas) :
1098  nReplicas(nReplicas)
1099  {
1100  }
1101 
1106  std::tuple<const ::std::string&> ice_tuple() const
1107  {
1108  return std::tie(nReplicas);
1109  }
1110 
1115  ICE_MEMBER(ICEGRID_API) static const ::std::string& ice_staticId();
1116 
1121  ::std::string nReplicas;
1122 };
1123 
1128 class ICE_CLASS(ICEGRID_API) RandomLoadBalancingPolicy : public ::Ice::ValueHelper<RandomLoadBalancingPolicy, LoadBalancingPolicy>
1129 {
1130 public:
1131 
1132  ICE_MEMBER(ICEGRID_API) virtual ~RandomLoadBalancingPolicy();
1133 
1134  RandomLoadBalancingPolicy() = default;
1135 
1136  RandomLoadBalancingPolicy(const RandomLoadBalancingPolicy&) = default;
1137  RandomLoadBalancingPolicy(RandomLoadBalancingPolicy&&) = default;
1138  RandomLoadBalancingPolicy& operator=(const RandomLoadBalancingPolicy&) = default;
1139  RandomLoadBalancingPolicy& operator=(RandomLoadBalancingPolicy&&) = default;
1140 
1145  explicit RandomLoadBalancingPolicy(const ::std::string& nReplicas) :
1146  Ice::ValueHelper<RandomLoadBalancingPolicy, LoadBalancingPolicy>(nReplicas)
1147  {
1148  }
1149 
1154  std::tuple<const ::std::string&> ice_tuple() const
1155  {
1156  return std::tie(nReplicas);
1157  }
1158 
1163  ICE_MEMBER(ICEGRID_API) static const ::std::string& ice_staticId();
1164 };
1165 
1170 class ICE_CLASS(ICEGRID_API) OrderedLoadBalancingPolicy : public ::Ice::ValueHelper<OrderedLoadBalancingPolicy, LoadBalancingPolicy>
1171 {
1172 public:
1173 
1174  ICE_MEMBER(ICEGRID_API) virtual ~OrderedLoadBalancingPolicy();
1175 
1176  OrderedLoadBalancingPolicy() = default;
1177 
1178  OrderedLoadBalancingPolicy(const OrderedLoadBalancingPolicy&) = default;
1179  OrderedLoadBalancingPolicy(OrderedLoadBalancingPolicy&&) = default;
1180  OrderedLoadBalancingPolicy& operator=(const OrderedLoadBalancingPolicy&) = default;
1181  OrderedLoadBalancingPolicy& operator=(OrderedLoadBalancingPolicy&&) = default;
1182 
1187  explicit OrderedLoadBalancingPolicy(const ::std::string& nReplicas) :
1188  Ice::ValueHelper<OrderedLoadBalancingPolicy, LoadBalancingPolicy>(nReplicas)
1189  {
1190  }
1191 
1196  std::tuple<const ::std::string&> ice_tuple() const
1197  {
1198  return std::tie(nReplicas);
1199  }
1200 
1205  ICE_MEMBER(ICEGRID_API) static const ::std::string& ice_staticId();
1206 };
1207 
1212 class ICE_CLASS(ICEGRID_API) RoundRobinLoadBalancingPolicy : public ::Ice::ValueHelper<RoundRobinLoadBalancingPolicy, LoadBalancingPolicy>
1213 {
1214 public:
1215 
1216  ICE_MEMBER(ICEGRID_API) virtual ~RoundRobinLoadBalancingPolicy();
1217 
1218  RoundRobinLoadBalancingPolicy() = default;
1219 
1220  RoundRobinLoadBalancingPolicy(const RoundRobinLoadBalancingPolicy&) = default;
1221  RoundRobinLoadBalancingPolicy(RoundRobinLoadBalancingPolicy&&) = default;
1222  RoundRobinLoadBalancingPolicy& operator=(const RoundRobinLoadBalancingPolicy&) = default;
1223  RoundRobinLoadBalancingPolicy& operator=(RoundRobinLoadBalancingPolicy&&) = default;
1224 
1229  explicit RoundRobinLoadBalancingPolicy(const ::std::string& nReplicas) :
1230  Ice::ValueHelper<RoundRobinLoadBalancingPolicy, LoadBalancingPolicy>(nReplicas)
1231  {
1232  }
1233 
1238  std::tuple<const ::std::string&> ice_tuple() const
1239  {
1240  return std::tie(nReplicas);
1241  }
1242 
1247  ICE_MEMBER(ICEGRID_API) static const ::std::string& ice_staticId();
1248 };
1249 
1254 class ICE_CLASS(ICEGRID_API) AdaptiveLoadBalancingPolicy : public ::Ice::ValueHelper<AdaptiveLoadBalancingPolicy, LoadBalancingPolicy>
1255 {
1256 public:
1257 
1258  ICE_MEMBER(ICEGRID_API) virtual ~AdaptiveLoadBalancingPolicy();
1259 
1260  AdaptiveLoadBalancingPolicy() = default;
1261 
1262  AdaptiveLoadBalancingPolicy(const AdaptiveLoadBalancingPolicy&) = default;
1263  AdaptiveLoadBalancingPolicy(AdaptiveLoadBalancingPolicy&&) = default;
1264  AdaptiveLoadBalancingPolicy& operator=(const AdaptiveLoadBalancingPolicy&) = default;
1265  AdaptiveLoadBalancingPolicy& operator=(AdaptiveLoadBalancingPolicy&&) = default;
1266 
1272  AdaptiveLoadBalancingPolicy(const ::std::string& nReplicas, const ::std::string& loadSample) :
1273  Ice::ValueHelper<AdaptiveLoadBalancingPolicy, LoadBalancingPolicy>(nReplicas),
1274  loadSample(loadSample)
1275  {
1276  }
1277 
1282  std::tuple<const ::std::string&, const ::std::string&> ice_tuple() const
1283  {
1284  return std::tie(nReplicas, loadSample);
1285  }
1286 
1291  ICE_MEMBER(ICEGRID_API) static const ::std::string& ice_staticId();
1292 
1299  ::std::string loadSample;
1300 };
1301 
1306 class ICE_CLASS(ICEGRID_API) BoxedString : public ::Ice::ValueHelper<BoxedString, ::Ice::Value>
1307 {
1308 public:
1309 
1310  ICE_MEMBER(ICEGRID_API) virtual ~BoxedString();
1311 
1312  BoxedString() = default;
1313 
1314  BoxedString(const BoxedString&) = default;
1315  BoxedString(BoxedString&&) = default;
1316  BoxedString& operator=(const BoxedString&) = default;
1317  BoxedString& operator=(BoxedString&&) = default;
1318 
1323  explicit BoxedString(const ::std::string& value) :
1324  value(value)
1325  {
1326  }
1327 
1332  std::tuple<const ::std::string&> ice_tuple() const
1333  {
1334  return std::tie(value);
1335  }
1336 
1341  ICE_MEMBER(ICEGRID_API) static const ::std::string& ice_staticId();
1342 
1346  ::std::string value;
1347 };
1348 
1353 class ICE_CLASS(ICEGRID_API) BoxedDistributionDescriptor : public ::Ice::ValueHelper<BoxedDistributionDescriptor, ::Ice::Value>
1354 {
1355 public:
1356 
1357  ICE_MEMBER(ICEGRID_API) virtual ~BoxedDistributionDescriptor();
1358 
1359  BoxedDistributionDescriptor() = default;
1360 
1361  BoxedDistributionDescriptor(const BoxedDistributionDescriptor&) = default;
1362  BoxedDistributionDescriptor(BoxedDistributionDescriptor&&) = default;
1363  BoxedDistributionDescriptor& operator=(const BoxedDistributionDescriptor&) = default;
1364  BoxedDistributionDescriptor& operator=(BoxedDistributionDescriptor&&) = default;
1365 
1370  explicit BoxedDistributionDescriptor(const ::IceGrid::DistributionDescriptor& value) :
1371  value(value)
1372  {
1373  }
1374 
1379  std::tuple<const ::IceGrid::DistributionDescriptor&> ice_tuple() const
1380  {
1381  return std::tie(value);
1382  }
1383 
1388  ICE_MEMBER(ICEGRID_API) static const ::std::string& ice_staticId();
1389 
1393  ::IceGrid::DistributionDescriptor value;
1394 };
1395 
1396 }
1397 
1398 namespace IceGrid
1399 {
1400 
1401 }
1402 
1404 namespace Ice
1405 {
1406 
1407 template<>
1408 struct StreamableTraits<::IceGrid::PropertyDescriptor>
1409 {
1410  static const StreamHelperCategory helper = StreamHelperCategoryStruct;
1411  static const int minWireSize = 2;
1412  static const bool fixedLength = false;
1413 };
1414 
1415 template<typename S>
1416 struct StreamReader<::IceGrid::PropertyDescriptor, S>
1417 {
1418  static void read(S* istr, ::IceGrid::PropertyDescriptor& v)
1419  {
1420  istr->readAll(v.name, v.value);
1421  }
1422 };
1423 
1424 template<>
1425 struct StreamableTraits<::IceGrid::PropertySetDescriptor>
1426 {
1427  static const StreamHelperCategory helper = StreamHelperCategoryStruct;
1428  static const int minWireSize = 2;
1429  static const bool fixedLength = false;
1430 };
1431 
1432 template<typename S>
1433 struct StreamReader<::IceGrid::PropertySetDescriptor, S>
1434 {
1435  static void read(S* istr, ::IceGrid::PropertySetDescriptor& v)
1436  {
1437  istr->readAll(v.references, v.properties);
1438  }
1439 };
1440 
1441 template<>
1442 struct StreamableTraits<::IceGrid::ObjectDescriptor>
1443 {
1444  static const StreamHelperCategory helper = StreamHelperCategoryStruct;
1445  static const int minWireSize = 4;
1446  static const bool fixedLength = false;
1447 };
1448 
1449 template<typename S>
1450 struct StreamReader<::IceGrid::ObjectDescriptor, S>
1451 {
1452  static void read(S* istr, ::IceGrid::ObjectDescriptor& v)
1453  {
1454  istr->readAll(v.id, v.type, v.proxyOptions);
1455  }
1456 };
1457 
1458 template<>
1459 struct StreamableTraits<::IceGrid::AdapterDescriptor>
1460 {
1461  static const StreamHelperCategory helper = StreamHelperCategoryStruct;
1462  static const int minWireSize = 9;
1463  static const bool fixedLength = false;
1464 };
1465 
1466 template<typename S>
1467 struct StreamReader<::IceGrid::AdapterDescriptor, S>
1468 {
1469  static void read(S* istr, ::IceGrid::AdapterDescriptor& v)
1470  {
1471  istr->readAll(v.name, v.description, v.id, v.replicaGroupId, v.priority, v.registerProcess, v.serverLifetime, v.objects, v.allocatables);
1472  }
1473 };
1474 
1475 template<>
1476 struct StreamableTraits<::IceGrid::DbEnvDescriptor>
1477 {
1478  static const StreamHelperCategory helper = StreamHelperCategoryStruct;
1479  static const int minWireSize = 4;
1480  static const bool fixedLength = false;
1481 };
1482 
1483 template<typename S>
1484 struct StreamReader<::IceGrid::DbEnvDescriptor, S>
1485 {
1486  static void read(S* istr, ::IceGrid::DbEnvDescriptor& v)
1487  {
1488  istr->readAll(v.name, v.description, v.dbHome, v.properties);
1489  }
1490 };
1491 
1492 template<typename S>
1493 struct StreamReader<::IceGrid::CommunicatorDescriptor, S>
1494 {
1495  static void read(S* istr, ::IceGrid::CommunicatorDescriptor& v)
1496  {
1497  istr->readAll(v.adapters, v.propertySet, v.dbEnvs, v.logs, v.description);
1498  }
1499 };
1500 
1501 template<>
1502 struct StreamableTraits<::IceGrid::DistributionDescriptor>
1503 {
1504  static const StreamHelperCategory helper = StreamHelperCategoryStruct;
1505  static const int minWireSize = 2;
1506  static const bool fixedLength = false;
1507 };
1508 
1509 template<typename S>
1510 struct StreamReader<::IceGrid::DistributionDescriptor, S>
1511 {
1512  static void read(S* istr, ::IceGrid::DistributionDescriptor& v)
1513  {
1514  istr->readAll(v.icepatch, v.directories);
1515  }
1516 };
1517 
1518 template<typename S>
1519 struct StreamWriter<::IceGrid::ServerDescriptor, S>
1520 {
1521  static void write(S* ostr, const ::IceGrid::ServerDescriptor& v)
1522  {
1523  ostr->writeAll(v.id, v.exe, v.iceVersion, v.pwd, v.options, v.envs, v.activation, v.activationTimeout, v.deactivationTimeout, v.applicationDistrib, v.distrib, v.allocatable, v.user);
1524  }
1525 };
1526 
1527 template<typename S>
1528 struct StreamReader<::IceGrid::ServerDescriptor, S>
1529 {
1530  static void read(S* istr, ::IceGrid::ServerDescriptor& v)
1531  {
1532  istr->readAll(v.id, v.exe, v.iceVersion, v.pwd, v.options, v.envs, v.activation, v.activationTimeout, v.deactivationTimeout, v.applicationDistrib, v.distrib, v.allocatable, v.user);
1533  }
1534 };
1535 
1536 template<typename S>
1537 struct StreamWriter<::IceGrid::ServiceDescriptor, S>
1538 {
1539  static void write(S* ostr, const ::IceGrid::ServiceDescriptor& v)
1540  {
1541  ostr->writeAll(v.name, v.entry);
1542  }
1543 };
1544 
1545 template<typename S>
1546 struct StreamReader<::IceGrid::ServiceDescriptor, S>
1547 {
1548  static void read(S* istr, ::IceGrid::ServiceDescriptor& v)
1549  {
1550  istr->readAll(v.name, v.entry);
1551  }
1552 };
1553 
1554 template<>
1555 struct StreamableTraits<::IceGrid::ServerInstanceDescriptor>
1556 {
1557  static const StreamHelperCategory helper = StreamHelperCategoryStruct;
1558  static const int minWireSize = 5;
1559  static const bool fixedLength = false;
1560 };
1561 
1562 template<typename S>
1563 struct StreamReader<::IceGrid::ServerInstanceDescriptor, S>
1564 {
1565  static void read(S* istr, ::IceGrid::ServerInstanceDescriptor& v)
1566  {
1567  istr->readAll(v._cpp_template, v.parameterValues, v.propertySet, v.servicePropertySets);
1568  }
1569 };
1570 
1571 template<>
1572 struct StreamableTraits<::IceGrid::TemplateDescriptor>
1573 {
1574  static const StreamHelperCategory helper = StreamHelperCategoryStruct;
1575  static const int minWireSize = 3;
1576  static const bool fixedLength = false;
1577 };
1578 
1579 template<typename S>
1580 struct StreamReader<::IceGrid::TemplateDescriptor, S>
1581 {
1582  static void read(S* istr, ::IceGrid::TemplateDescriptor& v)
1583  {
1584  istr->readAll(v.descriptor, v.parameters, v.parameterDefaults);
1585  }
1586 };
1587 
1588 template<>
1589 struct StreamableTraits<::IceGrid::ServiceInstanceDescriptor>
1590 {
1591  static const StreamHelperCategory helper = StreamHelperCategoryStruct;
1592  static const int minWireSize = 5;
1593  static const bool fixedLength = false;
1594 };
1595 
1596 template<typename S>
1597 struct StreamReader<::IceGrid::ServiceInstanceDescriptor, S>
1598 {
1599  static void read(S* istr, ::IceGrid::ServiceInstanceDescriptor& v)
1600  {
1601  istr->readAll(v._cpp_template, v.parameterValues, v.descriptor, v.propertySet);
1602  }
1603 };
1604 
1605 template<typename S>
1606 struct StreamWriter<::IceGrid::IceBoxDescriptor, S>
1607 {
1608  static void write(S* ostr, const ::IceGrid::IceBoxDescriptor& v)
1609  {
1610  ostr->writeAll(v.services);
1611  }
1612 };
1613 
1614 template<typename S>
1615 struct StreamReader<::IceGrid::IceBoxDescriptor, S>
1616 {
1617  static void read(S* istr, ::IceGrid::IceBoxDescriptor& v)
1618  {
1619  istr->readAll(v.services);
1620  }
1621 };
1622 
1623 template<>
1624 struct StreamableTraits<::IceGrid::NodeDescriptor>
1625 {
1626  static const StreamHelperCategory helper = StreamHelperCategoryStruct;
1627  static const int minWireSize = 6;
1628  static const bool fixedLength = false;
1629 };
1630 
1631 template<typename S>
1632 struct StreamReader<::IceGrid::NodeDescriptor, S>
1633 {
1634  static void read(S* istr, ::IceGrid::NodeDescriptor& v)
1635  {
1636  istr->readAll(v.variables, v.serverInstances, v.servers, v.loadFactor, v.description, v.propertySets);
1637  }
1638 };
1639 
1640 template<typename S>
1641 struct StreamReader<::IceGrid::LoadBalancingPolicy, S>
1642 {
1643  static void read(S* istr, ::IceGrid::LoadBalancingPolicy& v)
1644  {
1645  istr->readAll(v.nReplicas);
1646  }
1647 };
1648 
1649 template<typename S>
1650 struct StreamWriter<::IceGrid::RandomLoadBalancingPolicy, S>
1651 {
1652  static void write(S*, const ::IceGrid::RandomLoadBalancingPolicy&)
1653  {
1654  }
1655 };
1656 
1657 template<typename S>
1658 struct StreamReader<::IceGrid::RandomLoadBalancingPolicy, S>
1659 {
1660  static void read(S*, ::IceGrid::RandomLoadBalancingPolicy&)
1661  {
1662  }
1663 };
1664 
1665 template<typename S>
1666 struct StreamWriter<::IceGrid::OrderedLoadBalancingPolicy, S>
1667 {
1668  static void write(S*, const ::IceGrid::OrderedLoadBalancingPolicy&)
1669  {
1670  }
1671 };
1672 
1673 template<typename S>
1674 struct StreamReader<::IceGrid::OrderedLoadBalancingPolicy, S>
1675 {
1676  static void read(S*, ::IceGrid::OrderedLoadBalancingPolicy&)
1677  {
1678  }
1679 };
1680 
1681 template<typename S>
1682 struct StreamWriter<::IceGrid::RoundRobinLoadBalancingPolicy, S>
1683 {
1684  static void write(S*, const ::IceGrid::RoundRobinLoadBalancingPolicy&)
1685  {
1686  }
1687 };
1688 
1689 template<typename S>
1690 struct StreamReader<::IceGrid::RoundRobinLoadBalancingPolicy, S>
1691 {
1692  static void read(S*, ::IceGrid::RoundRobinLoadBalancingPolicy&)
1693  {
1694  }
1695 };
1696 
1697 template<typename S>
1698 struct StreamWriter<::IceGrid::AdaptiveLoadBalancingPolicy, S>
1699 {
1700  static void write(S* ostr, const ::IceGrid::AdaptiveLoadBalancingPolicy& v)
1701  {
1702  ostr->writeAll(v.loadSample);
1703  }
1704 };
1705 
1706 template<typename S>
1707 struct StreamReader<::IceGrid::AdaptiveLoadBalancingPolicy, S>
1708 {
1709  static void read(S* istr, ::IceGrid::AdaptiveLoadBalancingPolicy& v)
1710  {
1711  istr->readAll(v.loadSample);
1712  }
1713 };
1714 
1715 template<>
1716 struct StreamableTraits<::IceGrid::ReplicaGroupDescriptor>
1717 {
1718  static const StreamHelperCategory helper = StreamHelperCategoryStruct;
1719  static const int minWireSize = 6;
1720  static const bool fixedLength = false;
1721 };
1722 
1723 template<typename S>
1724 struct StreamReader<::IceGrid::ReplicaGroupDescriptor, S>
1725 {
1726  static void read(S* istr, ::IceGrid::ReplicaGroupDescriptor& v)
1727  {
1728  istr->readAll(v.id, v.loadBalancing, v.proxyOptions, v.objects, v.description, v.filter);
1729  }
1730 };
1731 
1732 template<>
1733 struct StreamableTraits<::IceGrid::ApplicationDescriptor>
1734 {
1735  static const StreamHelperCategory helper = StreamHelperCategoryStruct;
1736  static const int minWireSize = 10;
1737  static const bool fixedLength = false;
1738 };
1739 
1740 template<typename S>
1741 struct StreamReader<::IceGrid::ApplicationDescriptor, S>
1742 {
1743  static void read(S* istr, ::IceGrid::ApplicationDescriptor& v)
1744  {
1745  istr->readAll(v.name, v.variables, v.replicaGroups, v.serverTemplates, v.serviceTemplates, v.nodes, v.distrib, v.description, v.propertySets);
1746  }
1747 };
1748 
1749 template<typename S>
1750 struct StreamReader<::IceGrid::BoxedString, S>
1751 {
1752  static void read(S* istr, ::IceGrid::BoxedString& v)
1753  {
1754  istr->readAll(v.value);
1755  }
1756 };
1757 
1758 template<>
1759 struct StreamableTraits<::IceGrid::NodeUpdateDescriptor>
1760 {
1761  static const StreamHelperCategory helper = StreamHelperCategoryStruct;
1762  static const int minWireSize = 10;
1763  static const bool fixedLength = false;
1764 };
1765 
1766 template<typename S>
1767 struct StreamReader<::IceGrid::NodeUpdateDescriptor, S>
1768 {
1769  static void read(S* istr, ::IceGrid::NodeUpdateDescriptor& v)
1770  {
1771  istr->readAll(v.name, v.description, v.variables, v.removeVariables, v.propertySets, v.removePropertySets, v.serverInstances, v.servers, v.removeServers, v.loadFactor);
1772  }
1773 };
1774 
1775 template<typename S>
1776 struct StreamReader<::IceGrid::BoxedDistributionDescriptor, S>
1777 {
1778  static void read(S* istr, ::IceGrid::BoxedDistributionDescriptor& v)
1779  {
1780  istr->readAll(v.value);
1781  }
1782 };
1783 
1784 template<>
1785 struct StreamableTraits<::IceGrid::ApplicationUpdateDescriptor>
1786 {
1787  static const StreamHelperCategory helper = StreamHelperCategoryStruct;
1788  static const int minWireSize = 15;
1789  static const bool fixedLength = false;
1790 };
1791 
1792 template<typename S>
1793 struct StreamReader<::IceGrid::ApplicationUpdateDescriptor, S>
1794 {
1795  static void read(S* istr, ::IceGrid::ApplicationUpdateDescriptor& v)
1796  {
1797  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);
1798  }
1799 };
1800 
1801 }
1803 
1805 namespace IceGrid
1806 {
1807 
1808 using CommunicatorDescriptorPtr = ::std::shared_ptr<CommunicatorDescriptor>;
1809 
1810 using ServerDescriptorPtr = ::std::shared_ptr<ServerDescriptor>;
1811 
1812 using ServiceDescriptorPtr = ::std::shared_ptr<ServiceDescriptor>;
1813 
1814 using IceBoxDescriptorPtr = ::std::shared_ptr<IceBoxDescriptor>;
1815 
1816 using LoadBalancingPolicyPtr = ::std::shared_ptr<LoadBalancingPolicy>;
1817 
1818 using RandomLoadBalancingPolicyPtr = ::std::shared_ptr<RandomLoadBalancingPolicy>;
1819 
1820 using OrderedLoadBalancingPolicyPtr = ::std::shared_ptr<OrderedLoadBalancingPolicy>;
1821 
1822 using RoundRobinLoadBalancingPolicyPtr = ::std::shared_ptr<RoundRobinLoadBalancingPolicy>;
1823 
1824 using AdaptiveLoadBalancingPolicyPtr = ::std::shared_ptr<AdaptiveLoadBalancingPolicy>;
1825 
1826 using BoxedStringPtr = ::std::shared_ptr<BoxedString>;
1827 
1828 using BoxedDistributionDescriptorPtr = ::std::shared_ptr<BoxedDistributionDescriptor>;
1829 
1830 }
1832 
1833 #else // C++98 mapping
1834 
1835 namespace IceProxy
1836 {
1837 
1838 namespace IceGrid
1839 {
1840 
1841 class CommunicatorDescriptor;
1843 ICEGRID_API void _readProxy(::Ice::InputStream*, ::IceInternal::ProxyHandle< CommunicatorDescriptor>&);
1844 ICEGRID_API ::IceProxy::Ice::Object* upCast(CommunicatorDescriptor*);
1846 
1847 class ServerDescriptor;
1849 ICEGRID_API void _readProxy(::Ice::InputStream*, ::IceInternal::ProxyHandle< ServerDescriptor>&);
1850 ICEGRID_API ::IceProxy::Ice::Object* upCast(ServerDescriptor*);
1852 
1853 class ServiceDescriptor;
1855 ICEGRID_API void _readProxy(::Ice::InputStream*, ::IceInternal::ProxyHandle< ServiceDescriptor>&);
1856 ICEGRID_API ::IceProxy::Ice::Object* upCast(ServiceDescriptor*);
1858 
1859 class IceBoxDescriptor;
1861 ICEGRID_API void _readProxy(::Ice::InputStream*, ::IceInternal::ProxyHandle< IceBoxDescriptor>&);
1862 ICEGRID_API ::IceProxy::Ice::Object* upCast(IceBoxDescriptor*);
1864 
1865 class LoadBalancingPolicy;
1867 ICEGRID_API void _readProxy(::Ice::InputStream*, ::IceInternal::ProxyHandle< LoadBalancingPolicy>&);
1868 ICEGRID_API ::IceProxy::Ice::Object* upCast(LoadBalancingPolicy*);
1870 
1871 class RandomLoadBalancingPolicy;
1873 ICEGRID_API void _readProxy(::Ice::InputStream*, ::IceInternal::ProxyHandle< RandomLoadBalancingPolicy>&);
1874 ICEGRID_API ::IceProxy::Ice::Object* upCast(RandomLoadBalancingPolicy*);
1876 
1877 class OrderedLoadBalancingPolicy;
1879 ICEGRID_API void _readProxy(::Ice::InputStream*, ::IceInternal::ProxyHandle< OrderedLoadBalancingPolicy>&);
1880 ICEGRID_API ::IceProxy::Ice::Object* upCast(OrderedLoadBalancingPolicy*);
1882 
1883 class RoundRobinLoadBalancingPolicy;
1885 ICEGRID_API void _readProxy(::Ice::InputStream*, ::IceInternal::ProxyHandle< RoundRobinLoadBalancingPolicy>&);
1886 ICEGRID_API ::IceProxy::Ice::Object* upCast(RoundRobinLoadBalancingPolicy*);
1888 
1889 class AdaptiveLoadBalancingPolicy;
1891 ICEGRID_API void _readProxy(::Ice::InputStream*, ::IceInternal::ProxyHandle< AdaptiveLoadBalancingPolicy>&);
1892 ICEGRID_API ::IceProxy::Ice::Object* upCast(AdaptiveLoadBalancingPolicy*);
1894 
1895 class BoxedString;
1897 ICEGRID_API void _readProxy(::Ice::InputStream*, ::IceInternal::ProxyHandle< BoxedString>&);
1898 ICEGRID_API ::IceProxy::Ice::Object* upCast(BoxedString*);
1900 
1901 class BoxedDistributionDescriptor;
1903 ICEGRID_API void _readProxy(::Ice::InputStream*, ::IceInternal::ProxyHandle< BoxedDistributionDescriptor>&);
1904 ICEGRID_API ::IceProxy::Ice::Object* upCast(BoxedDistributionDescriptor*);
1906 
1907 }
1908 
1909 }
1910 
1911 namespace IceGrid
1912 {
1913 
1914 class CommunicatorDescriptor;
1916 ICEGRID_API ::Ice::Object* upCast(CommunicatorDescriptor*);
1918 typedef ::IceInternal::Handle< CommunicatorDescriptor> CommunicatorDescriptorPtr;
1919 typedef ::IceInternal::ProxyHandle< ::IceProxy::IceGrid::CommunicatorDescriptor> CommunicatorDescriptorPrx;
1920 typedef CommunicatorDescriptorPrx CommunicatorDescriptorPrxPtr;
1922 ICEGRID_API void _icePatchObjectPtr(CommunicatorDescriptorPtr&, const ::Ice::ObjectPtr&);
1924 
1925 class ServerDescriptor;
1927 ICEGRID_API ::Ice::Object* upCast(ServerDescriptor*);
1929 typedef ::IceInternal::Handle< ServerDescriptor> ServerDescriptorPtr;
1930 typedef ::IceInternal::ProxyHandle< ::IceProxy::IceGrid::ServerDescriptor> ServerDescriptorPrx;
1931 typedef ServerDescriptorPrx ServerDescriptorPrxPtr;
1933 ICEGRID_API void _icePatchObjectPtr(ServerDescriptorPtr&, const ::Ice::ObjectPtr&);
1935 
1936 class ServiceDescriptor;
1938 ICEGRID_API ::Ice::Object* upCast(ServiceDescriptor*);
1940 typedef ::IceInternal::Handle< ServiceDescriptor> ServiceDescriptorPtr;
1941 typedef ::IceInternal::ProxyHandle< ::IceProxy::IceGrid::ServiceDescriptor> ServiceDescriptorPrx;
1942 typedef ServiceDescriptorPrx ServiceDescriptorPrxPtr;
1944 ICEGRID_API void _icePatchObjectPtr(ServiceDescriptorPtr&, const ::Ice::ObjectPtr&);
1946 
1947 class IceBoxDescriptor;
1949 ICEGRID_API ::Ice::Object* upCast(IceBoxDescriptor*);
1951 typedef ::IceInternal::Handle< IceBoxDescriptor> IceBoxDescriptorPtr;
1952 typedef ::IceInternal::ProxyHandle< ::IceProxy::IceGrid::IceBoxDescriptor> IceBoxDescriptorPrx;
1953 typedef IceBoxDescriptorPrx IceBoxDescriptorPrxPtr;
1955 ICEGRID_API void _icePatchObjectPtr(IceBoxDescriptorPtr&, const ::Ice::ObjectPtr&);
1957 
1958 class LoadBalancingPolicy;
1960 ICEGRID_API ::Ice::Object* upCast(LoadBalancingPolicy*);
1962 typedef ::IceInternal::Handle< LoadBalancingPolicy> LoadBalancingPolicyPtr;
1963 typedef ::IceInternal::ProxyHandle< ::IceProxy::IceGrid::LoadBalancingPolicy> LoadBalancingPolicyPrx;
1964 typedef LoadBalancingPolicyPrx LoadBalancingPolicyPrxPtr;
1966 ICEGRID_API void _icePatchObjectPtr(LoadBalancingPolicyPtr&, const ::Ice::ObjectPtr&);
1968 
1969 class RandomLoadBalancingPolicy;
1971 ICEGRID_API ::Ice::Object* upCast(RandomLoadBalancingPolicy*);
1973 typedef ::IceInternal::Handle< RandomLoadBalancingPolicy> RandomLoadBalancingPolicyPtr;
1974 typedef ::IceInternal::ProxyHandle< ::IceProxy::IceGrid::RandomLoadBalancingPolicy> RandomLoadBalancingPolicyPrx;
1975 typedef RandomLoadBalancingPolicyPrx RandomLoadBalancingPolicyPrxPtr;
1977 ICEGRID_API void _icePatchObjectPtr(RandomLoadBalancingPolicyPtr&, const ::Ice::ObjectPtr&);
1979 
1980 class OrderedLoadBalancingPolicy;
1982 ICEGRID_API ::Ice::Object* upCast(OrderedLoadBalancingPolicy*);
1984 typedef ::IceInternal::Handle< OrderedLoadBalancingPolicy> OrderedLoadBalancingPolicyPtr;
1985 typedef ::IceInternal::ProxyHandle< ::IceProxy::IceGrid::OrderedLoadBalancingPolicy> OrderedLoadBalancingPolicyPrx;
1986 typedef OrderedLoadBalancingPolicyPrx OrderedLoadBalancingPolicyPrxPtr;
1988 ICEGRID_API void _icePatchObjectPtr(OrderedLoadBalancingPolicyPtr&, const ::Ice::ObjectPtr&);
1990 
1991 class RoundRobinLoadBalancingPolicy;
1993 ICEGRID_API ::Ice::Object* upCast(RoundRobinLoadBalancingPolicy*);
1995 typedef ::IceInternal::Handle< RoundRobinLoadBalancingPolicy> RoundRobinLoadBalancingPolicyPtr;
1996 typedef ::IceInternal::ProxyHandle< ::IceProxy::IceGrid::RoundRobinLoadBalancingPolicy> RoundRobinLoadBalancingPolicyPrx;
1997 typedef RoundRobinLoadBalancingPolicyPrx RoundRobinLoadBalancingPolicyPrxPtr;
1999 ICEGRID_API void _icePatchObjectPtr(RoundRobinLoadBalancingPolicyPtr&, const ::Ice::ObjectPtr&);
2001 
2002 class AdaptiveLoadBalancingPolicy;
2004 ICEGRID_API ::Ice::Object* upCast(AdaptiveLoadBalancingPolicy*);
2006 typedef ::IceInternal::Handle< AdaptiveLoadBalancingPolicy> AdaptiveLoadBalancingPolicyPtr;
2007 typedef ::IceInternal::ProxyHandle< ::IceProxy::IceGrid::AdaptiveLoadBalancingPolicy> AdaptiveLoadBalancingPolicyPrx;
2008 typedef AdaptiveLoadBalancingPolicyPrx AdaptiveLoadBalancingPolicyPrxPtr;
2010 ICEGRID_API void _icePatchObjectPtr(AdaptiveLoadBalancingPolicyPtr&, const ::Ice::ObjectPtr&);
2012 
2013 class BoxedString;
2015 ICEGRID_API ::Ice::Object* upCast(BoxedString*);
2017 typedef ::IceInternal::Handle< BoxedString> BoxedStringPtr;
2018 typedef ::IceInternal::ProxyHandle< ::IceProxy::IceGrid::BoxedString> BoxedStringPrx;
2019 typedef BoxedStringPrx BoxedStringPrxPtr;
2021 ICEGRID_API void _icePatchObjectPtr(BoxedStringPtr&, const ::Ice::ObjectPtr&);
2023 
2024 class BoxedDistributionDescriptor;
2026 ICEGRID_API ::Ice::Object* upCast(BoxedDistributionDescriptor*);
2028 typedef ::IceInternal::Handle< BoxedDistributionDescriptor> BoxedDistributionDescriptorPtr;
2029 typedef ::IceInternal::ProxyHandle< ::IceProxy::IceGrid::BoxedDistributionDescriptor> BoxedDistributionDescriptorPrx;
2030 typedef BoxedDistributionDescriptorPrx BoxedDistributionDescriptorPrxPtr;
2032 ICEGRID_API void _icePatchObjectPtr(BoxedDistributionDescriptorPtr&, const ::Ice::ObjectPtr&);
2034 
2035 }
2036 
2037 namespace IceGrid
2038 {
2039 
2043 typedef ::std::map< ::std::string, ::std::string> StringStringDict;
2044 
2049 struct PropertyDescriptor
2050 {
2054  ::std::string name;
2058  ::std::string value;
2059 
2060  bool operator==(const PropertyDescriptor& rhs_) const
2061  {
2062  if(this == &rhs_)
2063  {
2064  return true;
2065  }
2066  if(name != rhs_.name)
2067  {
2068  return false;
2069  }
2070  if(value != rhs_.value)
2071  {
2072  return false;
2073  }
2074  return true;
2075  }
2076 
2077  bool operator<(const PropertyDescriptor& rhs_) const
2078  {
2079  if(this == &rhs_)
2080  {
2081  return false;
2082  }
2083  if(name < rhs_.name)
2084  {
2085  return true;
2086  }
2087  else if(rhs_.name < name)
2088  {
2089  return false;
2090  }
2091  if(value < rhs_.value)
2092  {
2093  return true;
2094  }
2095  else if(rhs_.value < value)
2096  {
2097  return false;
2098  }
2099  return false;
2100  }
2101 
2102  bool operator!=(const PropertyDescriptor& rhs_) const
2103  {
2104  return !operator==(rhs_);
2105  }
2106  bool operator<=(const PropertyDescriptor& rhs_) const
2107  {
2108  return operator<(rhs_) || operator==(rhs_);
2109  }
2110  bool operator>(const PropertyDescriptor& rhs_) const
2111  {
2112  return !operator<(rhs_) && !operator==(rhs_);
2113  }
2114  bool operator>=(const PropertyDescriptor& rhs_) const
2115  {
2116  return !operator<(rhs_);
2117  }
2118 };
2119 
2123 typedef ::std::vector<PropertyDescriptor> PropertyDescriptorSeq;
2124 
2129 struct PropertySetDescriptor
2130 {
2134  ::Ice::StringSeq references;
2138  ::IceGrid::PropertyDescriptorSeq properties;
2139 
2140  bool operator==(const PropertySetDescriptor& rhs_) const
2141  {
2142  if(this == &rhs_)
2143  {
2144  return true;
2145  }
2146  if(references != rhs_.references)
2147  {
2148  return false;
2149  }
2150  if(properties != rhs_.properties)
2151  {
2152  return false;
2153  }
2154  return true;
2155  }
2156 
2157  bool operator<(const PropertySetDescriptor& rhs_) const
2158  {
2159  if(this == &rhs_)
2160  {
2161  return false;
2162  }
2163  if(references < rhs_.references)
2164  {
2165  return true;
2166  }
2167  else if(rhs_.references < references)
2168  {
2169  return false;
2170  }
2171  if(properties < rhs_.properties)
2172  {
2173  return true;
2174  }
2175  else if(rhs_.properties < properties)
2176  {
2177  return false;
2178  }
2179  return false;
2180  }
2181 
2182  bool operator!=(const PropertySetDescriptor& rhs_) const
2183  {
2184  return !operator==(rhs_);
2185  }
2186  bool operator<=(const PropertySetDescriptor& rhs_) const
2187  {
2188  return operator<(rhs_) || operator==(rhs_);
2189  }
2190  bool operator>(const PropertySetDescriptor& rhs_) const
2191  {
2192  return !operator<(rhs_) && !operator==(rhs_);
2193  }
2194  bool operator>=(const PropertySetDescriptor& rhs_) const
2195  {
2196  return !operator<(rhs_);
2197  }
2198 };
2199 
2203 typedef ::std::map< ::std::string, PropertySetDescriptor> PropertySetDescriptorDict;
2204 
2209 struct ObjectDescriptor
2210 {
2214  ::Ice::Identity id;
2218  ::std::string type;
2224  ::std::string proxyOptions;
2225 
2226  bool operator==(const ObjectDescriptor& rhs_) const
2227  {
2228  if(this == &rhs_)
2229  {
2230  return true;
2231  }
2232  if(id != rhs_.id)
2233  {
2234  return false;
2235  }
2236  if(type != rhs_.type)
2237  {
2238  return false;
2239  }
2240  if(proxyOptions != rhs_.proxyOptions)
2241  {
2242  return false;
2243  }
2244  return true;
2245  }
2246 
2247  bool operator<(const ObjectDescriptor& rhs_) const
2248  {
2249  if(this == &rhs_)
2250  {
2251  return false;
2252  }
2253  if(id < rhs_.id)
2254  {
2255  return true;
2256  }
2257  else if(rhs_.id < id)
2258  {
2259  return false;
2260  }
2261  if(type < rhs_.type)
2262  {
2263  return true;
2264  }
2265  else if(rhs_.type < type)
2266  {
2267  return false;
2268  }
2269  if(proxyOptions < rhs_.proxyOptions)
2270  {
2271  return true;
2272  }
2273  else if(rhs_.proxyOptions < proxyOptions)
2274  {
2275  return false;
2276  }
2277  return false;
2278  }
2279 
2280  bool operator!=(const ObjectDescriptor& rhs_) const
2281  {
2282  return !operator==(rhs_);
2283  }
2284  bool operator<=(const ObjectDescriptor& rhs_) const
2285  {
2286  return operator<(rhs_) || operator==(rhs_);
2287  }
2288  bool operator>(const ObjectDescriptor& rhs_) const
2289  {
2290  return !operator<(rhs_) && !operator==(rhs_);
2291  }
2292  bool operator>=(const ObjectDescriptor& rhs_) const
2293  {
2294  return !operator<(rhs_);
2295  }
2296 };
2297 
2301 typedef ::std::vector<ObjectDescriptor> ObjectDescriptorSeq;
2302 
2307 struct AdapterDescriptor
2308 {
2312  ::std::string name;
2316  ::std::string description;
2320  ::std::string id;
2324  ::std::string replicaGroupId;
2330  ::std::string priority;
2334  bool registerProcess;
2341  bool serverLifetime;
2345  ::IceGrid::ObjectDescriptorSeq objects;
2349  ::IceGrid::ObjectDescriptorSeq allocatables;
2350 
2351  bool operator==(const AdapterDescriptor& rhs_) const
2352  {
2353  if(this == &rhs_)
2354  {
2355  return true;
2356  }
2357  if(name != rhs_.name)
2358  {
2359  return false;
2360  }
2361  if(description != rhs_.description)
2362  {
2363  return false;
2364  }
2365  if(id != rhs_.id)
2366  {
2367  return false;
2368  }
2369  if(replicaGroupId != rhs_.replicaGroupId)
2370  {
2371  return false;
2372  }
2373  if(priority != rhs_.priority)
2374  {
2375  return false;
2376  }
2377  if(registerProcess != rhs_.registerProcess)
2378  {
2379  return false;
2380  }
2381  if(serverLifetime != rhs_.serverLifetime)
2382  {
2383  return false;
2384  }
2385  if(objects != rhs_.objects)
2386  {
2387  return false;
2388  }
2389  if(allocatables != rhs_.allocatables)
2390  {
2391  return false;
2392  }
2393  return true;
2394  }
2395 
2396  bool operator<(const AdapterDescriptor& rhs_) const
2397  {
2398  if(this == &rhs_)
2399  {
2400  return false;
2401  }
2402  if(name < rhs_.name)
2403  {
2404  return true;
2405  }
2406  else if(rhs_.name < name)
2407  {
2408  return false;
2409  }
2410  if(description < rhs_.description)
2411  {
2412  return true;
2413  }
2414  else if(rhs_.description < description)
2415  {
2416  return false;
2417  }
2418  if(id < rhs_.id)
2419  {
2420  return true;
2421  }
2422  else if(rhs_.id < id)
2423  {
2424  return false;
2425  }
2426  if(replicaGroupId < rhs_.replicaGroupId)
2427  {
2428  return true;
2429  }
2430  else if(rhs_.replicaGroupId < replicaGroupId)
2431  {
2432  return false;
2433  }
2434  if(priority < rhs_.priority)
2435  {
2436  return true;
2437  }
2438  else if(rhs_.priority < priority)
2439  {
2440  return false;
2441  }
2442  if(registerProcess < rhs_.registerProcess)
2443  {
2444  return true;
2445  }
2446  else if(rhs_.registerProcess < registerProcess)
2447  {
2448  return false;
2449  }
2450  if(serverLifetime < rhs_.serverLifetime)
2451  {
2452  return true;
2453  }
2454  else if(rhs_.serverLifetime < serverLifetime)
2455  {
2456  return false;
2457  }
2458  if(objects < rhs_.objects)
2459  {
2460  return true;
2461  }
2462  else if(rhs_.objects < objects)
2463  {
2464  return false;
2465  }
2466  if(allocatables < rhs_.allocatables)
2467  {
2468  return true;
2469  }
2470  else if(rhs_.allocatables < allocatables)
2471  {
2472  return false;
2473  }
2474  return false;
2475  }
2476 
2477  bool operator!=(const AdapterDescriptor& rhs_) const
2478  {
2479  return !operator==(rhs_);
2480  }
2481  bool operator<=(const AdapterDescriptor& rhs_) const
2482  {
2483  return operator<(rhs_) || operator==(rhs_);
2484  }
2485  bool operator>(const AdapterDescriptor& rhs_) const
2486  {
2487  return !operator<(rhs_) && !operator==(rhs_);
2488  }
2489  bool operator>=(const AdapterDescriptor& rhs_) const
2490  {
2491  return !operator<(rhs_);
2492  }
2493 };
2494 
2498 typedef ::std::vector<AdapterDescriptor> AdapterDescriptorSeq;
2499 
2504 struct DbEnvDescriptor
2505 {
2509  ::std::string name;
2513  ::std::string description;
2520  ::std::string dbHome;
2524  ::IceGrid::PropertyDescriptorSeq properties;
2525 
2526  bool operator==(const DbEnvDescriptor& rhs_) const
2527  {
2528  if(this == &rhs_)
2529  {
2530  return true;
2531  }
2532  if(name != rhs_.name)
2533  {
2534  return false;
2535  }
2536  if(description != rhs_.description)
2537  {
2538  return false;
2539  }
2540  if(dbHome != rhs_.dbHome)
2541  {
2542  return false;
2543  }
2544  if(properties != rhs_.properties)
2545  {
2546  return false;
2547  }
2548  return true;
2549  }
2550 
2551  bool operator<(const DbEnvDescriptor& rhs_) const
2552  {
2553  if(this == &rhs_)
2554  {
2555  return false;
2556  }
2557  if(name < rhs_.name)
2558  {
2559  return true;
2560  }
2561  else if(rhs_.name < name)
2562  {
2563  return false;
2564  }
2565  if(description < rhs_.description)
2566  {
2567  return true;
2568  }
2569  else if(rhs_.description < description)
2570  {
2571  return false;
2572  }
2573  if(dbHome < rhs_.dbHome)
2574  {
2575  return true;
2576  }
2577  else if(rhs_.dbHome < dbHome)
2578  {
2579  return false;
2580  }
2581  if(properties < rhs_.properties)
2582  {
2583  return true;
2584  }
2585  else if(rhs_.properties < properties)
2586  {
2587  return false;
2588  }
2589  return false;
2590  }
2591 
2592  bool operator!=(const DbEnvDescriptor& rhs_) const
2593  {
2594  return !operator==(rhs_);
2595  }
2596  bool operator<=(const DbEnvDescriptor& rhs_) const
2597  {
2598  return operator<(rhs_) || operator==(rhs_);
2599  }
2600  bool operator>(const DbEnvDescriptor& rhs_) const
2601  {
2602  return !operator<(rhs_) && !operator==(rhs_);
2603  }
2604  bool operator>=(const DbEnvDescriptor& rhs_) const
2605  {
2606  return !operator<(rhs_);
2607  }
2608 };
2609 
2613 typedef ::std::vector<DbEnvDescriptor> DbEnvDescriptorSeq;
2614 
2620 struct DistributionDescriptor
2621 {
2625  ::std::string icepatch;
2629  ::Ice::StringSeq directories;
2630 
2631  bool operator==(const DistributionDescriptor& rhs_) const
2632  {
2633  if(this == &rhs_)
2634  {
2635  return true;
2636  }
2637  if(icepatch != rhs_.icepatch)
2638  {
2639  return false;
2640  }
2641  if(directories != rhs_.directories)
2642  {
2643  return false;
2644  }
2645  return true;
2646  }
2647 
2648  bool operator<(const DistributionDescriptor& rhs_) const
2649  {
2650  if(this == &rhs_)
2651  {
2652  return false;
2653  }
2654  if(icepatch < rhs_.icepatch)
2655  {
2656  return true;
2657  }
2658  else if(rhs_.icepatch < icepatch)
2659  {
2660  return false;
2661  }
2662  if(directories < rhs_.directories)
2663  {
2664  return true;
2665  }
2666  else if(rhs_.directories < directories)
2667  {
2668  return false;
2669  }
2670  return false;
2671  }
2672 
2673  bool operator!=(const DistributionDescriptor& rhs_) const
2674  {
2675  return !operator==(rhs_);
2676  }
2677  bool operator<=(const DistributionDescriptor& rhs_) const
2678  {
2679  return operator<(rhs_) || operator==(rhs_);
2680  }
2681  bool operator>(const DistributionDescriptor& rhs_) const
2682  {
2683  return !operator<(rhs_) && !operator==(rhs_);
2684  }
2685  bool operator>=(const DistributionDescriptor& rhs_) const
2686  {
2687  return !operator<(rhs_);
2688  }
2689 };
2690 
2694 typedef ::std::vector<ServerDescriptorPtr> ServerDescriptorSeq;
2695 
2699 typedef ::std::vector<ServiceDescriptorPtr> ServiceDescriptorSeq;
2700 
2705 struct ServerInstanceDescriptor
2706 {
2710  ::std::string _cpp_template;
2714  ::IceGrid::StringStringDict parameterValues;
2718  ::IceGrid::PropertySetDescriptor propertySet;
2723  ::IceGrid::PropertySetDescriptorDict servicePropertySets;
2724 
2725  bool operator==(const ServerInstanceDescriptor& rhs_) const
2726  {
2727  if(this == &rhs_)
2728  {
2729  return true;
2730  }
2731  if(_cpp_template != rhs_._cpp_template)
2732  {
2733  return false;
2734  }
2735  if(parameterValues != rhs_.parameterValues)
2736  {
2737  return false;
2738  }
2739  if(propertySet != rhs_.propertySet)
2740  {
2741  return false;
2742  }
2743  if(servicePropertySets != rhs_.servicePropertySets)
2744  {
2745  return false;
2746  }
2747  return true;
2748  }
2749 
2750  bool operator<(const ServerInstanceDescriptor& rhs_) const
2751  {
2752  if(this == &rhs_)
2753  {
2754  return false;
2755  }
2756  if(_cpp_template < rhs_._cpp_template)
2757  {
2758  return true;
2759  }
2760  else if(rhs_._cpp_template < _cpp_template)
2761  {
2762  return false;
2763  }
2764  if(parameterValues < rhs_.parameterValues)
2765  {
2766  return true;
2767  }
2768  else if(rhs_.parameterValues < parameterValues)
2769  {
2770  return false;
2771  }
2772  if(propertySet < rhs_.propertySet)
2773  {
2774  return true;
2775  }
2776  else if(rhs_.propertySet < propertySet)
2777  {
2778  return false;
2779  }
2780  if(servicePropertySets < rhs_.servicePropertySets)
2781  {
2782  return true;
2783  }
2784  else if(rhs_.servicePropertySets < servicePropertySets)
2785  {
2786  return false;
2787  }
2788  return false;
2789  }
2790 
2791  bool operator!=(const ServerInstanceDescriptor& rhs_) const
2792  {
2793  return !operator==(rhs_);
2794  }
2795  bool operator<=(const ServerInstanceDescriptor& rhs_) const
2796  {
2797  return operator<(rhs_) || operator==(rhs_);
2798  }
2799  bool operator>(const ServerInstanceDescriptor& rhs_) const
2800  {
2801  return !operator<(rhs_) && !operator==(rhs_);
2802  }
2803  bool operator>=(const ServerInstanceDescriptor& rhs_) const
2804  {
2805  return !operator<(rhs_);
2806  }
2807 };
2808 
2812 typedef ::std::vector<ServerInstanceDescriptor> ServerInstanceDescriptorSeq;
2813 
2818 struct TemplateDescriptor
2819 {
2823  ::IceGrid::CommunicatorDescriptorPtr descriptor;
2827  ::Ice::StringSeq parameters;
2831  ::IceGrid::StringStringDict parameterDefaults;
2832 };
2833 
2837 typedef ::std::map< ::std::string, TemplateDescriptor> TemplateDescriptorDict;
2838 
2843 struct ServiceInstanceDescriptor
2844 {
2848  ::std::string _cpp_template;
2852  ::IceGrid::StringStringDict parameterValues;
2857  ::IceGrid::ServiceDescriptorPtr descriptor;
2861  ::IceGrid::PropertySetDescriptor propertySet;
2862 };
2863 
2867 typedef ::std::vector<ServiceInstanceDescriptor> ServiceInstanceDescriptorSeq;
2868 
2873 struct NodeDescriptor
2874 {
2878  ::IceGrid::StringStringDict variables;
2882  ::IceGrid::ServerInstanceDescriptorSeq serverInstances;
2886  ::IceGrid::ServerDescriptorSeq servers;
2890  ::std::string loadFactor;
2894  ::std::string description;
2898  ::IceGrid::PropertySetDescriptorDict propertySets;
2899 };
2900 
2904 typedef ::std::map< ::std::string, NodeDescriptor> NodeDescriptorDict;
2905 
2910 struct ReplicaGroupDescriptor
2911 {
2915  ::std::string id;
2919  ::IceGrid::LoadBalancingPolicyPtr loadBalancing;
2923  ::std::string proxyOptions;
2927  ::IceGrid::ObjectDescriptorSeq objects;
2931  ::std::string description;
2935  ::std::string filter;
2936 };
2937 
2941 typedef ::std::vector<ReplicaGroupDescriptor> ReplicaGroupDescriptorSeq;
2942 
2947 struct ApplicationDescriptor
2948 {
2952  ::std::string name;
2956  ::IceGrid::StringStringDict variables;
2960  ::IceGrid::ReplicaGroupDescriptorSeq replicaGroups;
2964  ::IceGrid::TemplateDescriptorDict serverTemplates;
2968  ::IceGrid::TemplateDescriptorDict serviceTemplates;
2972  ::IceGrid::NodeDescriptorDict nodes;
2976  ::IceGrid::DistributionDescriptor distrib;
2980  ::std::string description;
2984  ::IceGrid::PropertySetDescriptorDict propertySets;
2985 };
2986 
2990 typedef ::std::vector<ApplicationDescriptor> ApplicationDescriptorSeq;
2991 
2997 struct NodeUpdateDescriptor
2998 {
3002  ::std::string name;
3007  ::IceGrid::BoxedStringPtr description;
3011  ::IceGrid::StringStringDict variables;
3015  ::Ice::StringSeq removeVariables;
3019  ::IceGrid::PropertySetDescriptorDict propertySets;
3023  ::Ice::StringSeq removePropertySets;
3027  ::IceGrid::ServerInstanceDescriptorSeq serverInstances;
3031  ::IceGrid::ServerDescriptorSeq servers;
3035  ::Ice::StringSeq removeServers;
3040  ::IceGrid::BoxedStringPtr loadFactor;
3041 };
3042 
3046 typedef ::std::vector<NodeUpdateDescriptor> NodeUpdateDescriptorSeq;
3047 
3053 struct ApplicationUpdateDescriptor
3054 {
3058  ::std::string name;
3063  ::IceGrid::BoxedStringPtr description;
3067  ::IceGrid::BoxedDistributionDescriptorPtr distrib;
3071  ::IceGrid::StringStringDict variables;
3075  ::Ice::StringSeq removeVariables;
3079  ::IceGrid::PropertySetDescriptorDict propertySets;
3083  ::Ice::StringSeq removePropertySets;
3087  ::IceGrid::ReplicaGroupDescriptorSeq replicaGroups;
3091  ::Ice::StringSeq removeReplicaGroups;
3095  ::IceGrid::TemplateDescriptorDict serverTemplates;
3099  ::Ice::StringSeq removeServerTemplates;
3103  ::IceGrid::TemplateDescriptorDict serviceTemplates;
3107  ::Ice::StringSeq removeServiceTemplates;
3111  ::IceGrid::NodeUpdateDescriptorSeq nodes;
3115  ::Ice::StringSeq removeNodes;
3116 };
3117 
3118 }
3119 
3120 namespace IceGrid
3121 {
3122 
3123 }
3124 
3125 namespace IceProxy
3126 {
3127 
3128 namespace IceGrid
3129 {
3130 
3131 class ICE_CLASS(ICEGRID_API) CommunicatorDescriptor : public virtual ::Ice::Proxy<CommunicatorDescriptor, ::IceProxy::Ice::Object>
3132 {
3133 public:
3134 
3139  ICE_MEMBER(ICEGRID_API) static const ::std::string& ice_staticId();
3140 
3141 protected:
3143 
3144  ICE_MEMBER(ICEGRID_API) virtual ::IceProxy::Ice::Object* _newInstance() const;
3146 };
3147 
3148 class ICE_CLASS(ICEGRID_API) ServerDescriptor : public virtual ::Ice::Proxy<ServerDescriptor, ::IceProxy::IceGrid::CommunicatorDescriptor>
3149 {
3150 public:
3151 
3156  ICE_MEMBER(ICEGRID_API) static const ::std::string& ice_staticId();
3157 
3158 protected:
3160 
3161  ICE_MEMBER(ICEGRID_API) virtual ::IceProxy::Ice::Object* _newInstance() const;
3163 };
3164 
3165 class ICE_CLASS(ICEGRID_API) ServiceDescriptor : public virtual ::Ice::Proxy<ServiceDescriptor, ::IceProxy::IceGrid::CommunicatorDescriptor>
3166 {
3167 public:
3168 
3173  ICE_MEMBER(ICEGRID_API) static const ::std::string& ice_staticId();
3174 
3175 protected:
3177 
3178  ICE_MEMBER(ICEGRID_API) virtual ::IceProxy::Ice::Object* _newInstance() const;
3180 };
3181 
3182 class ICE_CLASS(ICEGRID_API) IceBoxDescriptor : public virtual ::Ice::Proxy<IceBoxDescriptor, ::IceProxy::IceGrid::ServerDescriptor>
3183 {
3184 public:
3185 
3190  ICE_MEMBER(ICEGRID_API) static const ::std::string& ice_staticId();
3191 
3192 protected:
3194 
3195  ICE_MEMBER(ICEGRID_API) virtual ::IceProxy::Ice::Object* _newInstance() const;
3197 };
3198 
3199 class ICE_CLASS(ICEGRID_API) LoadBalancingPolicy : public virtual ::Ice::Proxy<LoadBalancingPolicy, ::IceProxy::Ice::Object>
3200 {
3201 public:
3202 
3207  ICE_MEMBER(ICEGRID_API) static const ::std::string& ice_staticId();
3208 
3209 protected:
3211 
3212  ICE_MEMBER(ICEGRID_API) virtual ::IceProxy::Ice::Object* _newInstance() const;
3214 };
3215 
3216 class ICE_CLASS(ICEGRID_API) RandomLoadBalancingPolicy : public virtual ::Ice::Proxy<RandomLoadBalancingPolicy, ::IceProxy::IceGrid::LoadBalancingPolicy>
3217 {
3218 public:
3219 
3224  ICE_MEMBER(ICEGRID_API) static const ::std::string& ice_staticId();
3225 
3226 protected:
3228 
3229  ICE_MEMBER(ICEGRID_API) virtual ::IceProxy::Ice::Object* _newInstance() const;
3231 };
3232 
3233 class ICE_CLASS(ICEGRID_API) OrderedLoadBalancingPolicy : public virtual ::Ice::Proxy<OrderedLoadBalancingPolicy, ::IceProxy::IceGrid::LoadBalancingPolicy>
3234 {
3235 public:
3236 
3241  ICE_MEMBER(ICEGRID_API) static const ::std::string& ice_staticId();
3242 
3243 protected:
3245 
3246  ICE_MEMBER(ICEGRID_API) virtual ::IceProxy::Ice::Object* _newInstance() const;
3248 };
3249 
3250 class ICE_CLASS(ICEGRID_API) RoundRobinLoadBalancingPolicy : public virtual ::Ice::Proxy<RoundRobinLoadBalancingPolicy, ::IceProxy::IceGrid::LoadBalancingPolicy>
3251 {
3252 public:
3253 
3258  ICE_MEMBER(ICEGRID_API) static const ::std::string& ice_staticId();
3259 
3260 protected:
3262 
3263  ICE_MEMBER(ICEGRID_API) virtual ::IceProxy::Ice::Object* _newInstance() const;
3265 };
3266 
3267 class ICE_CLASS(ICEGRID_API) AdaptiveLoadBalancingPolicy : public virtual ::Ice::Proxy<AdaptiveLoadBalancingPolicy, ::IceProxy::IceGrid::LoadBalancingPolicy>
3268 {
3269 public:
3270 
3275  ICE_MEMBER(ICEGRID_API) static const ::std::string& ice_staticId();
3276 
3277 protected:
3279 
3280  ICE_MEMBER(ICEGRID_API) virtual ::IceProxy::Ice::Object* _newInstance() const;
3282 };
3283 
3284 class ICE_CLASS(ICEGRID_API) BoxedString : public virtual ::Ice::Proxy<BoxedString, ::IceProxy::Ice::Object>
3285 {
3286 public:
3287 
3292  ICE_MEMBER(ICEGRID_API) static const ::std::string& ice_staticId();
3293 
3294 protected:
3296 
3297  ICE_MEMBER(ICEGRID_API) virtual ::IceProxy::Ice::Object* _newInstance() const;
3299 };
3300 
3301 class ICE_CLASS(ICEGRID_API) BoxedDistributionDescriptor : public virtual ::Ice::Proxy<BoxedDistributionDescriptor, ::IceProxy::Ice::Object>
3302 {
3303 public:
3304 
3309  ICE_MEMBER(ICEGRID_API) static const ::std::string& ice_staticId();
3310 
3311 protected:
3313 
3314  ICE_MEMBER(ICEGRID_API) virtual ::IceProxy::Ice::Object* _newInstance() const;
3316 };
3317 
3318 }
3319 
3320 }
3321 
3322 namespace IceGrid
3323 {
3324 
3329 class ICEGRID_API CommunicatorDescriptor : public virtual ::Ice::Object
3330 {
3331 public:
3332 
3333  typedef CommunicatorDescriptorPrx ProxyType;
3334  typedef CommunicatorDescriptorPtr PointerType;
3335 
3336  virtual ~CommunicatorDescriptor();
3337 
3338  CommunicatorDescriptor()
3339  {
3340  }
3341 
3350  CommunicatorDescriptor(const ::IceGrid::AdapterDescriptorSeq& adapters, const ::IceGrid::PropertySetDescriptor& propertySet, const ::IceGrid::DbEnvDescriptorSeq& dbEnvs, const ::Ice::StringSeq& logs, const ::std::string& description) :
3351  adapters(adapters),
3352  propertySet(propertySet),
3353  dbEnvs(dbEnvs),
3354  logs(logs),
3355  description(description)
3356  {
3357  }
3358 
3359 #ifdef ICE_CPP11_COMPILER
3360  CommunicatorDescriptor(const CommunicatorDescriptor&) = default;
3361  CommunicatorDescriptor& operator=(const CommunicatorDescriptor&) = default;
3362 #endif
3363 
3368  virtual ::Ice::ObjectPtr ice_clone() const;
3369 
3376  virtual bool ice_isA(const ::std::string& id, const ::Ice::Current& current = ::Ice::emptyCurrent) const;
3377 
3383  virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& current = ::Ice::emptyCurrent) const;
3384 
3390  virtual const ::std::string& ice_id(const ::Ice::Current& current = ::Ice::emptyCurrent) const;
3391 
3396  static const ::std::string& ice_staticId();
3397 
3402  static ::Ice::ValueFactoryPtr ice_factory();
3403 
3404 protected:
3405 
3407  virtual void _iceWriteImpl(::Ice::OutputStream*) const;
3408  virtual void _iceReadImpl(::Ice::InputStream*);
3410 
3411 public:
3412 
3416  ::IceGrid::AdapterDescriptorSeq adapters;
3420  ::IceGrid::PropertySetDescriptor propertySet;
3424  ::IceGrid::DbEnvDescriptorSeq dbEnvs;
3428  ::Ice::StringSeq logs;
3432  ::std::string description;
3433 };
3435 static ::Ice::ValueFactoryPtr _iceS_CommunicatorDescriptor_init = ::IceGrid::CommunicatorDescriptor::ice_factory();
3437 
3439 inline bool operator==(const CommunicatorDescriptor& lhs, const CommunicatorDescriptor& rhs)
3440 {
3441  return static_cast<const ::Ice::Object&>(lhs) == static_cast<const ::Ice::Object&>(rhs);
3442 }
3443 
3444 inline bool operator<(const CommunicatorDescriptor& lhs, const CommunicatorDescriptor& rhs)
3445 {
3446  return static_cast<const ::Ice::Object&>(lhs) < static_cast<const ::Ice::Object&>(rhs);
3447 }
3449 
3454 class ICEGRID_API ServerDescriptor : public CommunicatorDescriptor
3455 {
3456 public:
3457 
3458  typedef ServerDescriptorPrx ProxyType;
3459  typedef ServerDescriptorPtr PointerType;
3460 
3461  virtual ~ServerDescriptor();
3462 
3463  ServerDescriptor()
3464  {
3465  }
3466 
3488  ServerDescriptor(const ::IceGrid::AdapterDescriptorSeq& adapters, const ::IceGrid::PropertySetDescriptor& propertySet, const ::IceGrid::DbEnvDescriptorSeq& dbEnvs, const ::Ice::StringSeq& logs, const ::std::string& description, const ::std::string& id, const ::std::string& exe, const ::std::string& iceVersion, const ::std::string& pwd, const ::Ice::StringSeq& options, const ::Ice::StringSeq& envs, const ::std::string& activation, const ::std::string& activationTimeout, const ::std::string& deactivationTimeout, bool applicationDistrib, const ::IceGrid::DistributionDescriptor& distrib, bool allocatable, const ::std::string& user) :
3489  ::IceGrid::CommunicatorDescriptor(adapters, propertySet, dbEnvs, logs, description),
3490  id(id),
3491  exe(exe),
3492  iceVersion(iceVersion),
3493  pwd(pwd),
3494  options(options),
3495  envs(envs),
3496  activation(activation),
3497  activationTimeout(activationTimeout),
3498  deactivationTimeout(deactivationTimeout),
3499  applicationDistrib(applicationDistrib),
3500  distrib(distrib),
3501  allocatable(allocatable),
3502  user(user)
3503  {
3504  }
3505 
3506 #ifdef ICE_CPP11_COMPILER
3507  ServerDescriptor(const ServerDescriptor&) = default;
3508  ServerDescriptor& operator=(const ServerDescriptor&) = default;
3509 #endif
3510 
3515  virtual ::Ice::ObjectPtr ice_clone() const;
3516 
3523  virtual bool ice_isA(const ::std::string& id, const ::Ice::Current& current = ::Ice::emptyCurrent) const;
3524 
3530  virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& current = ::Ice::emptyCurrent) const;
3531 
3537  virtual const ::std::string& ice_id(const ::Ice::Current& current = ::Ice::emptyCurrent) const;
3538 
3543  static const ::std::string& ice_staticId();
3544 
3549  static ::Ice::ValueFactoryPtr ice_factory();
3550 
3551 protected:
3552 
3554  virtual void _iceWriteImpl(::Ice::OutputStream*) const;
3555  virtual void _iceReadImpl(::Ice::InputStream*);
3557 
3558 public:
3559 
3563  ::std::string id;
3567  ::std::string exe;
3575  ::std::string iceVersion;
3579  ::std::string pwd;
3583  ::Ice::StringSeq options;
3587  ::Ice::StringSeq envs;
3592  ::std::string activation;
3597  ::std::string activationTimeout;
3602  ::std::string deactivationTimeout;
3607  bool applicationDistrib;
3611  ::IceGrid::DistributionDescriptor distrib;
3615  bool allocatable;
3619  ::std::string user;
3620 };
3622 static ::Ice::ValueFactoryPtr _iceS_ServerDescriptor_init = ::IceGrid::ServerDescriptor::ice_factory();
3624 
3626 inline bool operator==(const ServerDescriptor& lhs, const ServerDescriptor& rhs)
3627 {
3628  return static_cast<const ::Ice::Object&>(lhs) == static_cast<const ::Ice::Object&>(rhs);
3629 }
3630 
3631 inline bool operator<(const ServerDescriptor& lhs, const ServerDescriptor& rhs)
3632 {
3633  return static_cast<const ::Ice::Object&>(lhs) < static_cast<const ::Ice::Object&>(rhs);
3634 }
3636 
3641 class ICEGRID_API ServiceDescriptor : public CommunicatorDescriptor
3642 {
3643 public:
3644 
3645  typedef ServiceDescriptorPrx ProxyType;
3646  typedef ServiceDescriptorPtr PointerType;
3647 
3648  virtual ~ServiceDescriptor();
3649 
3650  ServiceDescriptor()
3651  {
3652  }
3653 
3664  ServiceDescriptor(const ::IceGrid::AdapterDescriptorSeq& adapters, const ::IceGrid::PropertySetDescriptor& propertySet, const ::IceGrid::DbEnvDescriptorSeq& dbEnvs, const ::Ice::StringSeq& logs, const ::std::string& description, const ::std::string& name, const ::std::string& entry) :
3665  ::IceGrid::CommunicatorDescriptor(adapters, propertySet, dbEnvs, logs, description),
3666  name(name),
3667  entry(entry)
3668  {
3669  }
3670 
3671 #ifdef ICE_CPP11_COMPILER
3672  ServiceDescriptor(const ServiceDescriptor&) = default;
3673  ServiceDescriptor& operator=(const ServiceDescriptor&) = default;
3674 #endif
3675 
3680  virtual ::Ice::ObjectPtr ice_clone() const;
3681 
3688  virtual bool ice_isA(const ::std::string& id, const ::Ice::Current& current = ::Ice::emptyCurrent) const;
3689 
3695  virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& current = ::Ice::emptyCurrent) const;
3696 
3702  virtual const ::std::string& ice_id(const ::Ice::Current& current = ::Ice::emptyCurrent) const;
3703 
3708  static const ::std::string& ice_staticId();
3709 
3714  static ::Ice::ValueFactoryPtr ice_factory();
3715 
3716 protected:
3717 
3719  virtual void _iceWriteImpl(::Ice::OutputStream*) const;
3720  virtual void _iceReadImpl(::Ice::InputStream*);
3722 
3723 public:
3724 
3728  ::std::string name;
3732  ::std::string entry;
3733 };
3735 static ::Ice::ValueFactoryPtr _iceS_ServiceDescriptor_init = ::IceGrid::ServiceDescriptor::ice_factory();
3737 
3739 inline bool operator==(const ServiceDescriptor& lhs, const ServiceDescriptor& rhs)
3740 {
3741  return static_cast<const ::Ice::Object&>(lhs) == static_cast<const ::Ice::Object&>(rhs);
3742 }
3743 
3744 inline bool operator<(const ServiceDescriptor& lhs, const ServiceDescriptor& rhs)
3745 {
3746  return static_cast<const ::Ice::Object&>(lhs) < static_cast<const ::Ice::Object&>(rhs);
3747 }
3749 
3754 class ICEGRID_API IceBoxDescriptor : public ServerDescriptor, public ::IceInternal::GCObject
3755 {
3756 public:
3757 
3758  typedef IceBoxDescriptorPrx ProxyType;
3759  typedef IceBoxDescriptorPtr PointerType;
3760 
3761  virtual ~IceBoxDescriptor();
3762 
3763  IceBoxDescriptor()
3764  {
3765  }
3766 
3789  IceBoxDescriptor(const ::IceGrid::AdapterDescriptorSeq& adapters, const ::IceGrid::PropertySetDescriptor& propertySet, const ::IceGrid::DbEnvDescriptorSeq& dbEnvs, const ::Ice::StringSeq& logs, const ::std::string& description, const ::std::string& id, const ::std::string& exe, const ::std::string& iceVersion, const ::std::string& pwd, const ::Ice::StringSeq& options, const ::Ice::StringSeq& envs, const ::std::string& activation, const ::std::string& activationTimeout, const ::std::string& deactivationTimeout, bool applicationDistrib, const ::IceGrid::DistributionDescriptor& distrib, bool allocatable, const ::std::string& user, const ::IceGrid::ServiceInstanceDescriptorSeq& services) :
3790  ::IceGrid::ServerDescriptor(adapters, propertySet, dbEnvs, logs, description, id, exe, iceVersion, pwd, options, envs, activation, activationTimeout, deactivationTimeout, applicationDistrib, distrib, allocatable, user),
3791  services(services)
3792  {
3793  }
3794 
3795 #ifdef ICE_CPP11_COMPILER
3796  IceBoxDescriptor(const IceBoxDescriptor&) = default;
3797  IceBoxDescriptor& operator=(const IceBoxDescriptor&) = default;
3798 #endif
3799 
3804  virtual ::Ice::ObjectPtr ice_clone() const;
3805 
3812  virtual bool ice_isA(const ::std::string& id, const ::Ice::Current& current = ::Ice::emptyCurrent) const;
3813 
3819  virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& current = ::Ice::emptyCurrent) const;
3820 
3826  virtual const ::std::string& ice_id(const ::Ice::Current& current = ::Ice::emptyCurrent) const;
3827 
3832  static const ::std::string& ice_staticId();
3834  virtual void _iceGcVisitMembers(::IceInternal::GCVisitor&);
3836 
3841  static ::Ice::ValueFactoryPtr ice_factory();
3842 
3843 protected:
3844 
3846  virtual void _iceWriteImpl(::Ice::OutputStream*) const;
3847  virtual void _iceReadImpl(::Ice::InputStream*);
3849 
3850 public:
3851 
3855  ::IceGrid::ServiceInstanceDescriptorSeq services;
3856 };
3858 static ::Ice::ValueFactoryPtr _iceS_IceBoxDescriptor_init = ::IceGrid::IceBoxDescriptor::ice_factory();
3860 
3862 inline bool operator==(const IceBoxDescriptor& lhs, const IceBoxDescriptor& rhs)
3863 {
3864  return static_cast<const ::Ice::Object&>(lhs) == static_cast<const ::Ice::Object&>(rhs);
3865 }
3866 
3867 inline bool operator<(const IceBoxDescriptor& lhs, const IceBoxDescriptor& rhs)
3868 {
3869  return static_cast<const ::Ice::Object&>(lhs) < static_cast<const ::Ice::Object&>(rhs);
3870 }
3872 
3877 class ICEGRID_API LoadBalancingPolicy : public virtual ::Ice::Object
3878 {
3879 public:
3880 
3881  typedef LoadBalancingPolicyPrx ProxyType;
3882  typedef LoadBalancingPolicyPtr PointerType;
3883 
3884  virtual ~LoadBalancingPolicy();
3885 
3886  LoadBalancingPolicy()
3887  {
3888  }
3889 
3894  explicit LoadBalancingPolicy(const ::std::string& nReplicas) :
3895  nReplicas(nReplicas)
3896  {
3897  }
3898 
3899 #ifdef ICE_CPP11_COMPILER
3900  LoadBalancingPolicy(const LoadBalancingPolicy&) = default;
3901  LoadBalancingPolicy& operator=(const LoadBalancingPolicy&) = default;
3902 #endif
3903 
3908  virtual ::Ice::ObjectPtr ice_clone() const;
3909 
3916  virtual bool ice_isA(const ::std::string& id, const ::Ice::Current& current = ::Ice::emptyCurrent) const;
3917 
3923  virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& current = ::Ice::emptyCurrent) const;
3924 
3930  virtual const ::std::string& ice_id(const ::Ice::Current& current = ::Ice::emptyCurrent) const;
3931 
3936  static const ::std::string& ice_staticId();
3937 
3942  static ::Ice::ValueFactoryPtr ice_factory();
3943 
3944 protected:
3945 
3947  virtual void _iceWriteImpl(::Ice::OutputStream*) const;
3948  virtual void _iceReadImpl(::Ice::InputStream*);
3950 
3951 public:
3952 
3957  ::std::string nReplicas;
3958 };
3960 static ::Ice::ValueFactoryPtr _iceS_LoadBalancingPolicy_init = ::IceGrid::LoadBalancingPolicy::ice_factory();
3962 
3964 inline bool operator==(const LoadBalancingPolicy& lhs, const LoadBalancingPolicy& rhs)
3965 {
3966  return static_cast<const ::Ice::Object&>(lhs) == static_cast<const ::Ice::Object&>(rhs);
3967 }
3968 
3969 inline bool operator<(const LoadBalancingPolicy& lhs, const LoadBalancingPolicy& rhs)
3970 {
3971  return static_cast<const ::Ice::Object&>(lhs) < static_cast<const ::Ice::Object&>(rhs);
3972 }
3974 
3979 class ICEGRID_API RandomLoadBalancingPolicy : public LoadBalancingPolicy
3980 {
3981 public:
3982 
3983  typedef RandomLoadBalancingPolicyPrx ProxyType;
3984  typedef RandomLoadBalancingPolicyPtr PointerType;
3985 
3986  virtual ~RandomLoadBalancingPolicy();
3987 
3988  RandomLoadBalancingPolicy()
3989  {
3990  }
3991 
3996  explicit RandomLoadBalancingPolicy(const ::std::string& nReplicas) :
3997  ::IceGrid::LoadBalancingPolicy(nReplicas)
3998  {
3999  }
4000 
4001 #ifdef ICE_CPP11_COMPILER
4002  RandomLoadBalancingPolicy(const RandomLoadBalancingPolicy&) = default;
4003  RandomLoadBalancingPolicy& operator=(const RandomLoadBalancingPolicy&) = default;
4004 #endif
4005 
4010  virtual ::Ice::ObjectPtr ice_clone() const;
4011 
4018  virtual bool ice_isA(const ::std::string& id, const ::Ice::Current& current = ::Ice::emptyCurrent) const;
4019 
4025  virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& current = ::Ice::emptyCurrent) const;
4026 
4032  virtual const ::std::string& ice_id(const ::Ice::Current& current = ::Ice::emptyCurrent) const;
4033 
4038  static const ::std::string& ice_staticId();
4039 
4044  static ::Ice::ValueFactoryPtr ice_factory();
4045 
4046 protected:
4047 
4049  virtual void _iceWriteImpl(::Ice::OutputStream*) const;
4050  virtual void _iceReadImpl(::Ice::InputStream*);
4052 };
4054 static ::Ice::ValueFactoryPtr _iceS_RandomLoadBalancingPolicy_init = ::IceGrid::RandomLoadBalancingPolicy::ice_factory();
4056 
4058 inline bool operator==(const RandomLoadBalancingPolicy& lhs, const RandomLoadBalancingPolicy& rhs)
4059 {
4060  return static_cast<const ::Ice::Object&>(lhs) == static_cast<const ::Ice::Object&>(rhs);
4061 }
4062 
4063 inline bool operator<(const RandomLoadBalancingPolicy& lhs, const RandomLoadBalancingPolicy& rhs)
4064 {
4065  return static_cast<const ::Ice::Object&>(lhs) < static_cast<const ::Ice::Object&>(rhs);
4066 }
4068 
4073 class ICEGRID_API OrderedLoadBalancingPolicy : public LoadBalancingPolicy
4074 {
4075 public:
4076 
4077  typedef OrderedLoadBalancingPolicyPrx ProxyType;
4078  typedef OrderedLoadBalancingPolicyPtr PointerType;
4079 
4080  virtual ~OrderedLoadBalancingPolicy();
4081 
4082  OrderedLoadBalancingPolicy()
4083  {
4084  }
4085 
4090  explicit OrderedLoadBalancingPolicy(const ::std::string& nReplicas) :
4091  ::IceGrid::LoadBalancingPolicy(nReplicas)
4092  {
4093  }
4094 
4095 #ifdef ICE_CPP11_COMPILER
4096  OrderedLoadBalancingPolicy(const OrderedLoadBalancingPolicy&) = default;
4097  OrderedLoadBalancingPolicy& operator=(const OrderedLoadBalancingPolicy&) = default;
4098 #endif
4099 
4104  virtual ::Ice::ObjectPtr ice_clone() const;
4105 
4112  virtual bool ice_isA(const ::std::string& id, const ::Ice::Current& current = ::Ice::emptyCurrent) const;
4113 
4119  virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& current = ::Ice::emptyCurrent) const;
4120 
4126  virtual const ::std::string& ice_id(const ::Ice::Current& current = ::Ice::emptyCurrent) const;
4127 
4132  static const ::std::string& ice_staticId();
4133 
4138  static ::Ice::ValueFactoryPtr ice_factory();
4139 
4140 protected:
4141 
4143  virtual void _iceWriteImpl(::Ice::OutputStream*) const;
4144  virtual void _iceReadImpl(::Ice::InputStream*);
4146 };
4148 static ::Ice::ValueFactoryPtr _iceS_OrderedLoadBalancingPolicy_init = ::IceGrid::OrderedLoadBalancingPolicy::ice_factory();
4150 
4152 inline bool operator==(const OrderedLoadBalancingPolicy& lhs, const OrderedLoadBalancingPolicy& rhs)
4153 {
4154  return static_cast<const ::Ice::Object&>(lhs) == static_cast<const ::Ice::Object&>(rhs);
4155 }
4156 
4157 inline bool operator<(const OrderedLoadBalancingPolicy& lhs, const OrderedLoadBalancingPolicy& rhs)
4158 {
4159  return static_cast<const ::Ice::Object&>(lhs) < static_cast<const ::Ice::Object&>(rhs);
4160 }
4162 
4167 class ICEGRID_API RoundRobinLoadBalancingPolicy : public LoadBalancingPolicy
4168 {
4169 public:
4170 
4171  typedef RoundRobinLoadBalancingPolicyPrx ProxyType;
4172  typedef RoundRobinLoadBalancingPolicyPtr PointerType;
4173 
4174  virtual ~RoundRobinLoadBalancingPolicy();
4175 
4176  RoundRobinLoadBalancingPolicy()
4177  {
4178  }
4179 
4184  explicit RoundRobinLoadBalancingPolicy(const ::std::string& nReplicas) :
4185  ::IceGrid::LoadBalancingPolicy(nReplicas)
4186  {
4187  }
4188 
4189 #ifdef ICE_CPP11_COMPILER
4190  RoundRobinLoadBalancingPolicy(const RoundRobinLoadBalancingPolicy&) = default;
4191  RoundRobinLoadBalancingPolicy& operator=(const RoundRobinLoadBalancingPolicy&) = default;
4192 #endif
4193 
4198  virtual ::Ice::ObjectPtr ice_clone() const;
4199 
4206  virtual bool ice_isA(const ::std::string& id, const ::Ice::Current& current = ::Ice::emptyCurrent) const;
4207 
4213  virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& current = ::Ice::emptyCurrent) const;
4214 
4220  virtual const ::std::string& ice_id(const ::Ice::Current& current = ::Ice::emptyCurrent) const;
4221 
4226  static const ::std::string& ice_staticId();
4227 
4232  static ::Ice::ValueFactoryPtr ice_factory();
4233 
4234 protected:
4235 
4237  virtual void _iceWriteImpl(::Ice::OutputStream*) const;
4238  virtual void _iceReadImpl(::Ice::InputStream*);
4240 };
4242 static ::Ice::ValueFactoryPtr _iceS_RoundRobinLoadBalancingPolicy_init = ::IceGrid::RoundRobinLoadBalancingPolicy::ice_factory();
4244 
4246 inline bool operator==(const RoundRobinLoadBalancingPolicy& lhs, const RoundRobinLoadBalancingPolicy& rhs)
4247 {
4248  return static_cast<const ::Ice::Object&>(lhs) == static_cast<const ::Ice::Object&>(rhs);
4249 }
4250 
4251 inline bool operator<(const RoundRobinLoadBalancingPolicy& lhs, const RoundRobinLoadBalancingPolicy& rhs)
4252 {
4253  return static_cast<const ::Ice::Object&>(lhs) < static_cast<const ::Ice::Object&>(rhs);
4254 }
4256 
4261 class ICEGRID_API AdaptiveLoadBalancingPolicy : public LoadBalancingPolicy
4262 {
4263 public:
4264 
4265  typedef AdaptiveLoadBalancingPolicyPrx ProxyType;
4266  typedef AdaptiveLoadBalancingPolicyPtr PointerType;
4267 
4268  virtual ~AdaptiveLoadBalancingPolicy();
4269 
4270  AdaptiveLoadBalancingPolicy()
4271  {
4272  }
4273 
4279  AdaptiveLoadBalancingPolicy(const ::std::string& nReplicas, const ::std::string& loadSample) :
4280  ::IceGrid::LoadBalancingPolicy(nReplicas),
4281  loadSample(loadSample)
4282  {
4283  }
4284 
4285 #ifdef ICE_CPP11_COMPILER
4286  AdaptiveLoadBalancingPolicy(const AdaptiveLoadBalancingPolicy&) = default;
4287  AdaptiveLoadBalancingPolicy& operator=(const AdaptiveLoadBalancingPolicy&) = default;
4288 #endif
4289 
4294  virtual ::Ice::ObjectPtr ice_clone() const;
4295 
4302  virtual bool ice_isA(const ::std::string& id, const ::Ice::Current& current = ::Ice::emptyCurrent) const;
4303 
4309  virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& current = ::Ice::emptyCurrent) const;
4310 
4316  virtual const ::std::string& ice_id(const ::Ice::Current& current = ::Ice::emptyCurrent) const;
4317 
4322  static const ::std::string& ice_staticId();
4323 
4328  static ::Ice::ValueFactoryPtr ice_factory();
4329 
4330 protected:
4331 
4333  virtual void _iceWriteImpl(::Ice::OutputStream*) const;
4334  virtual void _iceReadImpl(::Ice::InputStream*);
4336 
4337 public:
4338 
4345  ::std::string loadSample;
4346 };
4348 static ::Ice::ValueFactoryPtr _iceS_AdaptiveLoadBalancingPolicy_init = ::IceGrid::AdaptiveLoadBalancingPolicy::ice_factory();
4350 
4352 inline bool operator==(const AdaptiveLoadBalancingPolicy& lhs, const AdaptiveLoadBalancingPolicy& rhs)
4353 {
4354  return static_cast<const ::Ice::Object&>(lhs) == static_cast<const ::Ice::Object&>(rhs);
4355 }
4356 
4357 inline bool operator<(const AdaptiveLoadBalancingPolicy& lhs, const AdaptiveLoadBalancingPolicy& rhs)
4358 {
4359  return static_cast<const ::Ice::Object&>(lhs) < static_cast<const ::Ice::Object&>(rhs);
4360 }
4362 
4367 class ICEGRID_API BoxedString : public virtual ::Ice::Object
4368 {
4369 public:
4370 
4371  typedef BoxedStringPrx ProxyType;
4372  typedef BoxedStringPtr PointerType;
4373 
4374  virtual ~BoxedString();
4375 
4376  BoxedString()
4377  {
4378  }
4379 
4384  explicit BoxedString(const ::std::string& value) :
4385  value(value)
4386  {
4387  }
4388 
4389 #ifdef ICE_CPP11_COMPILER
4390  BoxedString(const BoxedString&) = default;
4391  BoxedString& operator=(const BoxedString&) = default;
4392 #endif
4393 
4398  virtual ::Ice::ObjectPtr ice_clone() const;
4399 
4406  virtual bool ice_isA(const ::std::string& id, const ::Ice::Current& current = ::Ice::emptyCurrent) const;
4407 
4413  virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& current = ::Ice::emptyCurrent) const;
4414 
4420  virtual const ::std::string& ice_id(const ::Ice::Current& current = ::Ice::emptyCurrent) const;
4421 
4426  static const ::std::string& ice_staticId();
4427 
4432  static ::Ice::ValueFactoryPtr ice_factory();
4433 
4434 protected:
4435 
4437  virtual void _iceWriteImpl(::Ice::OutputStream*) const;
4438  virtual void _iceReadImpl(::Ice::InputStream*);
4440 
4441 public:
4442 
4446  ::std::string value;
4447 };
4449 static ::Ice::ValueFactoryPtr _iceS_BoxedString_init = ::IceGrid::BoxedString::ice_factory();
4451 
4453 inline bool operator==(const BoxedString& lhs, const BoxedString& rhs)
4454 {
4455  return static_cast<const ::Ice::Object&>(lhs) == static_cast<const ::Ice::Object&>(rhs);
4456 }
4457 
4458 inline bool operator<(const BoxedString& lhs, const BoxedString& rhs)
4459 {
4460  return static_cast<const ::Ice::Object&>(lhs) < static_cast<const ::Ice::Object&>(rhs);
4461 }
4463 
4468 class ICEGRID_API BoxedDistributionDescriptor : public virtual ::Ice::Object
4469 {
4470 public:
4471 
4472  typedef BoxedDistributionDescriptorPrx ProxyType;
4473  typedef BoxedDistributionDescriptorPtr PointerType;
4474 
4475  virtual ~BoxedDistributionDescriptor();
4476 
4477  BoxedDistributionDescriptor()
4478  {
4479  }
4480 
4485  explicit BoxedDistributionDescriptor(const ::IceGrid::DistributionDescriptor& value) :
4486  value(value)
4487  {
4488  }
4489 
4490 #ifdef ICE_CPP11_COMPILER
4491  BoxedDistributionDescriptor(const BoxedDistributionDescriptor&) = default;
4492  BoxedDistributionDescriptor& operator=(const BoxedDistributionDescriptor&) = default;
4493 #endif
4494 
4499  virtual ::Ice::ObjectPtr ice_clone() const;
4500 
4507  virtual bool ice_isA(const ::std::string& id, const ::Ice::Current& current = ::Ice::emptyCurrent) const;
4508 
4514  virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& current = ::Ice::emptyCurrent) const;
4515 
4521  virtual const ::std::string& ice_id(const ::Ice::Current& current = ::Ice::emptyCurrent) const;
4522 
4527  static const ::std::string& ice_staticId();
4528 
4533  static ::Ice::ValueFactoryPtr ice_factory();
4534 
4535 protected:
4536 
4538  virtual void _iceWriteImpl(::Ice::OutputStream*) const;
4539  virtual void _iceReadImpl(::Ice::InputStream*);
4541 
4542 public:
4543 
4547  ::IceGrid::DistributionDescriptor value;
4548 };
4550 static ::Ice::ValueFactoryPtr _iceS_BoxedDistributionDescriptor_init = ::IceGrid::BoxedDistributionDescriptor::ice_factory();
4552 
4554 inline bool operator==(const BoxedDistributionDescriptor& lhs, const BoxedDistributionDescriptor& rhs)
4555 {
4556  return static_cast<const ::Ice::Object&>(lhs) == static_cast<const ::Ice::Object&>(rhs);
4557 }
4558 
4559 inline bool operator<(const BoxedDistributionDescriptor& lhs, const BoxedDistributionDescriptor& rhs)
4560 {
4561  return static_cast<const ::Ice::Object&>(lhs) < static_cast<const ::Ice::Object&>(rhs);
4562 }
4564 
4565 }
4566 
4568 namespace Ice
4569 {
4570 
4571 template<>
4572 struct StreamableTraits< ::IceGrid::PropertyDescriptor>
4573 {
4574  static const StreamHelperCategory helper = StreamHelperCategoryStruct;
4575  static const int minWireSize = 2;
4576  static const bool fixedLength = false;
4577 };
4578 
4579 template<typename S>
4580 struct StreamWriter< ::IceGrid::PropertyDescriptor, S>
4581 {
4582  static void write(S* ostr, const ::IceGrid::PropertyDescriptor& v)
4583  {
4584  ostr->write(v.name);
4585  ostr->write(v.value);
4586  }
4587 };
4588 
4589 template<typename S>
4590 struct StreamReader< ::IceGrid::PropertyDescriptor, S>
4591 {
4592  static void read(S* istr, ::IceGrid::PropertyDescriptor& v)
4593  {
4594  istr->read(v.name);
4595  istr->read(v.value);
4596  }
4597 };
4598 
4599 template<>
4600 struct StreamableTraits< ::IceGrid::PropertySetDescriptor>
4601 {
4602  static const StreamHelperCategory helper = StreamHelperCategoryStruct;
4603  static const int minWireSize = 2;
4604  static const bool fixedLength = false;
4605 };
4606 
4607 template<typename S>
4608 struct StreamWriter< ::IceGrid::PropertySetDescriptor, S>
4609 {
4610  static void write(S* ostr, const ::IceGrid::PropertySetDescriptor& v)
4611  {
4612  ostr->write(v.references);
4613  ostr->write(v.properties);
4614  }
4615 };
4616 
4617 template<typename S>
4618 struct StreamReader< ::IceGrid::PropertySetDescriptor, S>
4619 {
4620  static void read(S* istr, ::IceGrid::PropertySetDescriptor& v)
4621  {
4622  istr->read(v.references);
4623  istr->read(v.properties);
4624  }
4625 };
4626 
4627 template<>
4628 struct StreamableTraits< ::IceGrid::ObjectDescriptor>
4629 {
4630  static const StreamHelperCategory helper = StreamHelperCategoryStruct;
4631  static const int minWireSize = 4;
4632  static const bool fixedLength = false;
4633 };
4634 
4635 template<typename S>
4636 struct StreamWriter< ::IceGrid::ObjectDescriptor, S>
4637 {
4638  static void write(S* ostr, const ::IceGrid::ObjectDescriptor& v)
4639  {
4640  ostr->write(v.id);
4641  ostr->write(v.type);
4642  ostr->write(v.proxyOptions);
4643  }
4644 };
4645 
4646 template<typename S>
4647 struct StreamReader< ::IceGrid::ObjectDescriptor, S>
4648 {
4649  static void read(S* istr, ::IceGrid::ObjectDescriptor& v)
4650  {
4651  istr->read(v.id);
4652  istr->read(v.type);
4653  istr->read(v.proxyOptions);
4654  }
4655 };
4656 
4657 template<>
4658 struct StreamableTraits< ::IceGrid::AdapterDescriptor>
4659 {
4660  static const StreamHelperCategory helper = StreamHelperCategoryStruct;
4661  static const int minWireSize = 9;
4662  static const bool fixedLength = false;
4663 };
4664 
4665 template<typename S>
4666 struct StreamWriter< ::IceGrid::AdapterDescriptor, S>
4667 {
4668  static void write(S* ostr, const ::IceGrid::AdapterDescriptor& v)
4669  {
4670  ostr->write(v.name);
4671  ostr->write(v.description);
4672  ostr->write(v.id);
4673  ostr->write(v.replicaGroupId);
4674  ostr->write(v.priority);
4675  ostr->write(v.registerProcess);
4676  ostr->write(v.serverLifetime);
4677  ostr->write(v.objects);
4678  ostr->write(v.allocatables);
4679  }
4680 };
4681 
4682 template<typename S>
4683 struct StreamReader< ::IceGrid::AdapterDescriptor, S>
4684 {
4685  static void read(S* istr, ::IceGrid::AdapterDescriptor& v)
4686  {
4687  istr->read(v.name);
4688  istr->read(v.description);
4689  istr->read(v.id);
4690  istr->read(v.replicaGroupId);
4691  istr->read(v.priority);
4692  istr->read(v.registerProcess);
4693  istr->read(v.serverLifetime);
4694  istr->read(v.objects);
4695  istr->read(v.allocatables);
4696  }
4697 };
4698 
4699 template<>
4700 struct StreamableTraits< ::IceGrid::DbEnvDescriptor>
4701 {
4702  static const StreamHelperCategory helper = StreamHelperCategoryStruct;
4703  static const int minWireSize = 4;
4704  static const bool fixedLength = false;
4705 };
4706 
4707 template<typename S>
4708 struct StreamWriter< ::IceGrid::DbEnvDescriptor, S>
4709 {
4710  static void write(S* ostr, const ::IceGrid::DbEnvDescriptor& v)
4711  {
4712  ostr->write(v.name);
4713  ostr->write(v.description);
4714  ostr->write(v.dbHome);
4715  ostr->write(v.properties);
4716  }
4717 };
4718 
4719 template<typename S>
4720 struct StreamReader< ::IceGrid::DbEnvDescriptor, S>
4721 {
4722  static void read(S* istr, ::IceGrid::DbEnvDescriptor& v)
4723  {
4724  istr->read(v.name);
4725  istr->read(v.description);
4726  istr->read(v.dbHome);
4727  istr->read(v.properties);
4728  }
4729 };
4730 
4731 template<typename S>
4732 struct StreamWriter< ::IceGrid::CommunicatorDescriptor, S>
4733 {
4734  static void write(S* ostr, const ::IceGrid::CommunicatorDescriptor& v)
4735  {
4736  ostr->write(v.adapters);
4737  ostr->write(v.propertySet);
4738  ostr->write(v.dbEnvs);
4739  ostr->write(v.logs);
4740  ostr->write(v.description);
4741  }
4742 };
4743 
4744 template<typename S>
4745 struct StreamReader< ::IceGrid::CommunicatorDescriptor, S>
4746 {
4747  static void read(S* istr, ::IceGrid::CommunicatorDescriptor& v)
4748  {
4749  istr->read(v.adapters);
4750  istr->read(v.propertySet);
4751  istr->read(v.dbEnvs);
4752  istr->read(v.logs);
4753  istr->read(v.description);
4754  }
4755 };
4756 
4757 template<>
4758 struct StreamableTraits< ::IceGrid::DistributionDescriptor>
4759 {
4760  static const StreamHelperCategory helper = StreamHelperCategoryStruct;
4761  static const int minWireSize = 2;
4762  static const bool fixedLength = false;
4763 };
4764 
4765 template<typename S>
4766 struct StreamWriter< ::IceGrid::DistributionDescriptor, S>
4767 {
4768  static void write(S* ostr, const ::IceGrid::DistributionDescriptor& v)
4769  {
4770  ostr->write(v.icepatch);
4771  ostr->write(v.directories);
4772  }
4773 };
4774 
4775 template<typename S>
4776 struct StreamReader< ::IceGrid::DistributionDescriptor, S>
4777 {
4778  static void read(S* istr, ::IceGrid::DistributionDescriptor& v)
4779  {
4780  istr->read(v.icepatch);
4781  istr->read(v.directories);
4782  }
4783 };
4784 
4785 template<typename S>
4786 struct StreamWriter< ::IceGrid::ServerDescriptor, S>
4787 {
4788  static void write(S* ostr, const ::IceGrid::ServerDescriptor& v)
4789  {
4790  ostr->write(v.id);
4791  ostr->write(v.exe);
4792  ostr->write(v.iceVersion);
4793  ostr->write(v.pwd);
4794  ostr->write(v.options);
4795  ostr->write(v.envs);
4796  ostr->write(v.activation);
4797  ostr->write(v.activationTimeout);
4798  ostr->write(v.deactivationTimeout);
4799  ostr->write(v.applicationDistrib);
4800  ostr->write(v.distrib);
4801  ostr->write(v.allocatable);
4802  ostr->write(v.user);
4803  }
4804 };
4805 
4806 template<typename S>
4807 struct StreamReader< ::IceGrid::ServerDescriptor, S>
4808 {
4809  static void read(S* istr, ::IceGrid::ServerDescriptor& v)
4810  {
4811  istr->read(v.id);
4812  istr->read(v.exe);
4813  istr->read(v.iceVersion);
4814  istr->read(v.pwd);
4815  istr->read(v.options);
4816  istr->read(v.envs);
4817  istr->read(v.activation);
4818  istr->read(v.activationTimeout);
4819  istr->read(v.deactivationTimeout);
4820  istr->read(v.applicationDistrib);
4821  istr->read(v.distrib);
4822  istr->read(v.allocatable);
4823  istr->read(v.user);
4824  }
4825 };
4826 
4827 template<typename S>
4828 struct StreamWriter< ::IceGrid::ServiceDescriptor, S>
4829 {
4830  static void write(S* ostr, const ::IceGrid::ServiceDescriptor& v)
4831  {
4832  ostr->write(v.name);
4833  ostr->write(v.entry);
4834  }
4835 };
4836 
4837 template<typename S>
4838 struct StreamReader< ::IceGrid::ServiceDescriptor, S>
4839 {
4840  static void read(S* istr, ::IceGrid::ServiceDescriptor& v)
4841  {
4842  istr->read(v.name);
4843  istr->read(v.entry);
4844  }
4845 };
4846 
4847 template<>
4848 struct StreamableTraits< ::IceGrid::ServerInstanceDescriptor>
4849 {
4850  static const StreamHelperCategory helper = StreamHelperCategoryStruct;
4851  static const int minWireSize = 5;
4852  static const bool fixedLength = false;
4853 };
4854 
4855 template<typename S>
4856 struct StreamWriter< ::IceGrid::ServerInstanceDescriptor, S>
4857 {
4858  static void write(S* ostr, const ::IceGrid::ServerInstanceDescriptor& v)
4859  {
4860  ostr->write(v._cpp_template);
4861  ostr->write(v.parameterValues);
4862  ostr->write(v.propertySet);
4863  ostr->write(v.servicePropertySets);
4864  }
4865 };
4866 
4867 template<typename S>
4868 struct StreamReader< ::IceGrid::ServerInstanceDescriptor, S>
4869 {
4870  static void read(S* istr, ::IceGrid::ServerInstanceDescriptor& v)
4871  {
4872  istr->read(v._cpp_template);
4873  istr->read(v.parameterValues);
4874  istr->read(v.propertySet);
4875  istr->read(v.servicePropertySets);
4876  }
4877 };
4878 
4879 template<>
4880 struct StreamableTraits< ::IceGrid::TemplateDescriptor>
4881 {
4882  static const StreamHelperCategory helper = StreamHelperCategoryStruct;
4883  static const int minWireSize = 3;
4884  static const bool fixedLength = false;
4885 };
4886 
4887 template<typename S>
4888 struct StreamWriter< ::IceGrid::TemplateDescriptor, S>
4889 {
4890  static void write(S* ostr, const ::IceGrid::TemplateDescriptor& v)
4891  {
4892  ostr->write(v.descriptor);
4893  ostr->write(v.parameters);
4894  ostr->write(v.parameterDefaults);
4895  }
4896 };
4897 
4898 template<typename S>
4899 struct StreamReader< ::IceGrid::TemplateDescriptor, S>
4900 {
4901  static void read(S* istr, ::IceGrid::TemplateDescriptor& v)
4902  {
4903  istr->read(v.descriptor);
4904  istr->read(v.parameters);
4905  istr->read(v.parameterDefaults);
4906  }
4907 };
4908 
4909 template<>
4910 struct StreamableTraits< ::IceGrid::ServiceInstanceDescriptor>
4911 {
4912  static const StreamHelperCategory helper = StreamHelperCategoryStruct;
4913  static const int minWireSize = 5;
4914  static const bool fixedLength = false;
4915 };
4916 
4917 template<typename S>
4918 struct StreamWriter< ::IceGrid::ServiceInstanceDescriptor, S>
4919 {
4920  static void write(S* ostr, const ::IceGrid::ServiceInstanceDescriptor& v)
4921  {
4922  ostr->write(v._cpp_template);
4923  ostr->write(v.parameterValues);
4924  ostr->write(v.descriptor);
4925  ostr->write(v.propertySet);
4926  }
4927 };
4928 
4929 template<typename S>
4930 struct StreamReader< ::IceGrid::ServiceInstanceDescriptor, S>
4931 {
4932  static void read(S* istr, ::IceGrid::ServiceInstanceDescriptor& v)
4933  {
4934  istr->read(v._cpp_template);
4935  istr->read(v.parameterValues);
4936  istr->read(v.descriptor);
4937  istr->read(v.propertySet);
4938  }
4939 };
4940 
4941 template<typename S>
4942 struct StreamWriter< ::IceGrid::IceBoxDescriptor, S>
4943 {
4944  static void write(S* ostr, const ::IceGrid::IceBoxDescriptor& v)
4945  {
4946  ostr->write(v.services);
4947  }
4948 };
4949 
4950 template<typename S>
4951 struct StreamReader< ::IceGrid::IceBoxDescriptor, S>
4952 {
4953  static void read(S* istr, ::IceGrid::IceBoxDescriptor& v)
4954  {
4955  istr->read(v.services);
4956  }
4957 };
4958 
4959 template<>
4960 struct StreamableTraits< ::IceGrid::NodeDescriptor>
4961 {
4962  static const StreamHelperCategory helper = StreamHelperCategoryStruct;
4963  static const int minWireSize = 6;
4964  static const bool fixedLength = false;
4965 };
4966 
4967 template<typename S>
4968 struct StreamWriter< ::IceGrid::NodeDescriptor, S>
4969 {
4970  static void write(S* ostr, const ::IceGrid::NodeDescriptor& v)
4971  {
4972  ostr->write(v.variables);
4973  ostr->write(v.serverInstances);
4974  ostr->write(v.servers);
4975  ostr->write(v.loadFactor);
4976  ostr->write(v.description);
4977  ostr->write(v.propertySets);
4978  }
4979 };
4980 
4981 template<typename S>
4982 struct StreamReader< ::IceGrid::NodeDescriptor, S>
4983 {
4984  static void read(S* istr, ::IceGrid::NodeDescriptor& v)
4985  {
4986  istr->read(v.variables);
4987  istr->read(v.serverInstances);
4988  istr->read(v.servers);
4989  istr->read(v.loadFactor);
4990  istr->read(v.description);
4991  istr->read(v.propertySets);
4992  }
4993 };
4994 
4995 template<typename S>
4996 struct StreamWriter< ::IceGrid::LoadBalancingPolicy, S>
4997 {
4998  static void write(S* ostr, const ::IceGrid::LoadBalancingPolicy& v)
4999  {
5000  ostr->write(v.nReplicas);
5001  }
5002 };
5003 
5004 template<typename S>
5005 struct StreamReader< ::IceGrid::LoadBalancingPolicy, S>
5006 {
5007  static void read(S* istr, ::IceGrid::LoadBalancingPolicy& v)
5008  {
5009  istr->read(v.nReplicas);
5010  }
5011 };
5012 
5013 template<typename S>
5014 struct StreamWriter< ::IceGrid::AdaptiveLoadBalancingPolicy, S>
5015 {
5016  static void write(S* ostr, const ::IceGrid::AdaptiveLoadBalancingPolicy& v)
5017  {
5018  ostr->write(v.loadSample);
5019  }
5020 };
5021 
5022 template<typename S>
5023 struct StreamReader< ::IceGrid::AdaptiveLoadBalancingPolicy, S>
5024 {
5025  static void read(S* istr, ::IceGrid::AdaptiveLoadBalancingPolicy& v)
5026  {
5027  istr->read(v.loadSample);
5028  }
5029 };
5030 
5031 template<>
5032 struct StreamableTraits< ::IceGrid::ReplicaGroupDescriptor>
5033 {
5034  static const StreamHelperCategory helper = StreamHelperCategoryStruct;
5035  static const int minWireSize = 6;
5036  static const bool fixedLength = false;
5037 };
5038 
5039 template<typename S>
5040 struct StreamWriter< ::IceGrid::ReplicaGroupDescriptor, S>
5041 {
5042  static void write(S* ostr, const ::IceGrid::ReplicaGroupDescriptor& v)
5043  {
5044  ostr->write(v.id);
5045  ostr->write(v.loadBalancing);
5046  ostr->write(v.proxyOptions);
5047  ostr->write(v.objects);
5048  ostr->write(v.description);
5049  ostr->write(v.filter);
5050  }
5051 };
5052 
5053 template<typename S>
5054 struct StreamReader< ::IceGrid::ReplicaGroupDescriptor, S>
5055 {
5056  static void read(S* istr, ::IceGrid::ReplicaGroupDescriptor& v)
5057  {
5058  istr->read(v.id);
5059  istr->read(v.loadBalancing);
5060  istr->read(v.proxyOptions);
5061  istr->read(v.objects);
5062  istr->read(v.description);
5063  istr->read(v.filter);
5064  }
5065 };
5066 
5067 template<>
5068 struct StreamableTraits< ::IceGrid::ApplicationDescriptor>
5069 {
5070  static const StreamHelperCategory helper = StreamHelperCategoryStruct;
5071  static const int minWireSize = 10;
5072  static const bool fixedLength = false;
5073 };
5074 
5075 template<typename S>
5076 struct StreamWriter< ::IceGrid::ApplicationDescriptor, S>
5077 {
5078  static void write(S* ostr, const ::IceGrid::ApplicationDescriptor& v)
5079  {
5080  ostr->write(v.name);
5081  ostr->write(v.variables);
5082  ostr->write(v.replicaGroups);
5083  ostr->write(v.serverTemplates);
5084  ostr->write(v.serviceTemplates);
5085  ostr->write(v.nodes);
5086  ostr->write(v.distrib);
5087  ostr->write(v.description);
5088  ostr->write(v.propertySets);
5089  }
5090 };
5091 
5092 template<typename S>
5093 struct StreamReader< ::IceGrid::ApplicationDescriptor, S>
5094 {
5095  static void read(S* istr, ::IceGrid::ApplicationDescriptor& v)
5096  {
5097  istr->read(v.name);
5098  istr->read(v.variables);
5099  istr->read(v.replicaGroups);
5100  istr->read(v.serverTemplates);
5101  istr->read(v.serviceTemplates);
5102  istr->read(v.nodes);
5103  istr->read(v.distrib);
5104  istr->read(v.description);
5105  istr->read(v.propertySets);
5106  }
5107 };
5108 
5109 template<typename S>
5110 struct StreamWriter< ::IceGrid::BoxedString, S>
5111 {
5112  static void write(S* ostr, const ::IceGrid::BoxedString& v)
5113  {
5114  ostr->write(v.value);
5115  }
5116 };
5117 
5118 template<typename S>
5119 struct StreamReader< ::IceGrid::BoxedString, S>
5120 {
5121  static void read(S* istr, ::IceGrid::BoxedString& v)
5122  {
5123  istr->read(v.value);
5124  }
5125 };
5126 
5127 template<>
5128 struct StreamableTraits< ::IceGrid::NodeUpdateDescriptor>
5129 {
5130  static const StreamHelperCategory helper = StreamHelperCategoryStruct;
5131  static const int minWireSize = 10;
5132  static const bool fixedLength = false;
5133 };
5134 
5135 template<typename S>
5136 struct StreamWriter< ::IceGrid::NodeUpdateDescriptor, S>
5137 {
5138  static void write(S* ostr, const ::IceGrid::NodeUpdateDescriptor& v)
5139  {
5140  ostr->write(v.name);
5141  ostr->write(v.description);
5142  ostr->write(v.variables);
5143  ostr->write(v.removeVariables);
5144  ostr->write(v.propertySets);
5145  ostr->write(v.removePropertySets);
5146  ostr->write(v.serverInstances);
5147  ostr->write(v.servers);
5148  ostr->write(v.removeServers);
5149  ostr->write(v.loadFactor);
5150  }
5151 };
5152 
5153 template<typename S>
5154 struct StreamReader< ::IceGrid::NodeUpdateDescriptor, S>
5155 {
5156  static void read(S* istr, ::IceGrid::NodeUpdateDescriptor& v)
5157  {
5158  istr->read(v.name);
5159  istr->read(v.description);
5160  istr->read(v.variables);
5161  istr->read(v.removeVariables);
5162  istr->read(v.propertySets);
5163  istr->read(v.removePropertySets);
5164  istr->read(v.serverInstances);
5165  istr->read(v.servers);
5166  istr->read(v.removeServers);
5167  istr->read(v.loadFactor);
5168  }
5169 };
5170 
5171 template<typename S>
5172 struct StreamWriter< ::IceGrid::BoxedDistributionDescriptor, S>
5173 {
5174  static void write(S* ostr, const ::IceGrid::BoxedDistributionDescriptor& v)
5175  {
5176  ostr->write(v.value);
5177  }
5178 };
5179 
5180 template<typename S>
5181 struct StreamReader< ::IceGrid::BoxedDistributionDescriptor, S>
5182 {
5183  static void read(S* istr, ::IceGrid::BoxedDistributionDescriptor& v)
5184  {
5185  istr->read(v.value);
5186  }
5187 };
5188 
5189 template<>
5190 struct StreamableTraits< ::IceGrid::ApplicationUpdateDescriptor>
5191 {
5192  static const StreamHelperCategory helper = StreamHelperCategoryStruct;
5193  static const int minWireSize = 15;
5194  static const bool fixedLength = false;
5195 };
5196 
5197 template<typename S>
5198 struct StreamWriter< ::IceGrid::ApplicationUpdateDescriptor, S>
5199 {
5200  static void write(S* ostr, const ::IceGrid::ApplicationUpdateDescriptor& v)
5201  {
5202  ostr->write(v.name);
5203  ostr->write(v.description);
5204  ostr->write(v.distrib);
5205  ostr->write(v.variables);
5206  ostr->write(v.removeVariables);
5207  ostr->write(v.propertySets);
5208  ostr->write(v.removePropertySets);
5209  ostr->write(v.replicaGroups);
5210  ostr->write(v.removeReplicaGroups);
5211  ostr->write(v.serverTemplates);
5212  ostr->write(v.removeServerTemplates);
5213  ostr->write(v.serviceTemplates);
5214  ostr->write(v.removeServiceTemplates);
5215  ostr->write(v.nodes);
5216  ostr->write(v.removeNodes);
5217  }
5218 };
5219 
5220 template<typename S>
5221 struct StreamReader< ::IceGrid::ApplicationUpdateDescriptor, S>
5222 {
5223  static void read(S* istr, ::IceGrid::ApplicationUpdateDescriptor& v)
5224  {
5225  istr->read(v.name);
5226  istr->read(v.description);
5227  istr->read(v.distrib);
5228  istr->read(v.variables);
5229  istr->read(v.removeVariables);
5230  istr->read(v.propertySets);
5231  istr->read(v.removePropertySets);
5232  istr->read(v.replicaGroups);
5233  istr->read(v.removeReplicaGroups);
5234  istr->read(v.serverTemplates);
5235  istr->read(v.removeServerTemplates);
5236  istr->read(v.serviceTemplates);
5237  istr->read(v.removeServiceTemplates);
5238  istr->read(v.nodes);
5239  istr->read(v.removeNodes);
5240  }
5241 };
5242 
5243 }
5245 
5246 namespace IceGrid
5247 {
5248 
5249 }
5250 
5251 #endif
5252 
5253 #include <IceUtil/PopDisableWarnings.h>
5254 #endif
IceGrid::LoadBalancingPolicy::operator=
LoadBalancingPolicy & operator=(LoadBalancingPolicy &&)=default
IceGrid::BoxedDistributionDescriptor::value
::IceGrid::DistributionDescriptor value
The value of the boxed distribution descriptor.
Definition: Descriptor.h:1393
IceGrid::ServiceDescriptor::name
::std::string name
The service name.
Definition: Descriptor.h:1003
IceGrid::RoundRobinLoadBalancingPolicy::ice_tuple
std::tuple< const ::std::string & > ice_tuple() const
Obtains a tuple containing all of the value's data members.
Definition: Descriptor.h:1238
IceGrid::NodeUpdateDescriptor::ice_tuple
std::tuple< const ::std::string &, const ::std::shared_ptr<::IceGrid::BoxedString > &, const ::IceGrid::StringStringDict &, const ::Ice::StringSeq &, const ::IceGrid::PropertySetDescriptorDict &, const ::Ice::StringSeq &, const ::IceGrid::ServerInstanceDescriptorSeq &, const ::IceGrid::ServerDescriptorSeq &, const ::Ice::StringSeq &, const ::std::shared_ptr<::IceGrid::BoxedString > & > ice_tuple() const
Obtains a tuple containing all of the struct's data members.
Definition: Descriptor.h:641
Ice::operator!=
bool operator!=(const C &lhs, const C &rhs)
Relational operator for generated structs and classes.
Definition: Comparable.h:196
IceGrid::CommunicatorDescriptor::CommunicatorDescriptor
CommunicatorDescriptor(const ::IceGrid::AdapterDescriptorSeq &adapters, const ::IceGrid::PropertySetDescriptor &propertySet, const ::IceGrid::DbEnvDescriptorSeq &dbEnvs, const ::Ice::StringSeq &logs, const ::std::string &description)
One-shot constructor to initialize all data members.
Definition: Descriptor.h:768
IceGrid::OrderedLoadBalancingPolicy::ice_tuple
std::tuple< const ::std::string & > ice_tuple() const
Obtains a tuple containing all of the value's data members.
Definition: Descriptor.h:1196
IceGrid::IceBoxDescriptor::IceBoxDescriptor
IceBoxDescriptor(const IceBoxDescriptor &)=default
IceGrid::NodeUpdateDescriptor::variables
::IceGrid::StringStringDict variables
The variables to update.
Definition: Descriptor.h:606
IceGrid::ApplicationDescriptor::propertySets
::IceGrid::PropertySetDescriptorDict propertySets
Property set descriptors.
Definition: Descriptor.h:570
IceGrid::OrderedLoadBalancingPolicy::ice_staticId
static const ::std::string & ice_staticId()
Obtains the Slice type ID of this value.
Optional.h
IceGrid::ServerDescriptor::exe
::std::string exe
The path of the server executable.
Definition: Descriptor.h:896
IceGrid::CommunicatorDescriptor::~CommunicatorDescriptor
virtual ~CommunicatorDescriptor()
IceGrid::IceBoxDescriptor::IceBoxDescriptor
IceBoxDescriptor()=default
IceGrid::IceBoxDescriptor::ice_tuple
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
Obtains a tuple containing all of the value's data members.
Definition: Descriptor.h:1059
IceGrid::NodeDescriptor::variables
::IceGrid::StringStringDict variables
The variables defined for the node.
Definition: Descriptor.h:446
IceGrid::BoxedString::BoxedString
BoxedString(BoxedString &&)=default
Ice::InputStream
Interface for input streams used to extract Slice types from a sequence of bytes.
Definition: InputStream.h:50
IceGrid::ServiceDescriptor::ice_tuple
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
Obtains a tuple containing all of the value's data members.
Definition: Descriptor.h:989
IceGrid::ServiceDescriptor::ServiceDescriptor
ServiceDescriptor(const ServiceDescriptor &)=default
IceGrid::BoxedString::ice_staticId
static const ::std::string & ice_staticId()
Obtains the Slice type ID of this value.
IceGrid::RandomLoadBalancingPolicy::RandomLoadBalancingPolicy
RandomLoadBalancingPolicy(const RandomLoadBalancingPolicy &)=default
IceGrid::ServerInstanceDescriptorSeq
::std::vector< ServerInstanceDescriptor > ServerInstanceDescriptorSeq
A sequence of server instance descriptors.
Definition: Descriptor.h:362
IceGrid::DistributionDescriptor
A distribution descriptor defines an IcePatch2 server and the directories to retrieve from the patch ...
Definition: Descriptor.h:295
IceGrid::NodeDescriptor
A node descriptor.
Definition: Descriptor.h:442
IceGrid::PropertySetDescriptor
A property set descriptor.
Definition: Descriptor.h:124
IceGrid::CommunicatorDescriptor::CommunicatorDescriptor
CommunicatorDescriptor(CommunicatorDescriptor &&)=default
IceGrid::BoxedDistributionDescriptor::ice_staticId
static const ::std::string & ice_staticId()
Obtains the Slice type ID of this value.
IceGrid::PropertySetDescriptor::properties
::IceGrid::PropertyDescriptorSeq properties
The property set properties.
Definition: Descriptor.h:132
IceGrid::AdapterDescriptor
An Ice object adapter descriptor.
Definition: Descriptor.h:190
IceGrid::ServiceInstanceDescriptor::descriptor
::std::shared_ptr<::IceGrid::ServiceDescriptor > descriptor
The service definition if the instance isn't a template instance (i.e.
Definition: Descriptor.h:416
IceGrid::ServerInstanceDescriptor::ice_tuple
std::tuple< const ::std::string &, const ::IceGrid::StringStringDict &, const ::IceGrid::PropertySetDescriptor &, const ::IceGrid::PropertySetDescriptorDict & > ice_tuple() const
Obtains a tuple containing all of the struct's data members.
Definition: Descriptor.h:353
IceGrid::NodeUpdateDescriptor::removeVariables
::Ice::StringSeq removeVariables
The variables to remove.
Definition: Descriptor.h:610
IceGrid::ObjectDescriptor::id
::Ice::Identity id
The identity of the object.
Definition: Descriptor.h:158
IceGrid::ApplicationDescriptor::replicaGroups
::IceGrid::ReplicaGroupDescriptorSeq replicaGroups
The replica groups.
Definition: Descriptor.h:546
IceGrid::ServerDescriptor::ServerDescriptor
ServerDescriptor(const ::IceGrid::AdapterDescriptorSeq &adapters, const ::IceGrid::PropertySetDescriptor &propertySet, const ::IceGrid::DbEnvDescriptorSeq &dbEnvs, const ::Ice::StringSeq &logs, const ::std::string &description, const ::std::string &id, const ::std::string &exe, const ::std::string &iceVersion, const ::std::string &pwd, const ::Ice::StringSeq &options, const ::Ice::StringSeq &envs, const ::std::string &activation, const ::std::string &activationTimeout, const ::std::string &deactivationTimeout, bool applicationDistrib, const ::IceGrid::DistributionDescriptor &distrib, bool allocatable, const ::std::string &user)
One-shot constructor to initialize all data members.
Definition: Descriptor.h:856
Ice::emptyCurrent
const Current emptyCurrent
A default-initialized Current instance.
IceGrid::AdaptiveLoadBalancingPolicy::AdaptiveLoadBalancingPolicy
AdaptiveLoadBalancingPolicy(AdaptiveLoadBalancingPolicy &&)=default
IceGrid::ServiceDescriptor::ServiceDescriptor
ServiceDescriptor()=default
IceGrid::AdaptiveLoadBalancingPolicy::operator=
AdaptiveLoadBalancingPolicy & operator=(AdaptiveLoadBalancingPolicy &&)=default
IceGrid::ApplicationDescriptor::distrib
::IceGrid::DistributionDescriptor distrib
The application distribution.
Definition: Descriptor.h:562
IceGrid::AdapterDescriptor::serverLifetime
bool serverLifetime
If true the lifetime of this object adapter is the same of the server lifetime.
Definition: Descriptor.h:223
IceGrid::BoxedDistributionDescriptor::operator=
BoxedDistributionDescriptor & operator=(const BoxedDistributionDescriptor &)=default
IceGrid::NodeUpdateDescriptor::description
::std::shared_ptr<::IceGrid::BoxedString > description
The updated description (or null if the description wasn't updated.)
Definition: Descriptor.h:602
IceGrid::NodeUpdateDescriptor::servers
::IceGrid::ServerDescriptorSeq servers
The servers which are not template instances to update.
Definition: Descriptor.h:626
IceGrid::OrderedLoadBalancingPolicy::OrderedLoadBalancingPolicy
OrderedLoadBalancingPolicy(OrderedLoadBalancingPolicy &&)=default
IceGrid::IceBoxDescriptor::services
::IceGrid::ServiceInstanceDescriptorSeq services
The service instances.
Definition: Descriptor.h:1073
StreamHelpers.h
IceGrid::ApplicationUpdateDescriptor::replicaGroups
::IceGrid::ReplicaGroupDescriptorSeq replicaGroups
The replica groups to update.
Definition: Descriptor.h:691
IceGrid::ServiceInstanceDescriptor::propertySet
::IceGrid::PropertySetDescriptor propertySet
The property set.
Definition: Descriptor.h:420
IceGrid::NodeUpdateDescriptor::propertySets
::IceGrid::PropertySetDescriptorDict propertySets
The property sets to update.
Definition: Descriptor.h:614
IceGrid::NodeDescriptor::description
::std::string description
The description of this node.
Definition: Descriptor.h:462
IceGrid::BoxedString::value
::std::string value
The value of the boxed string.
Definition: Descriptor.h:1346
IceGrid::ApplicationDescriptor::nodes
::IceGrid::NodeDescriptorDict nodes
The application nodes.
Definition: Descriptor.h:558
IceGrid::ServerDescriptor::user
::std::string user
The user account used to run the server.
Definition: Descriptor.h:948
Ice::Object
The base class for servants.
Definition: Object.h:91
Ice::operator==
bool operator==(const C &lhs, const C &rhs)
Relational operator for generated structs and classes.
Definition: Comparable.h:184
IceGrid::ApplicationUpdateDescriptor::serverTemplates
::IceGrid::TemplateDescriptorDict serverTemplates
The server templates to update.
Definition: Descriptor.h:699
IceGrid::IceBoxDescriptor::operator=
IceBoxDescriptor & operator=(const IceBoxDescriptor &)=default
IceGrid::BoxedDistributionDescriptor
A "boxed" distribution descriptor.
Definition: Descriptor.h:1354
IceGrid::TemplateDescriptor::parameters
::Ice::StringSeq parameters
The parameters required to instantiate the template.
Definition: Descriptor.h:377
IceGrid::AdapterDescriptor::allocatables
::IceGrid::ObjectDescriptorSeq allocatables
The allocatable object descriptors associated with this object adapter.
Definition: Descriptor.h:231
IceGrid::BoxedDistributionDescriptor::BoxedDistributionDescriptor
BoxedDistributionDescriptor(BoxedDistributionDescriptor &&)=default
IceGrid::AdaptiveLoadBalancingPolicy::operator=
AdaptiveLoadBalancingPolicy & operator=(const AdaptiveLoadBalancingPolicy &)=default
IceGrid::ApplicationUpdateDescriptor::propertySets
::IceGrid::PropertySetDescriptorDict propertySets
The property sets to update.
Definition: Descriptor.h:683
IceGrid::ApplicationUpdateDescriptor::removePropertySets
::Ice::StringSeq removePropertySets
The property sets to remove.
Definition: Descriptor.h:687
IceGrid::ServiceInstanceDescriptor::ice_tuple
std::tuple< const ::std::string &, const ::IceGrid::StringStringDict &, const ::std::shared_ptr<::IceGrid::ServiceDescriptor > &, const ::IceGrid::PropertySetDescriptor & > ice_tuple() const
Obtains a tuple containing all of the struct's data members.
Definition: Descriptor.h:426
GCObject.h
IceGrid::BoxedString::BoxedString
BoxedString(const ::std::string &value)
One-shot constructor to initialize all data members.
Definition: Descriptor.h:1323
IceGrid::RandomLoadBalancingPolicy::RandomLoadBalancingPolicy
RandomLoadBalancingPolicy(RandomLoadBalancingPolicy &&)=default
IceGrid::OrderedLoadBalancingPolicy::OrderedLoadBalancingPolicy
OrderedLoadBalancingPolicy(const ::std::string &nReplicas)
One-shot constructor to initialize all data members.
Definition: Descriptor.h:1187
IceGrid::CommunicatorDescriptor::dbEnvs
::IceGrid::DbEnvDescriptorSeq dbEnvs
The database environments.
Definition: Descriptor.h:803
IceGrid::CommunicatorDescriptor::operator=
CommunicatorDescriptor & operator=(const CommunicatorDescriptor &)=default
IceGrid::ApplicationUpdateDescriptor::serviceTemplates
::IceGrid::TemplateDescriptorDict serviceTemplates
The service templates to update.
Definition: Descriptor.h:707
IceGrid::BoxedString::operator=
BoxedString & operator=(BoxedString &&)=default
IceGrid::LoadBalancingPolicy::ice_tuple
std::tuple< const ::std::string & > ice_tuple() const
Obtains a tuple containing all of the value's data members.
Definition: Descriptor.h:1106
IceGrid::ReplicaGroupDescriptor::id
::std::string id
The id of the replica group.
Definition: Descriptor.h:492
IceGrid::AdaptiveLoadBalancingPolicy::loadSample
::std::string loadSample
The load sample to use for the load balancing.
Definition: Descriptor.h:1299
IceGrid::ServiceDescriptor::ServiceDescriptor
ServiceDescriptor(const ::IceGrid::AdapterDescriptorSeq &adapters, const ::IceGrid::PropertySetDescriptor &propertySet, const ::IceGrid::DbEnvDescriptorSeq &dbEnvs, const ::Ice::StringSeq &logs, const ::std::string &description, const ::std::string &name, const ::std::string &entry)
One-shot constructor to initialize all data members.
Definition: Descriptor.h:978
IceGrid::LoadBalancingPolicy::LoadBalancingPolicy
LoadBalancingPolicy(const LoadBalancingPolicy &)=default
IceGrid::ServerDescriptor::activationTimeout
::std::string activationTimeout
The activation timeout (an integer value representing the number of seconds to wait for activation).
Definition: Descriptor.h:926
IceGrid::NodeDescriptor::ice_tuple
std::tuple< const ::IceGrid::StringStringDict &, const ::IceGrid::ServerInstanceDescriptorSeq &, const ::IceGrid::ServerDescriptorSeq &, const ::std::string &, const ::std::string &, const ::IceGrid::PropertySetDescriptorDict & > ice_tuple() const
Obtains a tuple containing all of the struct's data members.
Definition: Descriptor.h:472
Incoming.h
IceGrid::CommunicatorDescriptor::operator=
CommunicatorDescriptor & operator=(CommunicatorDescriptor &&)=default
IceGrid::NodeDescriptor::servers
::IceGrid::ServerDescriptorSeq servers
Servers (which are not template instances).
Definition: Descriptor.h:454
IceGrid::RandomLoadBalancingPolicy::operator=
RandomLoadBalancingPolicy & operator=(const RandomLoadBalancingPolicy &)=default
IceGrid::CommunicatorDescriptor::logs
::Ice::StringSeq logs
The path of each log file.
Definition: Descriptor.h:807
IceGrid::ServerInstanceDescriptor::servicePropertySets
::IceGrid::PropertySetDescriptorDict servicePropertySets
The services property sets.
Definition: Descriptor.h:347
IceGrid::AdaptiveLoadBalancingPolicy::AdaptiveLoadBalancingPolicy
AdaptiveLoadBalancingPolicy()=default
IceGrid::PropertyDescriptor
Property descriptor.
Definition: Descriptor.h:94
IceGrid::ServerDescriptor::ServerDescriptor
ServerDescriptor()=default
IceGrid::NodeUpdateDescriptor
A node update descriptor to describe the updates to apply to a node of a deployed application.
Definition: Descriptor.h:593
ICE_MEMBER
#define ICE_MEMBER(API)
Definition: Config.h:177
IceGrid::AdapterDescriptor::id
::std::string id
The object adapter id.
Definition: Descriptor.h:202
IceGrid::ServiceDescriptor::ServiceDescriptor
ServiceDescriptor(ServiceDescriptor &&)=default
IceGrid::NodeDescriptor::propertySets
::IceGrid::PropertySetDescriptorDict propertySets
Property set descriptors.
Definition: Descriptor.h:466
IceGrid::ServiceDescriptor::operator=
ServiceDescriptor & operator=(ServiceDescriptor &&)=default
IceGrid::ServerDescriptor::distrib
::IceGrid::DistributionDescriptor distrib
The distribution descriptor.
Definition: Descriptor.h:940
Ice::operator<=
bool operator<=(const C &lhs, const C &rhs)
Relational operator for generated structs and classes.
Definition: Comparable.h:148
IceGrid::RoundRobinLoadBalancingPolicy::~RoundRobinLoadBalancingPolicy
virtual ~RoundRobinLoadBalancingPolicy()
FactoryTableInit.h
IceGrid::PropertyDescriptor::ice_tuple
std::tuple< const ::std::string &, const ::std::string & > ice_tuple() const
Obtains a tuple containing all of the struct's data members.
Definition: Descriptor.h:108
IceGrid::ApplicationUpdateDescriptor::removeVariables
::Ice::StringSeq removeVariables
The variables to remove.
Definition: Descriptor.h:679
IceGrid::ServiceInstanceDescriptor
A service template instance descriptor.
Definition: Descriptor.h:403
IceGrid::DistributionDescriptor::icepatch
::std::string icepatch
The proxy of the IcePatch2 server.
Definition: Descriptor.h:299
IceGrid::CommunicatorDescriptor
A communicator descriptor.
Definition: Descriptor.h:748
IceGrid::LoadBalancingPolicy::LoadBalancingPolicy
LoadBalancingPolicy(LoadBalancingPolicy &&)=default
IceGrid::RandomLoadBalancingPolicy::~RandomLoadBalancingPolicy
virtual ~RandomLoadBalancingPolicy()
IceGrid::TemplateDescriptor::ice_tuple
std::tuple< const ::std::shared_ptr<::IceGrid::CommunicatorDescriptor > &, const ::Ice::StringSeq &, const ::IceGrid::StringStringDict & > ice_tuple() const
Obtains a tuple containing all of the struct's data members.
Definition: Descriptor.h:387
IceGrid::BoxedString::BoxedString
BoxedString()=default
IceGrid::AdapterDescriptorSeq
::std::vector< AdapterDescriptor > AdapterDescriptorSeq
A sequence of adapter descriptors.
Definition: Descriptor.h:246
IceGrid::ApplicationUpdateDescriptor::removeServiceTemplates
::Ice::StringSeq removeServiceTemplates
The ids of the service template to remove.
Definition: Descriptor.h:711
IceGrid::AdapterDescriptor::objects
::IceGrid::ObjectDescriptorSeq objects
The well-known object descriptors associated with this object adapter.
Definition: Descriptor.h:227
IceGrid::DistributionDescriptor::ice_tuple
std::tuple< const ::std::string &, const ::Ice::StringSeq & > ice_tuple() const
Obtains a tuple containing all of the struct's data members.
Definition: Descriptor.h:309
IceGrid::StringStringDict
::std::map<::std::string, ::std::string > StringStringDict
A mapping of string to string.
Definition: Descriptor.h:87
IceGrid::ServerDescriptor::ice_tuple
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
Obtains a tuple containing all of the value's data members.
Definition: Descriptor.h:878
IceGrid::TemplateDescriptor
A template descriptor for server or service templates.
Definition: Descriptor.h:369
IceGrid::NodeDescriptorDict
::std::map<::std::string, NodeDescriptor > NodeDescriptorDict
Mapping of node name to node descriptor.
Definition: Descriptor.h:481
IceGrid::ServiceDescriptorSeq
::std::vector<::std::shared_ptr< ServiceDescriptor > > ServiceDescriptorSeq
A sequence of service descriptors.
Definition: Descriptor.h:323
IceGrid::BoxedDistributionDescriptor::ice_tuple
std::tuple< const ::IceGrid::DistributionDescriptor & > ice_tuple() const
Obtains a tuple containing all of the value's data members.
Definition: Descriptor.h:1379
IceGrid::DistributionDescriptor::directories
::Ice::StringSeq directories
The source directories.
Definition: Descriptor.h:303
ICEGRID_API
#define ICEGRID_API
Definition: Descriptor.h:58
IceGrid::OrderedLoadBalancingPolicy
Ordered load balancing policy.
Definition: Descriptor.h:1171
IceGrid::RoundRobinLoadBalancingPolicy::ice_staticId
static const ::std::string & ice_staticId()
Obtains the Slice type ID of this value.
IceGrid::LoadBalancingPolicy::LoadBalancingPolicy
LoadBalancingPolicy()=default
IceGrid::AdaptiveLoadBalancingPolicy::AdaptiveLoadBalancingPolicy
AdaptiveLoadBalancingPolicy(const ::std::string &nReplicas, const ::std::string &loadSample)
One-shot constructor to initialize all data members.
Definition: Descriptor.h:1272
IceGrid::CommunicatorDescriptor::propertySet
::IceGrid::PropertySetDescriptor propertySet
The property set.
Definition: Descriptor.h:799
IceGrid::RoundRobinLoadBalancingPolicy::RoundRobinLoadBalancingPolicy
RoundRobinLoadBalancingPolicy(const RoundRobinLoadBalancingPolicy &)=default
IceGrid::DbEnvDescriptor
A Freeze database environment descriptor.
Definition: Descriptor.h:253
IceGrid::ApplicationDescriptor::serviceTemplates
::IceGrid::TemplateDescriptorDict serviceTemplates
The service templates.
Definition: Descriptor.h:554
Ice::operator>=
bool operator>=(const C &lhs, const C &rhs)
Relational operator for generated structs and classes.
Definition: Comparable.h:172
IceGrid::BoxedString::operator=
BoxedString & operator=(const BoxedString &)=default
LocalObject.h
IceGrid::ApplicationUpdateDescriptor::description
::std::shared_ptr<::IceGrid::BoxedString > description
The updated description (or null if the description wasn't updated.)
Definition: Descriptor.h:667
IceGrid::ObjectDescriptor::type
::std::string type
The object type.
Definition: Descriptor.h:162
PushDisableWarnings.h
IceGrid::OrderedLoadBalancingPolicy::OrderedLoadBalancingPolicy
OrderedLoadBalancingPolicy(const OrderedLoadBalancingPolicy &)=default
IceGrid::IceBoxDescriptor::~IceBoxDescriptor
virtual ~IceBoxDescriptor()
IceGrid::ServerDescriptorSeq
::std::vector<::std::shared_ptr< ServerDescriptor > > ServerDescriptorSeq
A sequence of server descriptors.
Definition: Descriptor.h:318
IceGrid::RoundRobinLoadBalancingPolicy::operator=
RoundRobinLoadBalancingPolicy & operator=(RoundRobinLoadBalancingPolicy &&)=default
IceGrid::ServerInstanceDescriptor::parameterValues
::IceGrid::StringStringDict parameterValues
The template parameter values.
Definition: Descriptor.h:338
IceGrid::ApplicationDescriptorSeq
::std::vector< ApplicationDescriptor > ApplicationDescriptorSeq
A sequence of application descriptors.
Definition: Descriptor.h:585
IceGrid::ServerDescriptor::~ServerDescriptor
virtual ~ServerDescriptor()
IceGrid::PropertyDescriptor::value
::std::string value
The value of the property.
Definition: Descriptor.h:102
IceGrid::BoxedDistributionDescriptor::~BoxedDistributionDescriptor
virtual ~BoxedDistributionDescriptor()
IceGrid::LoadBalancingPolicy::operator=
LoadBalancingPolicy & operator=(const LoadBalancingPolicy &)=default
IceGrid::DbEnvDescriptorSeq
::std::vector< DbEnvDescriptor > DbEnvDescriptorSeq
A sequence of database environment descriptors.
Definition: Descriptor.h:287
IceGrid::BoxedDistributionDescriptor::BoxedDistributionDescriptor
BoxedDistributionDescriptor(const BoxedDistributionDescriptor &)=default
IceGrid::ApplicationUpdateDescriptor::removeNodes
::Ice::StringSeq removeNodes
The nodes to remove.
Definition: Descriptor.h:719
IceGrid::AdaptiveLoadBalancingPolicy::AdaptiveLoadBalancingPolicy
AdaptiveLoadBalancingPolicy(const AdaptiveLoadBalancingPolicy &)=default
IceGrid::ReplicaGroupDescriptor
A replica group descriptor.
Definition: Descriptor.h:488
IceGrid::BoxedString::~BoxedString
virtual ~BoxedString()
ProxyF.h
IceGrid::PropertyDescriptor::name
::std::string name
The name of the property.
Definition: Descriptor.h:98
IceGrid::AdapterDescriptor::priority
::std::string priority
The adapter priority.
Definition: Descriptor.h:212
IceGrid::ApplicationUpdateDescriptor::variables
::IceGrid::StringStringDict variables
The variables to update.
Definition: Descriptor.h:675
IceGrid::NodeUpdateDescriptor::serverInstances
::IceGrid::ServerInstanceDescriptorSeq serverInstances
The server instances to update.
Definition: Descriptor.h:622
IceGrid::AdapterDescriptor::name
::std::string name
The object adapter name.
Definition: Descriptor.h:194
Ice::operator<
bool operator<(const C &lhs, const C &rhs)
Relational operator for generated structs and classes.
Definition: Comparable.h:136
IceGrid::LoadBalancingPolicy::ice_staticId
static const ::std::string & ice_staticId()
Obtains the Slice type ID of this value.
IceGrid::AdapterDescriptor::registerProcess
bool registerProcess
Flag to specify if the object adapter will register a process object.
Definition: Descriptor.h:216
IceGrid::NodeDescriptor::loadFactor
::std::string loadFactor
Load factor of the node.
Definition: Descriptor.h:458
IceGrid::ApplicationUpdateDescriptor::removeServerTemplates
::Ice::StringSeq removeServerTemplates
The ids of the server template to remove.
Definition: Descriptor.h:703
IceGrid::AdaptiveLoadBalancingPolicy::ice_tuple
std::tuple< const ::std::string &, const ::std::string & > ice_tuple() const
Obtains a tuple containing all of the value's data members.
Definition: Descriptor.h:1282
IceGrid::ServiceInstanceDescriptorSeq
::std::vector< ServiceInstanceDescriptor > ServiceInstanceDescriptorSeq
A sequence of service instance descriptors.
Definition: Descriptor.h:435
IceGrid::BoxedDistributionDescriptor::operator=
BoxedDistributionDescriptor & operator=(BoxedDistributionDescriptor &&)=default
IceGrid::ServerDescriptor::iceVersion
::std::string iceVersion
The Ice version used by this server.
Definition: Descriptor.h:904
IceGrid::ReplicaGroupDescriptor::loadBalancing
::std::shared_ptr<::IceGrid::LoadBalancingPolicy > loadBalancing
The load balancing policy.
Definition: Descriptor.h:496
IceGrid::TemplateDescriptor::parameterDefaults
::IceGrid::StringStringDict parameterDefaults
The parameters default values.
Definition: Descriptor.h:381
IceGrid::ServerDescriptor::allocatable
bool allocatable
Specifies if the server is allocatable.
Definition: Descriptor.h:944
IceGrid::ServiceDescriptor::~ServiceDescriptor
virtual ~ServiceDescriptor()
IceGrid::NodeUpdateDescriptor::removeServers
::Ice::StringSeq removeServers
The ids of the servers to remove.
Definition: Descriptor.h:630
IceGrid::ServerDescriptor::operator=
ServerDescriptor & operator=(ServerDescriptor &&)=default
IceGrid::TemplateDescriptorDict
::std::map<::std::string, TemplateDescriptor > TemplateDescriptorDict
A mapping of template identifier to template descriptor.
Definition: Descriptor.h:396
IceGrid::ReplicaGroupDescriptor::description
::std::string description
The description of this replica group.
Definition: Descriptor.h:508
IceGrid::ServiceDescriptor::ice_staticId
static const ::std::string & ice_staticId()
Obtains the Slice type ID of this value.
IceGrid::OrderedLoadBalancingPolicy::OrderedLoadBalancingPolicy
OrderedLoadBalancingPolicy()=default
IceGrid::ServerInstanceDescriptor::propertySet
::IceGrid::PropertySetDescriptor propertySet
The property set.
Definition: Descriptor.h:342
Object.h
IceGrid::AdapterDescriptor::description
::std::string description
The description of this object adapter.
Definition: Descriptor.h:198
Proxy.h
IceGrid::ApplicationUpdateDescriptor::removeReplicaGroups
::Ice::StringSeq removeReplicaGroups
The replica groups to remove.
Definition: Descriptor.h:695
IceGrid::RoundRobinLoadBalancingPolicy::operator=
RoundRobinLoadBalancingPolicy & operator=(const RoundRobinLoadBalancingPolicy &)=default
IceGrid::OrderedLoadBalancingPolicy::operator=
OrderedLoadBalancingPolicy & operator=(const OrderedLoadBalancingPolicy &)=default
IceGrid::ApplicationUpdateDescriptor::distrib
::std::shared_ptr<::IceGrid::BoxedDistributionDescriptor > distrib
The updated distribution application descriptor.
Definition: Descriptor.h:671
IceGrid::ServerDescriptor::options
::Ice::StringSeq options
The command line options to pass to the server executable.
Definition: Descriptor.h:912
UndefSysMacros.h
IceGrid::ServiceInstanceDescriptor::parameterValues
::IceGrid::StringStringDict parameterValues
The template parameter values.
Definition: Descriptor.h:411
IceGrid::ServerDescriptor::applicationDistrib
bool applicationDistrib
Specifies if the server depends on the application distribution.
Definition: Descriptor.h:936
IceGrid::ServiceDescriptor::operator=
ServiceDescriptor & operator=(const ServiceDescriptor &)=default
Ice::OutputStream
Interface for output streams used to create a sequence of bytes from Slice types.
Definition: OutputStream.h:28
IceGrid::BoxedDistributionDescriptor::BoxedDistributionDescriptor
BoxedDistributionDescriptor()=default
IceGrid::ObjectDescriptor::ice_tuple
std::tuple< const ::Ice::Identity &, const ::std::string &, const ::std::string & > ice_tuple() const
Obtains a tuple containing all of the struct's data members.
Definition: Descriptor.h:174
IceGrid::ServiceInstanceDescriptor::_cpp_template
::std::string _cpp_template
The template used by this instance.
Definition: Descriptor.h:407
IceGrid::PropertySetDescriptor::ice_tuple
std::tuple< const ::Ice::StringSeq &, const ::IceGrid::PropertyDescriptorSeq & > ice_tuple() const
Obtains a tuple containing all of the struct's data members.
Definition: Descriptor.h:138
IceGrid::LoadBalancingPolicy::nReplicas
::std::string nReplicas
The number of replicas that will be used to gather the endpoints of a replica group.
Definition: Descriptor.h:1121
ObjectF.h
IceGrid::RoundRobinLoadBalancingPolicy::RoundRobinLoadBalancingPolicy
RoundRobinLoadBalancingPolicy(RoundRobinLoadBalancingPolicy &&)=default
IceGrid::RandomLoadBalancingPolicy
Random load balancing policy.
Definition: Descriptor.h:1129
Ice::operator>
bool operator>(const C &lhs, const C &rhs)
Relational operator for generated structs and classes.
Definition: Comparable.h:160
IceGrid::NodeDescriptor::serverInstances
::IceGrid::ServerInstanceDescriptorSeq serverInstances
The server instances.
Definition: Descriptor.h:450
IceGrid::AdaptiveLoadBalancingPolicy::~AdaptiveLoadBalancingPolicy
virtual ~AdaptiveLoadBalancingPolicy()
Ice::StringSeq
::std::vector<::std::string > StringSeq
A sequence of strings.
Definition: BuiltinSequences.h:96
IceGrid::ServerDescriptor::activation
::std::string activation
The server activation mode (possible values are "on-demand" or "manual").
Definition: Descriptor.h:921
IceGrid::IceBoxDescriptor::IceBoxDescriptor
IceBoxDescriptor(IceBoxDescriptor &&)=default
Ice
Definition: BuiltinSequences.h:56
IceGrid::RandomLoadBalancingPolicy::operator=
RandomLoadBalancingPolicy & operator=(RandomLoadBalancingPolicy &&)=default
IceGrid::RandomLoadBalancingPolicy::ice_tuple
std::tuple< const ::std::string & > ice_tuple() const
Obtains a tuple containing all of the value's data members.
Definition: Descriptor.h:1154
IceGrid::AdaptiveLoadBalancingPolicy
Adaptive load balancing policy.
Definition: Descriptor.h:1255
IceGrid::OrderedLoadBalancingPolicy::operator=
OrderedLoadBalancingPolicy & operator=(OrderedLoadBalancingPolicy &&)=default
IceGrid::LoadBalancingPolicy::LoadBalancingPolicy
LoadBalancingPolicy(const ::std::string &nReplicas)
One-shot constructor to initialize all data members.
Definition: Descriptor.h:1097
IceGrid::NodeUpdateDescriptor::removePropertySets
::Ice::StringSeq removePropertySets
The property sets to remove.
Definition: Descriptor.h:618
IceGrid::ObjectDescriptor::proxyOptions
::std::string proxyOptions
Proxy options to use with the proxy created for this Ice object.
Definition: Descriptor.h:168
IceGrid::ReplicaGroupDescriptor::proxyOptions
::std::string proxyOptions
Default options for proxies created for the replica group.
Definition: Descriptor.h:500
IceGrid::ObjectDescriptorSeq
::std::vector< ObjectDescriptor > ObjectDescriptorSeq
A sequence of object descriptors.
Definition: Descriptor.h:183
IceGrid::DbEnvDescriptor::name
::std::string name
The name of the database environment.
Definition: Descriptor.h:257
IceGrid::CommunicatorDescriptor::ice_tuple
std::tuple< const ::IceGrid::AdapterDescriptorSeq &, const ::IceGrid::PropertySetDescriptor &, const ::IceGrid::DbEnvDescriptorSeq &, const ::Ice::StringSeq &, const ::std::string & > ice_tuple() const
Obtains a tuple containing all of the value's data members.
Definition: Descriptor.h:781
IceGrid::RandomLoadBalancingPolicy::RandomLoadBalancingPolicy
RandomLoadBalancingPolicy(const ::std::string &nReplicas)
One-shot constructor to initialize all data members.
Definition: Descriptor.h:1145
IceGrid::PropertyDescriptorSeq
::std::vector< PropertyDescriptor > PropertyDescriptorSeq
A sequence of property descriptors.
Definition: Descriptor.h:117
IceGrid::ApplicationDescriptor::description
::std::string description
The description of this application.
Definition: Descriptor.h:566
Identity.h
IceGrid::NodeUpdateDescriptor::loadFactor
::std::shared_ptr<::IceGrid::BoxedString > loadFactor
The updated load factor of the node (or null if the load factor was not updated).
Definition: Descriptor.h:635
IceGrid::DbEnvDescriptor::properties
::IceGrid::PropertyDescriptorSeq properties
The configuration properties of the database environment.
Definition: Descriptor.h:272
IceGrid::IceBoxDescriptor::operator=
IceBoxDescriptor & operator=(IceBoxDescriptor &&)=default
IceGrid::ApplicationUpdateDescriptor::name
::std::string name
The name of the application to update.
Definition: Descriptor.h:662
IceGrid::ServerDescriptor::deactivationTimeout
::std::string deactivationTimeout
The deactivation timeout (an integer value representing the number of seconds to wait for deactivatio...
Definition: Descriptor.h:931
IceGrid::ServerDescriptor::ServerDescriptor
ServerDescriptor(ServerDescriptor &&)=default
IceGrid::NodeUpdateDescriptorSeq
::std::vector< NodeUpdateDescriptor > NodeUpdateDescriptorSeq
A sequence of node update descriptors.
Definition: Descriptor.h:650
IceGrid::AdapterDescriptor::ice_tuple
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
Obtains a tuple containing all of the struct's data members.
Definition: Descriptor.h:237
IceGrid::OrderedLoadBalancingPolicy::~OrderedLoadBalancingPolicy
virtual ~OrderedLoadBalancingPolicy()
IceGrid::PropertySetDescriptorDict
::std::map<::std::string, PropertySetDescriptor > PropertySetDescriptorDict
A mapping of property set name to property set descriptor.
Definition: Descriptor.h:147
IceGrid::NodeUpdateDescriptor::name
::std::string name
The name of the node to update.
Definition: Descriptor.h:597
IceGrid::RandomLoadBalancingPolicy::RandomLoadBalancingPolicy
RandomLoadBalancingPolicy()=default
IceGrid::ReplicaGroupDescriptor::filter
::std::string filter
The filter to use for this replica group.
Definition: Descriptor.h:512
IceGrid::RandomLoadBalancingPolicy::ice_staticId
static const ::std::string & ice_staticId()
Obtains the Slice type ID of this value.
IceGrid::ServerDescriptor::id
::std::string id
The server id.
Definition: Descriptor.h:892
IceGrid::ApplicationUpdateDescriptor::ice_tuple
std::tuple< const ::std::string &, const ::std::shared_ptr<::IceGrid::BoxedString > &, const ::std::shared_ptr<::IceGrid::BoxedDistributionDescriptor > &, 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
Obtains a tuple containing all of the struct's data members.
Definition: Descriptor.h:725
Config.h
IceGrid::ServiceDescriptor::entry
::std::string entry
The entry point of the IceBox service.
Definition: Descriptor.h:1007
IceGrid::CommunicatorDescriptor::CommunicatorDescriptor
CommunicatorDescriptor(const CommunicatorDescriptor &)=default
IceGrid::CommunicatorDescriptor::ice_staticId
static const ::std::string & ice_staticId()
Obtains the Slice type ID of this value.
IceGrid::ServerInstanceDescriptor::_cpp_template
::std::string _cpp_template
The template used by this instance.
Definition: Descriptor.h:334
Comparable.h
BuiltinSequences.h
IceGrid::ApplicationUpdateDescriptor
An application update descriptor to describe the updates to apply to a deployed application.
Definition: Descriptor.h:658
IceGrid::BoxedString::ice_tuple
std::tuple< const ::std::string & > ice_tuple() const
Obtains a tuple containing all of the value's data members.
Definition: Descriptor.h:1332
ScopedArray.h
IceGrid::ObjectDescriptor
An Ice object descriptor.
Definition: Descriptor.h:154
IceGrid::ApplicationDescriptor
An application descriptor.
Definition: Descriptor.h:534
IceGrid::ApplicationDescriptor::variables
::IceGrid::StringStringDict variables
The variables defined in the application descriptor.
Definition: Descriptor.h:542
IceGrid::DbEnvDescriptor::dbHome
::std::string dbHome
The home of the database environment (i.e., the directory where the database files will be stored).
Definition: Descriptor.h:268
IceGrid::ServerDescriptor::ice_staticId
static const ::std::string & ice_staticId()
Obtains the Slice type ID of this value.
IceGrid::CommunicatorDescriptor::CommunicatorDescriptor
CommunicatorDescriptor()=default
IceGrid
Definition: Admin.h:73
IceGrid::ApplicationDescriptor::ice_tuple
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
Obtains a tuple containing all of the struct's data members.
Definition: Descriptor.h:576
IceGrid::ServerDescriptor::ServerDescriptor
ServerDescriptor(const ServerDescriptor &)=default
IceGrid::ReplicaGroupDescriptor::objects
::IceGrid::ObjectDescriptorSeq objects
The object descriptors associated with this object adapter.
Definition: Descriptor.h:504
Ice::Proxy
Helper template that supplies proxy factory functions.
Definition: Proxy.h:1204
IceGrid::ServerDescriptor::operator=
ServerDescriptor & operator=(const ServerDescriptor &)=default
IceGrid::IceBoxDescriptor::ice_staticId
static const ::std::string & ice_staticId()
Obtains the Slice type ID of this value.
IceGrid::LoadBalancingPolicy
A base class for load balancing policies.
Definition: Descriptor.h:1081
Ice::Identity
The identity of an Ice object.
Definition: Identity.h:67
IceGrid::PropertySetDescriptor::references
::Ice::StringSeq references
References to named property sets.
Definition: Descriptor.h:128
Exception.h
ValueF.h
IceGrid::ServerDescriptor::pwd
::std::string pwd
The path to the server working directory.
Definition: Descriptor.h:908
IceGrid::DbEnvDescriptor::ice_tuple
std::tuple< const ::std::string &, const ::std::string &, const ::std::string &, const ::IceGrid::PropertyDescriptorSeq & > ice_tuple() const
Obtains a tuple containing all of the struct's data members.
Definition: Descriptor.h:278
IceGrid::CommunicatorDescriptor::description
::std::string description
A description of this descriptor.
Definition: Descriptor.h:811
IceGrid::LoadBalancingPolicy::~LoadBalancingPolicy
virtual ~LoadBalancingPolicy()
IceGrid::ServerDescriptor::envs
::Ice::StringSeq envs
The server environment variables.
Definition: Descriptor.h:916
IceGrid::BoxedString::BoxedString
BoxedString(const BoxedString &)=default
IceGrid::RoundRobinLoadBalancingPolicy::RoundRobinLoadBalancingPolicy
RoundRobinLoadBalancingPolicy(const ::std::string &nReplicas)
One-shot constructor to initialize all data members.
Definition: Descriptor.h:1229
IceGrid::ReplicaGroupDescriptor::ice_tuple
std::tuple< const ::std::string &, const ::std::shared_ptr<::IceGrid::LoadBalancingPolicy > &, const ::std::string &, const ::IceGrid::ObjectDescriptorSeq &, const ::std::string &, const ::std::string & > ice_tuple() const
Obtains a tuple containing all of the struct's data members.
Definition: Descriptor.h:518
IceGrid::BoxedString
A "boxed" string.
Definition: Descriptor.h:1307
IceGrid::RoundRobinLoadBalancingPolicy::RoundRobinLoadBalancingPolicy
RoundRobinLoadBalancingPolicy()=default
IceGrid::ApplicationUpdateDescriptor::nodes
::IceGrid::NodeUpdateDescriptorSeq nodes
The application nodes to update.
Definition: Descriptor.h:715
IceGrid::AdaptiveLoadBalancingPolicy::ice_staticId
static const ::std::string & ice_staticId()
Obtains the Slice type ID of this value.
IceGrid::RoundRobinLoadBalancingPolicy
Round robin load balancing policy.
Definition: Descriptor.h:1213
IceGrid::IceBoxDescriptor::IceBoxDescriptor
IceBoxDescriptor(const ::IceGrid::AdapterDescriptorSeq &adapters, const ::IceGrid::PropertySetDescriptor &propertySet, const ::IceGrid::DbEnvDescriptorSeq &dbEnvs, const ::Ice::StringSeq &logs, const ::std::string &description, const ::std::string &id, const ::std::string &exe, const ::std::string &iceVersion, const ::std::string &pwd, const ::Ice::StringSeq &options, const ::Ice::StringSeq &envs, const ::std::string &activation, const ::std::string &activationTimeout, const ::std::string &deactivationTimeout, bool applicationDistrib, const ::IceGrid::DistributionDescriptor &distrib, bool allocatable, const ::std::string &user, const ::IceGrid::ServiceInstanceDescriptorSeq &services)
One-shot constructor to initialize all data members.
Definition: Descriptor.h:1049
IceGrid::ServerDescriptor
An Ice server descriptor.
Definition: Descriptor.h:823
IceGrid::AdapterDescriptor::replicaGroupId
::std::string replicaGroupId
The replica id of this adapter.
Definition: Descriptor.h:206
IceGrid::ServiceDescriptor
An IceBox service descriptor.
Definition: Descriptor.h:956
Value.h
IceGrid::ReplicaGroupDescriptorSeq
::std::vector< ReplicaGroupDescriptor > ReplicaGroupDescriptorSeq
A sequence of replica groups.
Definition: Descriptor.h:527
IceGrid::TemplateDescriptor::descriptor
::std::shared_ptr<::IceGrid::CommunicatorDescriptor > descriptor
The template.
Definition: Descriptor.h:373
IceGrid::CommunicatorDescriptor::adapters
::IceGrid::AdapterDescriptorSeq adapters
The object adapters.
Definition: Descriptor.h:795
IceGrid::ApplicationDescriptor::serverTemplates
::IceGrid::TemplateDescriptorDict serverTemplates
The server templates.
Definition: Descriptor.h:550
IceGrid::ServerInstanceDescriptor
A server template instance descriptor.
Definition: Descriptor.h:330
IceGrid::BoxedDistributionDescriptor::BoxedDistributionDescriptor
BoxedDistributionDescriptor(const ::IceGrid::DistributionDescriptor &value)
One-shot constructor to initialize all data members.
Definition: Descriptor.h:1370
IceGrid::ApplicationDescriptor::name
::std::string name
The application name.
Definition: Descriptor.h:538
IceGrid::IceBoxDescriptor
An IceBox server descriptor.
Definition: Descriptor.h:1015
IceGrid::DbEnvDescriptor::description
::std::string description
The description of this database environment.
Definition: Descriptor.h:261
PopDisableWarnings.h
Generated by doxygen 1.8.20