Implementation of enhancements described in

    http://bugzilla.zeroc.com/bugzilla/show_bug.cgi?id=1597

3 files changed, 690 insertions, 602 deletions

diff --git a/cpp/src/Ice/PropertiesI.cpp b/cpp/src/Ice/PropertiesI.cpp
index 770f7064b57..09d38acc992 100644
--- a/cpp/src/Ice/PropertiesI.cpp
+++ b/cpp/src/Ice/PropertiesI.cpp
@@ -111,14 +111,24 @@ Ice::PropertiesI::setProperty(const string& key, const string& value)
     //
     LoggerPtr logger = getProcessLogger();
     string::size_type dotPos = key.find('.');
+    string currentKey = key;
     if(dotPos != string::npos)
     {
-        string prefix = key.substr(0, dotPos);
-        for(const char* const** i = IceInternal::PropertyNames::validProps; *i != 0; ++i)
+        string prefix = currentKey.substr(0, dotPos);
+        for(int i = 0 ; IceInternal::PropertyNames::validProps[i].properties != 0; ++i)
         {
-            string pattern(*i[0]);
+            string pattern(IceInternal::PropertyNames::validProps[i].properties[0].pattern);
+            
+	    
             dotPos = pattern.find('.');
+
+	    //
+	    // Each top level prefix describes a non-empty
+	    // namespace. Having a string without a prefix followed by a
+	    // dot is an error.
+	    //
             assert(dotPos != string::npos);
+	    
             string propPrefix = pattern.substr(0, dotPos);
             if(propPrefix != prefix)
             {
@@ -126,13 +136,24 @@ Ice::PropertiesI::setProperty(const string& key, const string& value)
             }
 
             bool found = false;
-            for(const char* const* j = *i; *j != 0 && !found; ++j)
+
+            for(int j = 0; j < IceInternal::PropertyNames::validProps[i].length && !found; ++j)
             {
-                found = IceUtil::match(key, *j);
+                const IceInternal::Property& prop = IceInternal::PropertyNames::validProps[i].properties[j];
+                found = IceUtil::match(currentKey, prop.pattern);
+
+                if(found && prop.deprecated)
+                {
+                    logger->warning("deprecated property: " + currentKey);
+                    if(prop.deprecatedBy != 0)
+                    {
+                        currentKey = prop.deprecatedBy;
+                    }
+                }
             }
             if(!found)
             {
-                logger->warning("unknown property: " + key);
+                logger->warning("unknown property: " + currentKey);
             }
         }
     }
@@ -145,16 +166,16 @@ Ice::PropertiesI::setProperty(const string& key, const string& value)
     if(!value.empty())
     {
         PropertyValue pv(value, false);
-        map<string, PropertyValue>::const_iterator p = _properties.find(key);
+        map<string, PropertyValue>::const_iterator p = _properties.find(currentKey);
         if(p != _properties.end())
         {
             pv.used = p->second.used;
         }
-        _properties[key] = pv;
+        _properties[currentKey] = pv;
     }
     else
     {
-        _properties.erase(key);
+        _properties.erase(currentKey);
     }
 }
 
diff --git a/cpp/src/Ice/PropertyNames.cpp b/cpp/src/Ice/PropertyNames.cpp
index 20b4b620765..5f38f8f6701 100644
--- a/cpp/src/Ice/PropertyNames.cpp
+++ b/cpp/src/Ice/PropertyNames.cpp
@@ -1,551 +1,583 @@
-// **********************************************************************
-//
-// Copyright (c) 2003-2007 ZeroC, Inc. All rights reserved.
-//
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
-
-// Generated by makeprops.py from file `../config/PropertyNames.def', Wed May 23 14:21:55 2007
-
-// IMPORTANT: Do not edit this file -- any edits made here will be lost!
-
-#include <Ice/PropertyNames.h>
-
-const char* IceInternal::PropertyNames::IceProps[] =
-{
-    "Ice.ACM.Client",
-    "Ice.ACM.Server",
-    "Ice.BatchAutoFlush",
-    "Ice.ChangeUser",
-    "Ice.Compression.Level",
-    "Ice.Config",
-    "Ice.Default.CollocationOptimization",
-    "Ice.Default.EndpointSelection",
-    "Ice.Default.Host",
-    "Ice.Default.Locator",
-    "Ice.Default.Locator.EndpointSelection",
-    "Ice.Default.Locator.ConnectionCached",
-    "Ice.Default.Locator.PreferSecure",
-    "Ice.Default.Locator.LocatorCacheTimeout",
-    "Ice.Default.Locator.Locator",
-    "Ice.Default.Locator.Router",
-    "Ice.Default.Locator.CollocationOptimization",
-    "Ice.Default.Locator.ThreadPerConnection",
-    "Ice.Default.LocatorCacheTimeout",
-    "Ice.Default.Package",
-    "Ice.Default.PreferSecure",
-    "Ice.Default.Protocol",
-    "Ice.Default.Router",
-    "Ice.Default.Router.EndpointSelection",
-    "Ice.Default.Router.ConnectionCached",
-    "Ice.Default.Router.PreferSecure",
-    "Ice.Default.Router.LocatorCacheTimeout",
-    "Ice.Default.Router.Locator",
-    "Ice.Default.Router.Router",
-    "Ice.Default.Router.CollocationOptimization",
-    "Ice.Default.Router.ThreadPerConnection",
-    "Ice.GC.Interval",
-    "Ice.ImplicitContext",
-    "Ice.InitPlugins",
-    "Ice.LoggerPlugin",
-    "Ice.MessageSizeMax",
-    "Ice.MonitorConnections",
-    "Ice.Nohup",
-    "Ice.NullHandleAbort",
-    "Ice.Override.Compress",
-    "Ice.Override.ConnectTimeout",
-    "Ice.Override.Timeout",
-    "Ice.Override.Secure",
-    "Ice.Package.*",
-    "Ice.Plugin.*",
-    "Ice.PluginLoadOrder",
-    "Ice.PrintAdapterReady",
-    "Ice.PrintProcessId",
-    "Ice.ProgramName",
-    "Ice.RetryIntervals",
-    "Ice.ServerId",
-    "Ice.ServerIdleTime",
-    "Ice.StdErr",
-    "Ice.StdOut",
-    "Ice.ThreadPerConnection",
-    "Ice.ThreadPerConnection.StackSize",
-    "Ice.ThreadPool.Client.Size",
-    "Ice.ThreadPool.Client.SizeMax",
-    "Ice.ThreadPool.Client.SizeWarn",
-    "Ice.ThreadPool.Client.StackSize",
-    "Ice.ThreadPool.Server.Size",
-    "Ice.ThreadPool.Server.SizeMax",
-    "Ice.ThreadPool.Server.SizeWarn",
-    "Ice.ThreadPool.Server.StackSize",
-    "Ice.Trace.GC",
-    "Ice.Trace.Location",
-    "Ice.Trace.Network",
-    "Ice.Trace.Protocol",
-    "Ice.Trace.Retry",
-    "Ice.Trace.Slicing",
-    "Ice.UDP.RcvSize",
-    "Ice.UDP.SndSize",
-    "Ice.TCP.RcvSize",
-    "Ice.TCP.SndSize",
-    "Ice.UseEventLog",
-    "Ice.UseSyslog",
-    "Ice.Warn.AMICallback",
-    "Ice.Warn.Connections",
-    "Ice.Warn.Datagrams",
-    "Ice.Warn.Dispatch",
-    "Ice.Warn.Endpoints",
-    "Ice.Warn.UnknownProperties",
-    "Ice.Warn.UnusedProperties",
-    "Ice.CacheMessageBuffers",
-    0
-};
-
-const char* IceInternal::PropertyNames::IceBoxProps[] =
-{
-    "IceBox.InstanceName",
-    "IceBox.LoadOrder",
-    "IceBox.PrintServicesReady",
-    "IceBox.Service.*",
-    "IceBox.ServiceManager.AdapterId",
-    "IceBox.ServiceManager.Endpoints",
-    "IceBox.ServiceManager.Locator",
-    "IceBox.ServiceManager.PublishedEndpoints",
-    "IceBox.ServiceManager.RegisterProcess",
-    "IceBox.ServiceManager.ReplicaGroupId",
-    "IceBox.ServiceManager.Router",
-    "IceBox.ServiceManager.ThreadPerConnection",
-    "IceBox.ServiceManager.ThreadPerConnection.StackSize",
-    "IceBox.ServiceManager.ThreadPool.Size",
-    "IceBox.ServiceManager.ThreadPool.SizeMax",
-    "IceBox.ServiceManager.ThreadPool.SizeWarn",
-    "IceBox.ServiceManager.ThreadPool.StackSize",
-    "IceBox.UseSharedCommunicator.*",
-    "IceBox.InheritProperties",
-    0
-};
-
-const char* IceInternal::PropertyNames::IceGridAdminProps[] =
-{
-    "IceGridAdmin.AuthenticateUsingSSL",
-    "IceGridAdmin.Username",
-    "IceGridAdmin.Password",
-    "IceGridAdmin.Replica",
-    "IceGridAdmin.Trace.Observers",
-    "IceGridAdmin.Trace.SaveToRegistry",
-    0
-};
-
-const char* IceInternal::PropertyNames::IceGridProps[] =
-{
-    "IceGrid.InstanceName",
-    "IceGrid.Node.AdapterId",
-    "IceGrid.Node.CollocateRegistry",
-    "IceGrid.Node.Data",
-    "IceGrid.Node.DisableOnFailure",
-    "IceGrid.Node.Endpoints",
-    "IceGrid.Node.Locator",
-    "IceGrid.Node.Name",
-    "IceGrid.Node.Output",
-    "IceGrid.Node.PrintServersReady",
-    "IceGrid.Node.PropertiesOverride",
-    "IceGrid.Node.PublishedEndpoints",
-    "IceGrid.Node.RedirectErrToOut",
-    "IceGrid.Node.RegisterProcess",
-    "IceGrid.Node.ReplicaGroupId",
-    "IceGrid.Node.Router",
-    "IceGrid.Node.ThreadPerConnection",
-    "IceGrid.Node.ThreadPerConnection.StackSize",
-    "IceGrid.Node.ThreadPool.Size",
-    "IceGrid.Node.ThreadPool.SizeMax",
-    "IceGrid.Node.ThreadPool.SizeWarn",
-    "IceGrid.Node.ThreadPool.StackSize",
-    "IceGrid.Node.Trace.Activator",
-    "IceGrid.Node.Trace.Adapter",
-    "IceGrid.Node.Trace.Patch",
-    "IceGrid.Node.Trace.Replica",
-    "IceGrid.Node.Trace.Server",
-    "IceGrid.Node.UserAccounts",
-    "IceGrid.Node.UserAccountMapper",
-    "IceGrid.Node.UserAccountMapper.EndpointSelection",
-    "IceGrid.Node.UserAccountMapper.ConnectionCached",
-    "IceGrid.Node.UserAccountMapper.PreferSecure",
-    "IceGrid.Node.UserAccountMapper.LocatorCacheTimeout",
-    "IceGrid.Node.UserAccountMapper.Locator",
-    "IceGrid.Node.UserAccountMapper.Router",
-    "IceGrid.Node.UserAccountMapper.CollocationOptimization",
-    "IceGrid.Node.UserAccountMapper.ThreadPerConnection",
-    "IceGrid.Node.WaitTime",
-    "IceGrid.Registry.AdminCryptPasswords",
-    "IceGrid.Registry.AdminPermissionsVerifier",
-    "IceGrid.Registry.AdminPermissionsVerifier.EndpointSelection",
-    "IceGrid.Registry.AdminPermissionsVerifier.ConnectionCached",
-    "IceGrid.Registry.AdminPermissionsVerifier.PreferSecure",
-    "IceGrid.Registry.AdminPermissionsVerifier.LocatorCacheTimeout",
-    "IceGrid.Registry.AdminPermissionsVerifier.Locator",
-    "IceGrid.Registry.AdminPermissionsVerifier.Router",
-    "IceGrid.Registry.AdminPermissionsVerifier.CollocationOptimization",
-    "IceGrid.Registry.AdminPermissionsVerifier.ThreadPerConnection",
-    "IceGrid.Registry.AdminSSLPermissionsVerifier",
-    "IceGrid.Registry.AdminSSLPermissionsVerifier.EndpointSelection",
-    "IceGrid.Registry.AdminSSLPermissionsVerifier.ConnectionCached",
-    "IceGrid.Registry.AdminSSLPermissionsVerifier.PreferSecure",
-    "IceGrid.Registry.AdminSSLPermissionsVerifier.LocatorCacheTimeout",
-    "IceGrid.Registry.AdminSSLPermissionsVerifier.Locator",
-    "IceGrid.Registry.AdminSSLPermissionsVerifier.Router",
-    "IceGrid.Registry.AdminSSLPermissionsVerifier.CollocationOptimization",
-    "IceGrid.Registry.AdminSSLPermissionsVerifier.ThreadPerConnection",
-    "IceGrid.Registry.Client.AdapterId",
-    "IceGrid.Registry.Client.Endpoints",
-    "IceGrid.Registry.Client.Locator",
-    "IceGrid.Registry.Client.PublishedEndpoints",
-    "IceGrid.Registry.Client.RegisterProcess",
-    "IceGrid.Registry.Client.ReplicaGroupId",
-    "IceGrid.Registry.Client.Router",
-    "IceGrid.Registry.Client.ThreadPerConnection",
-    "IceGrid.Registry.Client.ThreadPerConnection.StackSize",
-    "IceGrid.Registry.Client.ThreadPool.Size",
-    "IceGrid.Registry.Client.ThreadPool.SizeMax",
-    "IceGrid.Registry.Client.ThreadPool.SizeWarn",
-    "IceGrid.Registry.Client.ThreadPool.StackSize",
-    "IceGrid.Registry.CryptPasswords",
-    "IceGrid.Registry.Data",
-    "IceGrid.Registry.DefaultTemplates",
-    "IceGrid.Registry.DynamicRegistration",
-    "IceGrid.Registry.Internal.AdapterId",
-    "IceGrid.Registry.Internal.Endpoints",
-    "IceGrid.Registry.Internal.Locator",
-    "IceGrid.Registry.Internal.PublishedEndpoints",
-    "IceGrid.Register.Internal.RegisterProcess",
-    "IceGrid.Registry.Internal.ReplicaGroupId",
-    "IceGrid.Registry.Internal.Router",
-    "IceGrid.Registry.Internal.ThreadPerConnection",
-    "IceGrid.Registry.Internal.ThreadPerConnection.StackSize",
-    "IceGrid.Registry.Internal.ThreadPool.Size",
-    "IceGrid.Registry.Internal.ThreadPool.SizeMax",
-    "IceGrid.Registry.Internal.ThreadPool.SizeWarn",
-    "IceGrid.Registry.Internal.ThreadPool.StackSize",
-    "IceGrid.Registry.NodeSessionTimeout",
-    "IceGrid.Registry.PermissionsVerifier",
-    "IceGrid.Registry.PermissionsVerifier.EndpointSelection",
-    "IceGrid.Registry.PermissionsVerifier.ConnectionCached",
-    "IceGrid.Registry.PermissionsVerifier.PreferSecure",
-    "IceGrid.Registry.PermissionsVerifier.LocatorCacheTimeout",
-    "IceGrid.Registry.PermissionsVerifier.Locator",
-    "IceGrid.Registry.PermissionsVerifier.Router",
-    "IceGrid.Registry.PermissionsVerifier.CollocationOptimization",
-    "IceGrid.Registry.PermissionsVerifier.ThreadPerConnection",
-    "IceGrid.Registry.ReplicaName",
-    "IceGrid.Registry.ReplicaSessionTimeout",
-    "IceGrid.Registry.Server.AdapterId",
-    "IceGrid.Registry.Server.Endpoints",
-    "IceGrid.Registry.Server.Locator",
-    "IceGrid.Registry.Server.PublishedEndpoints",
-    "IceGrid.Registry.Server.RegisterProcess",
-    "IceGrid.Registry.Server.ReplicaGroupId",
-    "IceGrid.Registry.Server.Router",
-    "IceGrid.Registry.Server.ThreadPerConnection",
-    "IceGrid.Registry.Server.ThreadPerConnection.StackSize",
-    "IceGrid.Registry.Server.ThreadPool.Size",
-    "IceGrid.Registry.Server.ThreadPool.SizeMax",
-    "IceGrid.Registry.Server.ThreadPool.SizeWarn",
-    "IceGrid.Registry.Server.ThreadPool.StackSize",
-    "IceGrid.Registry.SessionManager.AdapterId",
-    "IceGrid.Registry.SessionManager.Endpoints",
-    "IceGrid.Registry.SessionManager.Locator",
-    "IceGrid.Registry.SessionManager.PublishedEndpoints",
-    "IceGrid.Registry.SessionManager.RegisterProcess",
-    "IceGrid.Registry.SessionManager.ReplicaGroupId",
-    "IceGrid.Registry.SessionManager.Router",
-    "IceGrid.Registry.SessionManager.ThreadPerConnection",
-    "IceGrid.Registry.SessionManager.ThreadPerConnection.StackSize",
-    "IceGrid.Registry.SessionManager.ThreadPool.Size",
-    "IceGrid.Registry.SessionManager.ThreadPool.SizeMax",
-    "IceGrid.Registry.SessionManager.ThreadPool.SizeWarn",
-    "IceGrid.Registry.SessionManager.ThreadPool.StackSize",
-    "IceGrid.Registry.SessionTimeout",
-    "IceGrid.Registry.SSLPermissionsVerifier",
-    "IceGrid.Registry.SSLPermissionsVerifier.EndpointSelection",
-    "IceGrid.Registry.SSLPermissionsVerifier.ConnectionCached",
-    "IceGrid.Registry.SSLPermissionsVerifier.PreferSecure",
-    "IceGrid.Registry.SSLPermissionsVerifier.LocatorCacheTimeout",
-    "IceGrid.Registry.SSLPermissionsVerifier.Locator",
-    "IceGrid.Registry.SSLPermissionsVerifier.Router",
-    "IceGrid.Registry.SSLPermissionsVerifier.CollocationOptimization",
-    "IceGrid.Registry.SSLPermissionsVerifier.ThreadPerConnection",
-    "IceGrid.Registry.Trace.Application",
-    "IceGrid.Registry.Trace.Adapter",
-    "IceGrid.Registry.Trace.Locator",
-    "IceGrid.Registry.Trace.Node",
-    "IceGrid.Registry.Trace.Object",
-    "IceGrid.Registry.Trace.Patch",
-    "IceGrid.Registry.Trace.Replica",
-    "IceGrid.Registry.Trace.Server",
-    "IceGrid.Registry.Trace.Session",
-    "IceGrid.Registry.UserAccounts",
-    0
-};
-
-const char* IceInternal::PropertyNames::IcePatch2Props[] =
-{
-    "IcePatch2.AdapterId",
-    "IcePatch2.Admin.AdapterId",
-    "IcePatch2.Admin.Endpoints",
-    "IcePatch2.Admin.Locator",
-    "IcePatch2.Admin.PublishedEndpoints",
-    "IcePatch2.Admin.RegisterProcess",
-    "IcePatch2.Admin.ReplicaGroupId",
-    "IcePatch2.Admin.Router",
-    "IcePatch2.Admin.ThreadPerConnection",
-    "IcePatch2.Admin.ThreadPerConnection.StackSize",
-    "IcePatch2.Admin.ThreadPool.Size",
-    "IcePatch2.Admin.ThreadPool.SizeMax",
-    "IcePatch2.Admin.ThreadPool.SizeWarn",
-    "IcePatch2.Admin.ThreadPool.StackSize",
-    "IcePatch2.ChunkSize",
-    "IcePatch2.Directory",
-    "IcePatch2.Endpoints",
-    "IcePatch2.InstanceName",
-    "IcePatch2.Locator",
-    "IcePatch2.PublishedEndpoints",
-    "IcePatch2.RegisterProcess",
-    "IcePatch2.ReplicaGroupId",
-    "IcePatch2.Remove",
-    "IcePatch2.Router",
-    "IcePatch2.Thorough",
-    "IcePatch2.ThreadPerConnection",
-    "IcePatch2.ThreadPerConnection.StackSize",
-    "IcePatch2.ThreadPool.Size",
-    "IcePatch2.ThreadPool.SizeMax",
-    "IcePatch2.ThreadPool.SizeWarn",
-    "IcePatch2.ThreadPool.StackSize",
-    0
-};
-
-const char* IceInternal::PropertyNames::IceSSLProps[] =
-{
-    "IceSSL.Alias",
-    "IceSSL.CertAuthDir",
-    "IceSSL.CertAuthFile",
-    "IceSSL.CertFile",
-    "IceSSL.CheckCertName",
-    "IceSSL.CheckCRL",
-    "IceSSL.Ciphers",
-    "IceSSL.DefaultDir",
-    "IceSSL.DH.*",
-    "IceSSL.EntropyDaemon",
-    "IceSSL.FindCert.*",
-    "IceSSL.ImportCert.*",
-    "IceSSL.KeyFile",
-    "IceSSL.Keystore",
-    "IceSSL.KeystorePassword",
-    "IceSSL.KeystoreType",
-    "IceSSL.Password",
-    "IceSSL.PasswordRetryMax",
-    "IceSSL.Protocols",
-    "IceSSL.Random",
-    "IceSSL.Trace.Security",
-    "IceSSL.Truststore",
-    "IceSSL.TruststorePassword",
-    "IceSSL.TruststoreType",
-    "IceSSL.VerifyDepthMax",
-    "IceSSL.VerifyPeer",
-    "IceSSL.TrustOnly",
-    "IceSSL.TrustOnly.Client",
-    "IceSSL.TrustOnly.Server",
-    "IceSSL.TrustOnly.Server.*",
-    0
-};
-
-const char* IceInternal::PropertyNames::IceStormAdminProps[] =
-{
-    "IceStormAdmin.TopicManager.*",
-    0
-};
-
-const char* IceInternal::PropertyNames::IceStormProps[] =
-{
-    "IceStorm.Flush.Timeout",
-    "IceStorm.InstanceName",
-    "IceStorm.Publish.AdapterId",
-    "IceStorm.Publish.Endpoints",
-    "IceStorm.Publish.Locator",
-    "IceStorm.Publish.PublishedEndpoints",
-    "IceStorm.Publish.RegisterProcess",
-    "IceStorm.Publish.ReplicaGroupId",
-    "IceStorm.Publish.Router",
-    "IceStorm.Publish.ThreadPerConnection",
-    "IceStorm.Publish.ThreadPerConnection.StackSize",
-    "IceStorm.Publish.ThreadPool.Size",
-    "IceStorm.Publish.ThreadPool.SizeMax",
-    "IceStorm.Publish.ThreadPool.SizeWarn",
-    "IceStorm.Publish.ThreadPool.StackSize",
-    "IceStorm.TopicManager.AdapterId",
-    "IceStorm.TopicManager.Endpoints",
-    "IceStorm.TopicManager.Locator",
-    "IceStorm.TopicManager.Proxy",
-    "IceStorm.TopicManager.Proxy.EndpointSelection",
-    "IceStorm.TopicManager.Proxy.ConnectionCached",
-    "IceStorm.TopicManager.Proxy.PreferSecure",
-    "IceStorm.TopicManager.Proxy.LocatorCacheTimeout",
-    "IceStorm.TopicManager.Proxy.Locator",
-    "IceStorm.TopicManager.Proxy.Router",
-    "IceStorm.TopicManager.Proxy.CollocationOptimization",
-    "IceStorm.TopicManager.Proxy.ThreadPerConnection",
-    "IceStorm.TopicManager.PublishedEndpoints",
-    "IceStorm.TopicManager.RegisterProcess",
-    "IceStorm.TopicManager.ReplicaGroupId",
-    "IceStorm.TopicManager.Router",
-    "IceStorm.TopicManager.ThreadPerConnection",
-    "IceStorm.TopicManager.ThreadPerConnection.StackSize",
-    "IceStorm.TopicManager.ThreadPool.Size",
-    "IceStorm.TopicManager.ThreadPool.SizeMax",
-    "IceStorm.TopicManager.ThreadPool.SizeWarn",
-    "IceStorm.TopicManager.ThreadPool.StackSize",
-    "IceStorm.SubscriberPool.Size",
-    "IceStorm.SubscriberPool.SizeMax",
-    "IceStorm.SubscriberPool.SizeWarn",
-    "IceStorm.SubscriberPool.Timeout",
-    "IceStorm.Trace.Flush",
-    "IceStorm.Trace.Subscriber",
-    "IceStorm.Trace.SubscriberPool",
-    "IceStorm.Trace.Topic",
-    "IceStorm.Trace.TopicManager",
-    "IceStorm.Send.Timeout",
-    "IceStorm.Discard.Interval",
-    0
-};
-
-const char* IceInternal::PropertyNames::Glacier2Props[] =
-{
-    "Glacier2.AddSSLContext",
-    "Glacier2.AddUserToAllowCategories",
-    "Glacier2.Admin.Endpoints",
-    "Glacier2.Admin.PublishedEndpoints",
-    "Glacier2.Admin.RegisterProcess",
-    "Glacier2.AllowCategories",
-    "Glacier2.Client.AlwaysBatch",
-    "Glacier2.Client.Buffered",
-    "Glacier2.Client.Endpoints",
-    "Glacier2.Client.ForwardContext",
-    "Glacier2.Client.PublishedEndpoints",
-    "Glacier2.Client.RegisterProcess",
-    "Glacier2.Client.SleepTime",
-    "Glacier2.Client.Trace.Override",
-    "Glacier2.Client.Trace.Reject",
-    "Glacier2.Client.Trace.Request",
-    "Glacier2.Filter.Address.Reject",
-    "Glacier2.Filter.Address.Accept",
-    "Glacier2.Filter.ProxySizeMax",
-    "Glacier2.Filter.Category.Accept",
-    "Glacier2.Filter.Category.AcceptUser",
-    "Glacier2.Filter.AdapterId.Accept",
-    "Glacier2.Filter.Identity.Accept",
-    "Glacier2.CryptPasswords",
-    "Glacier2.InstanceName",
-    "Glacier2.PermissionsVerifier",
-    "Glacier2.PermissionsVerifier.EndpointSelection",
-    "Glacier2.PermissionsVerifier.ConnectionCached",
-    "Glacier2.PermissionsVerifier.PreferSecure",
-    "Glacier2.PermissionsVerifier.LocatorCacheTimeout",
-    "Glacier2.PermissionsVerifier.Locator",
-    "Glacier2.PermissionsVerifier.Router",
-    "Glacier2.PermissionsVerifier.CollocationOptimization",
-    "Glacier2.PermissionsVerifier.ThreadPerConnection",
-    "Glacier2.ReturnClientProxy",
-    "Glacier2.SSLPermissionsVerifier",
-    "Glacier2.SSLPermissionsVerifier.EndpointSelection",
-    "Glacier2.SSLPermissionsVerifier.ConnectionCached",
-    "Glacier2.SSLPermissionsVerifier.PreferSecure",
-    "Glacier2.SSLPermissionsVerifier.LocatorCacheTimeout",
-    "Glacier2.SSLPermissionsVerifier.Locator",
-    "Glacier2.SSLPermissionsVerifier.Router",
-    "Glacier2.SSLPermissionsVerifier.CollocationOptimization",
-    "Glacier2.SSLPermissionsVerifier.ThreadPerConnection",
-    "Glacier2.RoutingTable.MaxSize",
-    "Glacier2.Server.AlwaysBatch",
-    "Glacier2.Server.Buffered",
-    "Glacier2.Server.Endpoints",
-    "Glacier2.Server.ForwardContext",
-    "Glacier2.Server.PublishedEndpoints",
-    "Glacier2.Server.RegisterProcess",
-    "Glacier2.Server.SleepTime",
-    "Glacier2.Server.Trace.Override",
-    "Glacier2.Server.Trace.Request",
-    "Glacier2.SessionManager",
-    "Glacier2.SessionManager.EndpointSelection",
-    "Glacier2.SessionManager.ConnectionCached",
-    "Glacier2.SessionManager.PreferSecure",
-    "Glacier2.SessionManager.LocatorCacheTimeout",
-    "Glacier2.SessionManager.Locator",
-    "Glacier2.SessionManager.Router",
-    "Glacier2.SessionManager.CollocationOptimization",
-    "Glacier2.SessionManager.ThreadPerConnection",
-    "Glacier2.SSLSessionManager",
-    "Glacier2.SSLSessionManager.EndpointSelection",
-    "Glacier2.SSLSessionManager.ConnectionCached",
-    "Glacier2.SSLSessionManager.PreferSecure",
-    "Glacier2.SSLSessionManager.LocatorCacheTimeout",
-    "Glacier2.SSLSessionManager.Locator",
-    "Glacier2.SSLSessionManager.Router",
-    "Glacier2.SSLSessionManager.CollocationOptimization",
-    "Glacier2.SSLSessionManager.ThreadPerConnection",
-    "Glacier2.SessionTimeout",
-    "Glacier2.Trace.RoutingTable",
-    "Glacier2.Trace.Session",
-    0
-};
-
-const char* IceInternal::PropertyNames::FreezeProps[] =
-{
-    "Freeze.DbEnv.*.CheckpointPeriod",
-    "Freeze.DbEnv.*.DbHome",
-    "Freeze.DbEnv.*.DbPrivate",
-    "Freeze.DbEnv.*.DbRecoverFatal",
-    "Freeze.DbEnv.*.OldLogsAutoDelete",
-    "Freeze.DbEnv.*.PeriodicCheckpointMinSize",
-    "Freeze.Evictor.*.MaxTxSize",
-    "Freeze.Evictor.*.SavePeriod",
-    "Freeze.Evictor.*.SaveSizeTrigger",
-    "Freeze.Evictor.*.StreamTimeout",
-    "Freeze.Evictor.*.PopulateEmptyIndices",
-    "Freeze.Evictor.UseNonmutating",
-    "Freeze.Trace.DbEnv",
-    "Freeze.Trace.Evictor",
-    "Freeze.Trace.Map",
-    "Freeze.Trace.Transaction",
-    "Freeze.Warn.CloseInFinalize",
-    "Freeze.Warn.Deadlocks",
-    0
-};
-
-const char* const* IceInternal::PropertyNames::validProps[] =
-{
-    IcePatch2Props,
-    IceStormProps,
-    IceGridAdminProps,
-    IceSSLProps,
-    IceProps,
-    FreezeProps,
-    IceGridProps,
-    Glacier2Props,
-    IceStormAdminProps,
-    IceBoxProps,
-    0
-};
-
-const char* IceInternal::PropertyNames::clPropNames[] =
-{
-    "Ice",
-    "IceBox",
-    "IceGridAdmin",
-    "IceGrid",
-    "IcePatch2",
-    "IceSSL",
-    "IceStormAdmin",
-    "IceStorm",
-    "Glacier2",
-    "Freeze",
-    0
-};
+// **********************************************************************

+//

+// Copyright (c) 2003-2007 ZeroC, Inc. All rights reserved.

+//

+// This copy of Ice is licensed to you under the terms described in the

+// ICE_LICENSE file included in this distribution.

+//

+// **********************************************************************

+

+// Generated by makeprops.py from file XXX- stuff needs to go here!

+

+// IMPORTANT: Do not edit this file -- any edits made here will be lost!

+

+#include <Ice/PropertyNames.h>

+

+const IceInternal::Property IcePropsData[] = 

+{

+    IceInternal::Property("Ice.ACM.Client", false, 0),

+    IceInternal::Property("Ice.ACM.Server", false, 0),

+    IceInternal::Property("Ice.BatchAutoFlush", false, 0),

+    IceInternal::Property("Ice.ChangeUser", false, 0),

+    IceInternal::Property("Ice.Compression.Level", false, 0),

+    IceInternal::Property("Ice.Config", false, 0),

+    IceInternal::Property("Ice.Default.CollocationOptimization", false, 0),

+    IceInternal::Property("Ice.Default.EndpointSelection", false, 0),

+    IceInternal::Property("Ice.Default.Host", false, 0),

+    IceInternal::Property("Ice.Default.Locator", false, 0),

+    IceInternal::Property("Ice.Default.Locator.EndpointSelection", false, 0),

+    IceInternal::Property("Ice.Default.Locator.ConnectionCached", false, 0),

+    IceInternal::Property("Ice.Default.Locator.PreferSecure", false, 0),

+    IceInternal::Property("Ice.Default.Locator.LocatorCacheTimeout", false, 0),

+    IceInternal::Property("Ice.Default.Locator.Locator", false, 0),

+    IceInternal::Property("Ice.Default.Locator.Router", false, 0),

+    IceInternal::Property("Ice.Default.Locator.CollocationOptimization", false, 0),

+    IceInternal::Property("Ice.Default.Locator.ThreadPerConnection", false, 0),

+    IceInternal::Property("Ice.Default.LocatorCacheTimeout", false, 0),

+    IceInternal::Property("Ice.Default.Package", false, 0),

+    IceInternal::Property("Ice.Default.PreferSecure", false, 0),

+    IceInternal::Property("Ice.Default.Protocol", false, 0),

+    IceInternal::Property("Ice.Default.Router", false, 0),

+    IceInternal::Property("Ice.Default.Router.EndpointSelection", false, 0),

+    IceInternal::Property("Ice.Default.Router.ConnectionCached", false, 0),

+    IceInternal::Property("Ice.Default.Router.PreferSecure", false, 0),

+    IceInternal::Property("Ice.Default.Router.LocatorCacheTimeout", false, 0),

+    IceInternal::Property("Ice.Default.Router.Locator", false, 0),

+    IceInternal::Property("Ice.Default.Router.Router", false, 0),

+    IceInternal::Property("Ice.Default.Router.CollocationOptimization", false, 0),

+    IceInternal::Property("Ice.Default.Router.ThreadPerConnection", false, 0),

+    IceInternal::Property("Ice.GC.Interval", false, 0),

+    IceInternal::Property("Ice.ImplicitContext", false, 0),

+    IceInternal::Property("Ice.InitPlugins", false, 0),

+    IceInternal::Property("Ice.LoggerPlugin", false, 0),

+    IceInternal::Property("Ice.MessageSizeMax", false, 0),

+    IceInternal::Property("Ice.MonitorConnections", false, 0),

+    IceInternal::Property("Ice.Nohup", false, 0),

+    IceInternal::Property("Ice.NullHandleAbort", false, 0),

+    IceInternal::Property("Ice.Override.Compress", false, 0),

+    IceInternal::Property("Ice.Override.ConnectTimeout", false, 0),

+    IceInternal::Property("Ice.Override.Timeout", false, 0),

+    IceInternal::Property("Ice.Override.Secure", false, 0),

+    IceInternal::Property("Ice.Package.*", false, 0),

+    IceInternal::Property("Ice.Plugin.*", false, 0),

+    IceInternal::Property("Ice.PluginLoadOrder", false, 0),

+    IceInternal::Property("Ice.PrintAdapterReady", false, 0),

+    IceInternal::Property("Ice.PrintProcessId", false, 0),

+    IceInternal::Property("Ice.ProgramName", false, 0),

+    IceInternal::Property("Ice.RetryIntervals", false, 0),

+    IceInternal::Property("Ice.ServerId", false, 0),

+    IceInternal::Property("Ice.ServerIdleTime", false, 0),

+    IceInternal::Property("Ice.StdErr", false, 0),

+    IceInternal::Property("Ice.StdOut", false, 0),

+    IceInternal::Property("Ice.ThreadPerConnection", false, 0),

+    IceInternal::Property("Ice.ThreadPerConnection.StackSize", false, 0),

+    IceInternal::Property("Ice.ThreadPool.Client.Size", false, 0),

+    IceInternal::Property("Ice.ThreadPool.Client.SizeMax", false, 0),

+    IceInternal::Property("Ice.ThreadPool.Client.SizeWarn", false, 0),

+    IceInternal::Property("Ice.ThreadPool.Client.StackSize", false, 0),

+    IceInternal::Property("Ice.ThreadPool.Server.Size", false, 0),

+    IceInternal::Property("Ice.ThreadPool.Server.SizeMax", false, 0),

+    IceInternal::Property("Ice.ThreadPool.Server.SizeWarn", false, 0),

+    IceInternal::Property("Ice.ThreadPool.Server.StackSize", false, 0),

+    IceInternal::Property("Ice.Trace.GC", false, 0),

+    IceInternal::Property("Ice.Trace.Location", false, 0),

+    IceInternal::Property("Ice.Trace.Network", false, 0),

+    IceInternal::Property("Ice.Trace.Protocol", false, 0),

+    IceInternal::Property("Ice.Trace.Retry", false, 0),

+    IceInternal::Property("Ice.Trace.Slicing", false, 0),

+    IceInternal::Property("Ice.UDP.RcvSize", false, 0),

+    IceInternal::Property("Ice.UDP.SndSize", false, 0),

+    IceInternal::Property("Ice.TCP.RcvSize", false, 0),

+    IceInternal::Property("Ice.TCP.SndSize", false, 0),

+    IceInternal::Property("Ice.UseEventLog", false, 0),

+    IceInternal::Property("Ice.UseSyslog", false, 0),

+    IceInternal::Property("Ice.Warn.AMICallback", false, 0),

+    IceInternal::Property("Ice.Warn.Connections", false, 0),

+    IceInternal::Property("Ice.Warn.Datagrams", false, 0),

+    IceInternal::Property("Ice.Warn.Dispatch", false, 0),

+    IceInternal::Property("Ice.Warn.Endpoints", false, 0),

+    IceInternal::Property("Ice.Warn.UnknownProperties", false, 0),

+    IceInternal::Property("Ice.CacheMessageBuffers", false, 0),

+};

+

+const IceInternal::PropertyArray

+    IceInternal::PropertyNames::IceProps(IcePropsData,

+                                                sizeof(IcePropsData)/sizeof(IcePropsData[0]));

+

+const IceInternal::Property IceBoxPropsData[] = 

+{

+    IceInternal::Property("IceBox.InstanceName", false, 0),

+    IceInternal::Property("IceBox.LoadOrder", false, 0),

+    IceInternal::Property("IceBox.PrintServicesReady", false, 0),

+    IceInternal::Property("IceBox.Service.*", false, 0),

+    IceInternal::Property("IceBox.ServiceManager.AdapterId", false, 0),

+    IceInternal::Property("IceBox.ServiceManager.Endpoints", false, 0),

+    IceInternal::Property("IceBox.ServiceManager.Locator", false, 0),

+    IceInternal::Property("IceBox.ServiceManager.PublishedEndpoints", false, 0),

+    IceInternal::Property("IceBox.ServiceManager.RegisterProcess", false, 0),

+    IceInternal::Property("IceBox.ServiceManager.ReplicaGroupId", false, 0),

+    IceInternal::Property("IceBox.ServiceManager.Router", false, 0),

+    IceInternal::Property("IceBox.ServiceManager.ThreadPerConnection", false, 0),

+    IceInternal::Property("IceBox.ServiceManager.ThreadPerConnection.StackSize", false, 0),

+    IceInternal::Property("IceBox.ServiceManager.ThreadPool.Size", false, 0),

+    IceInternal::Property("IceBox.ServiceManager.ThreadPool.SizeMax", false, 0),

+    IceInternal::Property("IceBox.ServiceManager.ThreadPool.SizeWarn", false, 0),

+    IceInternal::Property("IceBox.ServiceManager.ThreadPool.StackSize", false, 0),

+    IceInternal::Property("IceBox.UseSharedCommunicator.*", false, 0),

+    IceInternal::Property("IceBox.InheritProperties", false, 0),

+};

+

+const IceInternal::PropertyArray

+    IceInternal::PropertyNames::IceBoxProps(IceBoxPropsData,

+                                                sizeof(IceBoxPropsData)/sizeof(IceBoxPropsData[0]));

+

+const IceInternal::Property IceGridAdminPropsData[] = 

+{

+    IceInternal::Property("IceGridAdmin.AuthenticateUsingSSL", false, 0),

+    IceInternal::Property("IceGridAdmin.Username", false, 0),

+    IceInternal::Property("IceGridAdmin.Password", false, 0),

+    IceInternal::Property("IceGridAdmin.Replica", false, 0),

+    IceInternal::Property("IceGridAdmin.Trace.Observers", false, 0),

+    IceInternal::Property("IceGridAdmin.Trace.SaveToRegistry", false, 0),

+};

+

+const IceInternal::PropertyArray

+    IceInternal::PropertyNames::IceGridAdminProps(IceGridAdminPropsData,

+                                                sizeof(IceGridAdminPropsData)/sizeof(IceGridAdminPropsData[0]));

+

+const IceInternal::Property IceGridPropsData[] = 

+{

+    IceInternal::Property("IceGrid.InstanceName", false, 0),

+    IceInternal::Property("IceGrid.Node.AdapterId", false, 0),

+    IceInternal::Property("IceGrid.Node.CollocateRegistry", false, 0),

+    IceInternal::Property("IceGrid.Node.Data", false, 0),

+    IceInternal::Property("IceGrid.Node.DisableOnFailure", false, 0),

+    IceInternal::Property("IceGrid.Node.Endpoints", false, 0),

+    IceInternal::Property("IceGrid.Node.Locator", false, 0),

+    IceInternal::Property("IceGrid.Node.Name", false, 0),

+    IceInternal::Property("IceGrid.Node.Output", false, 0),

+    IceInternal::Property("IceGrid.Node.PrintServersReady", false, 0),

+    IceInternal::Property("IceGrid.Node.PropertiesOverride", false, 0),

+    IceInternal::Property("IceGrid.Node.PublishedEndpoints", false, 0),

+    IceInternal::Property("IceGrid.Node.RedirectErrToOut", false, 0),

+    IceInternal::Property("IceGrid.Node.RegisterProcess", false, 0),

+    IceInternal::Property("IceGrid.Node.ReplicaGroupId", false, 0),

+    IceInternal::Property("IceGrid.Node.Router", false, 0),

+    IceInternal::Property("IceGrid.Node.ThreadPerConnection", false, 0),

+    IceInternal::Property("IceGrid.Node.ThreadPerConnection.StackSize", false, 0),

+    IceInternal::Property("IceGrid.Node.ThreadPool.Size", false, 0),

+    IceInternal::Property("IceGrid.Node.ThreadPool.SizeMax", false, 0),

+    IceInternal::Property("IceGrid.Node.ThreadPool.SizeWarn", false, 0),

+    IceInternal::Property("IceGrid.Node.ThreadPool.StackSize", false, 0),

+    IceInternal::Property("IceGrid.Node.Trace.Activator", false, 0),

+    IceInternal::Property("IceGrid.Node.Trace.Adapter", false, 0),

+    IceInternal::Property("IceGrid.Node.Trace.Patch", false, 0),

+    IceInternal::Property("IceGrid.Node.Trace.Replica", false, 0),

+    IceInternal::Property("IceGrid.Node.Trace.Server", false, 0),

+    IceInternal::Property("IceGrid.Node.UserAccounts", false, 0),

+    IceInternal::Property("IceGrid.Node.UserAccountMapper", false, 0),

+    IceInternal::Property("IceGrid.Node.UserAccountMapper.EndpointSelection", false, 0),

+    IceInternal::Property("IceGrid.Node.UserAccountMapper.ConnectionCached", false, 0),

+    IceInternal::Property("IceGrid.Node.UserAccountMapper.PreferSecure", false, 0),

+    IceInternal::Property("IceGrid.Node.UserAccountMapper.LocatorCacheTimeout", false, 0),

+    IceInternal::Property("IceGrid.Node.UserAccountMapper.Locator", false, 0),

+    IceInternal::Property("IceGrid.Node.UserAccountMapper.Router", false, 0),

+    IceInternal::Property("IceGrid.Node.UserAccountMapper.CollocationOptimization", false, 0),

+    IceInternal::Property("IceGrid.Node.UserAccountMapper.ThreadPerConnection", false, 0),

+    IceInternal::Property("IceGrid.Node.WaitTime", false, 0),

+    IceInternal::Property("IceGrid.Registry.AdminCryptPasswords", false, 0),

+    IceInternal::Property("IceGrid.Registry.AdminPermissionsVerifier", false, 0),

+    IceInternal::Property("IceGrid.Registry.AdminPermissionsVerifier.EndpointSelection", false, 0),

+    IceInternal::Property("IceGrid.Registry.AdminPermissionsVerifier.ConnectionCached", false, 0),

+    IceInternal::Property("IceGrid.Registry.AdminPermissionsVerifier.PreferSecure", false, 0),

+    IceInternal::Property("IceGrid.Registry.AdminPermissionsVerifier.LocatorCacheTimeout", false, 0),

+    IceInternal::Property("IceGrid.Registry.AdminPermissionsVerifier.Locator", false, 0),

+    IceInternal::Property("IceGrid.Registry.AdminPermissionsVerifier.Router", false, 0),

+    IceInternal::Property("IceGrid.Registry.AdminPermissionsVerifier.CollocationOptimization", false, 0),

+    IceInternal::Property("IceGrid.Registry.AdminPermissionsVerifier.ThreadPerConnection", false, 0),

+    IceInternal::Property("IceGrid.Registry.AdminSSLPermissionsVerifier", false, 0),

+    IceInternal::Property("IceGrid.Registry.AdminSSLPermissionsVerifier.EndpointSelection", false, 0),

+    IceInternal::Property("IceGrid.Registry.AdminSSLPermissionsVerifier.ConnectionCached", false, 0),

+    IceInternal::Property("IceGrid.Registry.AdminSSLPermissionsVerifier.PreferSecure", false, 0),

+    IceInternal::Property("IceGrid.Registry.AdminSSLPermissionsVerifier.LocatorCacheTimeout", false, 0),

+    IceInternal::Property("IceGrid.Registry.AdminSSLPermissionsVerifier.Locator", false, 0),

+    IceInternal::Property("IceGrid.Registry.AdminSSLPermissionsVerifier.Router", false, 0),

+    IceInternal::Property("IceGrid.Registry.AdminSSLPermissionsVerifier.CollocationOptimization", false, 0),

+    IceInternal::Property("IceGrid.Registry.AdminSSLPermissionsVerifier.ThreadPerConnection", false, 0),

+    IceInternal::Property("IceGrid.Registry.Client.AdapterId", false, 0),

+    IceInternal::Property("IceGrid.Registry.Client.Endpoints", false, 0),

+    IceInternal::Property("IceGrid.Registry.Client.Locator", false, 0),

+    IceInternal::Property("IceGrid.Registry.Client.PublishedEndpoints", false, 0),

+    IceInternal::Property("IceGrid.Registry.Client.RegisterProcess", false, 0),

+    IceInternal::Property("IceGrid.Registry.Client.ReplicaGroupId", false, 0),

+    IceInternal::Property("IceGrid.Registry.Client.Router", false, 0),

+    IceInternal::Property("IceGrid.Registry.Client.ThreadPerConnection", false, 0),

+    IceInternal::Property("IceGrid.Registry.Client.ThreadPerConnection.StackSize", false, 0),

+    IceInternal::Property("IceGrid.Registry.Client.ThreadPool.Size.Size", false, 0),

+    IceInternal::Property("IceGrid.Registry.Client.ThreadPool.Size.SizeMax", false, 0),

+    IceInternal::Property("IceGrid.Registry.Client.ThreadPool.Size.SizeWarn", false, 0),

+    IceInternal::Property("IceGrid.Registry.Client.ThreadPool.Size.StackSize", false, 0),

+    IceInternal::Property("IceGrid.Registry.CryptPasswords", false, 0),

+    IceInternal::Property("IceGrid.Registry.Data", false, 0),

+    IceInternal::Property("IceGrid.Registry.DefaultTemplates", false, 0),

+    IceInternal::Property("IceGrid.Registry.DynamicRegistration", false, 0),

+    IceInternal::Property("IceGrid.Registry.Internal.AdapterId", false, 0),

+    IceInternal::Property("IceGrid.Registry.Internal.Endpoints", false, 0),

+    IceInternal::Property("IceGrid.Registry.Internal.Locator", false, 0),

+    IceInternal::Property("IceGrid.Registry.Internal.PublishedEndpoints", false, 0),

+    IceInternal::Property("IceGrid.Register.Internal.RegisterProcess", false, 0),

+    IceInternal::Property("IceGrid.Registry.Internal.ReplicaGroupId", false, 0),

+    IceInternal::Property("IceGrid.Registry.Internal.Router", false, 0),

+    IceInternal::Property("IceGrid.Registry.Internal.ThreadPerConnection", false, 0),

+    IceInternal::Property("IceGrid.Registry.Internal.ThreadPerConnection.StackSize", false, 0),

+    IceInternal::Property("IceGrid.Registry.Internal.ThreadPool.Size", false, 0),

+    IceInternal::Property("IceGrid.Registry.Internal.ThreadPool.SizeMax", false, 0),

+    IceInternal::Property("IceGrid.Registry.Internal.ThreadPool.SizeWarn", false, 0),

+    IceInternal::Property("IceGrid.Registry.Internal.ThreadPool.StackSize", false, 0),

+    IceInternal::Property("IceGrid.Registry.NodeSessionTimeout", false, 0),

+    IceInternal::Property("IceGrid.Registry.PermissionsVerifier", false, 0),

+    IceInternal::Property("IceGrid.Registry.PermissionsVerifier.EndpointSelection", false, 0),

+    IceInternal::Property("IceGrid.Registry.PermissionsVerifier.ConnectionCached", false, 0),

+    IceInternal::Property("IceGrid.Registry.PermissionsVerifier.PreferSecure", false, 0),

+    IceInternal::Property("IceGrid.Registry.PermissionsVerifier.LocatorCacheTimeout", false, 0),

+    IceInternal::Property("IceGrid.Registry.PermissionsVerifier.Locator", false, 0),

+    IceInternal::Property("IceGrid.Registry.PermissionsVerifier.Router", false, 0),

+    IceInternal::Property("IceGrid.Registry.PermissionsVerifier.CollocationOptimization", false, 0),

+    IceInternal::Property("IceGrid.Registry.PermissionsVerifier.ThreadPerConnection", false, 0),

+    IceInternal::Property("IceGrid.Registry.ReplicaName", false, 0),

+    IceInternal::Property("IceGrid.Registry.ReplicaSessionTimeout", false, 0),

+    IceInternal::Property("IceGrid.Registry.Server.AdapterId", false, 0),

+    IceInternal::Property("IceGrid.Registry.Server.Endpoints", false, 0),

+    IceInternal::Property("IceGrid.Registry.Server.Locator", false, 0),

+    IceInternal::Property("IceGrid.Registry.Server.PublishedEndpoints", false, 0),

+    IceInternal::Property("IceGrid.Registry.Server.RegisterProcess", false, 0),

+    IceInternal::Property("IceGrid.Registry.Server.ReplicaGroupId", false, 0),

+    IceInternal::Property("IceGrid.Registry.Server.Router", false, 0),

+    IceInternal::Property("IceGrid.Registry.Server.ThreadPerConnection", false, 0),

+    IceInternal::Property("IceGrid.Registry.Server.ThreadPerConnection.StackSize", false, 0),

+    IceInternal::Property("IceGrid.Registry.Server.ThreadPool.Size", false, 0),

+    IceInternal::Property("IceGrid.Registry.Server.ThreadPool.SizeMax", false, 0),

+    IceInternal::Property("IceGrid.Registry.Server.ThreadPool.SizeWarn", false, 0),

+    IceInternal::Property("IceGrid.Registry.Server.ThreadPool.StackSize", false, 0),

+    IceInternal::Property("IceGrid.Registry.SessionManager.AdapterId", false, 0),

+    IceInternal::Property("IceGrid.Registry.SessionManager.Endpoints", false, 0),

+    IceInternal::Property("IceGrid.Registry.SessionManager.Locator", false, 0),

+    IceInternal::Property("IceGrid.Registry.SessionManager.PublishedEndpoints", false, 0),

+    IceInternal::Property("IceGrid.Registry.SessionManager.RegisterProcess", false, 0),

+    IceInternal::Property("IceGrid.Registry.SessionManager.ReplicaGroupId", false, 0),

+    IceInternal::Property("IceGrid.Registry.SessionManager.Router", false, 0),

+    IceInternal::Property("IceGrid.Registry.SessionManager.ThreadPerConnection", false, 0),

+    IceInternal::Property("IceGrid.Registry.SessionManager.ThreadPerConnection.StackSize", false, 0),

+    IceInternal::Property("IceGrid.Registry.SessionManager.ThreadPool.Size", false, 0),

+    IceInternal::Property("IceGrid.Registry.SessionManager.ThreadPool.SizeMax", false, 0),

+    IceInternal::Property("IceGrid.Registry.SessionManager.ThreadPool.SizeWarn", false, 0),

+    IceInternal::Property("IceGrid.Registry.SessionManager.ThreadPool.StackSize", false, 0),

+    IceInternal::Property("IceGrid.Registry.SessionTimeout", false, 0),

+    IceInternal::Property("IceGrid.Registry.SSLPermissionsVerifier", false, 0),

+    IceInternal::Property("IceGrid.Registry.SSLPermissionsVerifier.EndpointSelection", false, 0),

+    IceInternal::Property("IceGrid.Registry.SSLPermissionsVerifier.ConnectionCached", false, 0),

+    IceInternal::Property("IceGrid.Registry.SSLPermissionsVerifier.PreferSecure", false, 0),

+    IceInternal::Property("IceGrid.Registry.SSLPermissionsVerifier.LocatorCacheTimeout", false, 0),

+    IceInternal::Property("IceGrid.Registry.SSLPermissionsVerifier.Locator", false, 0),

+    IceInternal::Property("IceGrid.Registry.SSLPermissionsVerifier.Router", false, 0),

+    IceInternal::Property("IceGrid.Registry.SSLPermissionsVerifier.CollocationOptimization", false, 0),

+    IceInternal::Property("IceGrid.Registry.SSLPermissionsVerifier.ThreadPerConnection", false, 0),

+    IceInternal::Property("IceGrid.Registry.Trace.Application", false, 0),

+    IceInternal::Property("IceGrid.Registry.Trace.Adapter", false, 0),

+    IceInternal::Property("IceGrid.Registry.Trace.Locator", false, 0),

+    IceInternal::Property("IceGrid.Registry.Trace.Node", false, 0),

+    IceInternal::Property("IceGrid.Registry.Trace.Object", false, 0),

+    IceInternal::Property("IceGrid.Registry.Trace.Patch", false, 0),

+    IceInternal::Property("IceGrid.Registry.Trace.Replica", false, 0),

+    IceInternal::Property("IceGrid.Registry.Trace.Server", false, 0),

+    IceInternal::Property("IceGrid.Registry.Trace.Session", false, 0),

+    IceInternal::Property("IceGrid.Registry.UserAccounts", false, 0),

+};

+

+const IceInternal::PropertyArray

+    IceInternal::PropertyNames::IceGridProps(IceGridPropsData,

+                                                sizeof(IceGridPropsData)/sizeof(IceGridPropsData[0]));

+

+const IceInternal::Property IcePatch2PropsData[] = 

+{

+    IceInternal::Property("IcePatch2.AdapterId", false, 0),

+    IceInternal::Property("IcePatch2.Admin.AdapterId", false, 0),

+    IceInternal::Property("IcePatch2.Admin.Endpoints", false, 0),

+    IceInternal::Property("IcePatch2.Admin.Locator", false, 0),

+    IceInternal::Property("IcePatch2.Admin.PublishedEndpoints", false, 0),

+    IceInternal::Property("IcePatch2.Admin.RegisterProcess", false, 0),

+    IceInternal::Property("IcePatch2.Admin.ReplicaGroupId", false, 0),

+    IceInternal::Property("IcePatch2.Admin.Router", false, 0),

+    IceInternal::Property("IcePatch2.Admin.ThreadPerConnection", false, 0),

+    IceInternal::Property("IcePatch2.Admin.ThreadPerConnection.StackSize", false, 0),

+    IceInternal::Property("IcePatch2.Admin.ThreadPool.Size", false, 0),

+    IceInternal::Property("IcePatch2.Admin.ThreadPool.SizeMax", false, 0),

+    IceInternal::Property("IcePatch2.Admin.ThreadPool.SizeWarn", false, 0),

+    IceInternal::Property("IcePatch2.Admin.ThreadPool.StackSize", false, 0),

+    IceInternal::Property("IcePatch2.ChunkSize", false, 0),

+    IceInternal::Property("IcePatch2.Directory", false, 0),

+    IceInternal::Property("IcePatch2.Endpoints", false, 0),

+    IceInternal::Property("IcePatch2.InstanceName", false, 0),

+    IceInternal::Property("IcePatch2.Locator", false, 0),

+    IceInternal::Property("IcePatch2.PublishedEndpoints", false, 0),

+    IceInternal::Property("IcePatch2.RegisterProcess", false, 0),

+    IceInternal::Property("IcePatch2.ReplicaGroupId", false, 0),

+    IceInternal::Property("IcePatch2.Remove", false, 0),

+    IceInternal::Property("IcePatch2.Router", false, 0),

+    IceInternal::Property("IcePatch2.Thorough", false, 0),

+    IceInternal::Property("IcePatch2.ThreadPerConnection", false, 0),

+    IceInternal::Property("IcePatch2.ThreadPerConnection.StackSize", false, 0),

+    IceInternal::Property("IcePatch2.ThreadPool.Size", false, 0),

+    IceInternal::Property("IcePatch2.ThreadPool.SizeMax", false, 0),

+    IceInternal::Property("IcePatch2.ThreadPool.SizeWarn", false, 0),

+    IceInternal::Property("IcePatch2.ThreadPool.StackSize", false, 0),

+};

+

+const IceInternal::PropertyArray

+    IceInternal::PropertyNames::IcePatch2Props(IcePatch2PropsData,

+                                                sizeof(IcePatch2PropsData)/sizeof(IcePatch2PropsData[0]));

+

+const IceInternal::Property IceSSLPropsData[] = 

+{

+    IceInternal::Property("IceSSL.Alias", false, 0),

+    IceInternal::Property("IceSSL.CertAuthDir", false, 0),

+    IceInternal::Property("IceSSL.CertAuthFile", false, 0),

+    IceInternal::Property("IceSSL.CertFile", false, 0),

+    IceInternal::Property("IceSSL.CheckCertName", false, 0),

+    IceInternal::Property("IceSSL.CheckCRL", false, 0),

+    IceInternal::Property("IceSSL.Ciphers", false, 0),

+    IceInternal::Property("IceSSL.DefaultDir", false, 0),

+    IceInternal::Property("IceSSL.DH.*", false, 0),

+    IceInternal::Property("IceSSL.EntropyDaemon", false, 0),

+    IceInternal::Property("IceSSL.FindCert.*", false, 0),

+    IceInternal::Property("IceSSL.ImportCert.*", false, 0),

+    IceInternal::Property("IceSSL.KeyFile", false, 0),

+    IceInternal::Property("IceSSL.Keystore", false, 0),

+    IceInternal::Property("IceSSL.KeystorePassword", false, 0),

+    IceInternal::Property("IceSSL.KeystoreType", false, 0),

+    IceInternal::Property("IceSSL.Password", false, 0),

+    IceInternal::Property("IceSSL.PasswordRetryMax", false, 0),

+    IceInternal::Property("IceSSL.Protocols", false, 0),

+    IceInternal::Property("IceSSL.Random", false, 0),

+    IceInternal::Property("IceSSL.Trace.Security", false, 0),

+    IceInternal::Property("IceSSL.Truststore", false, 0),

+    IceInternal::Property("IceSSL.TruststorePassword", false, 0),

+    IceInternal::Property("IceSSL.TruststoreType", false, 0),

+    IceInternal::Property("IceSSL.VerifyDepthMax", false, 0),

+    IceInternal::Property("IceSSL.VerifyPeer", false, 0),

+    IceInternal::Property("IceSSL.TrustOnly", false, 0),

+    IceInternal::Property("IceSSL.TrustOnly.Client", false, 0),

+    IceInternal::Property("IceSSL.TrustOnly.Server", false, 0),

+    IceInternal::Property("IceSSL.TrustOnly.Server.*", false, 0),

+};

+

+const IceInternal::PropertyArray

+    IceInternal::PropertyNames::IceSSLProps(IceSSLPropsData,

+                                                sizeof(IceSSLPropsData)/sizeof(IceSSLPropsData[0]));

+

+const IceInternal::Property IceStormAdminPropsData[] = 

+{

+    IceInternal::Property("IceStormAdmin.TopicManager.*", false, 0),

+};

+

+const IceInternal::PropertyArray

+    IceInternal::PropertyNames::IceStormAdminProps(IceStormAdminPropsData,

+                                                sizeof(IceStormAdminPropsData)/sizeof(IceStormAdminPropsData[0]));

+

+const IceInternal::Property IceStormPropsData[] = 

+{

+    IceInternal::Property("IceStorm.Flush.Timeout", false, 0),

+    IceInternal::Property("IceStorm.InstanceName", false, 0),

+    IceInternal::Property("IceStorm.Publish.AdapterId", false, 0),

+    IceInternal::Property("IceStorm.Publish.Endpoints", false, 0),

+    IceInternal::Property("IceStorm.Publish.Locator", false, 0),

+    IceInternal::Property("IceStorm.Publish.PublishedEndpoints", false, 0),

+    IceInternal::Property("IceStorm.Publish.RegisterProcess", false, 0),

+    IceInternal::Property("IceStorm.Publish.ReplicaGroupId", false, 0),

+    IceInternal::Property("IceStorm.Publish.Router", false, 0),

+    IceInternal::Property("IceStorm.Publish.ThreadPerConnection", false, 0),

+    IceInternal::Property("IceStorm.Publish.ThreadPerConnection.StackSize", false, 0),

+    IceInternal::Property("IceStorm.Publish.ThreadPool.Size", false, 0),

+    IceInternal::Property("IceStorm.Publish.ThreadPool.SizeMax", false, 0),

+    IceInternal::Property("IceStorm.Publish.ThreadPool.SizeWarn", false, 0),

+    IceInternal::Property("IceStorm.Publish.ThreadPool.StackSize", false, 0),

+    IceInternal::Property("IceStorm.TopicManager.AdapterId", false, 0),

+    IceInternal::Property("IceStorm.TopicManager.Endpoints", false, 0),

+    IceInternal::Property("IceStorm.TopicManager.Locator", false, 0),

+    IceInternal::Property("IceStorm.TopicManager.Proxy", false, 0),

+    IceInternal::Property("IceStorm.TopicManager.Proxy.EndpointSelection", false, 0),

+    IceInternal::Property("IceStorm.TopicManager.Proxy.ConnectionCached", false, 0),

+    IceInternal::Property("IceStorm.TopicManager.Proxy.PreferSecure", false, 0),

+    IceInternal::Property("IceStorm.TopicManager.Proxy.LocatorCacheTimeout", false, 0),

+    IceInternal::Property("IceStorm.TopicManager.Proxy.Locator", false, 0),

+    IceInternal::Property("IceStorm.TopicManager.Proxy.Router", false, 0),

+    IceInternal::Property("IceStorm.TopicManager.Proxy.CollocationOptimization", false, 0),

+    IceInternal::Property("IceStorm.TopicManager.Proxy.ThreadPerConnection", false, 0),

+    IceInternal::Property("IceStorm.TopicManager.PublishedEndpoints", false, 0),

+    IceInternal::Property("IceStorm.TopicManager.RegisterProcess", false, 0),

+    IceInternal::Property("IceStorm.TopicManager.ReplicaGroupId", false, 0),

+    IceInternal::Property("IceStorm.TopicManager.Router", false, 0),

+    IceInternal::Property("IceStorm.TopicManager.ThreadPerConnection", false, 0),

+    IceInternal::Property("IceStorm.TopicManager.ThreadPerConnection.StackSize", false, 0),

+    IceInternal::Property("IceStorm.TopicManager.ThreadPool.Size", false, 0),

+    IceInternal::Property("IceStorm.TopicManager.ThreadPool.SizeMax", false, 0),

+    IceInternal::Property("IceStorm.TopicManager.ThreadPool.SizeWarn", false, 0),

+    IceInternal::Property("IceStorm.TopicManager.ThreadPool.StackSize", false, 0),

+    IceInternal::Property("IceStorm.SubscriberPool.Size", false, 0),

+    IceInternal::Property("IceStorm.SubscriberPool.SizeMax", false, 0),

+    IceInternal::Property("IceStorm.SubscriberPool.SizeWarn", false, 0),

+    IceInternal::Property("IceStorm.SubscriberPool.Timeout", false, 0),

+    IceInternal::Property("IceStorm.Trace.Flush", false, 0),

+    IceInternal::Property("IceStorm.Trace.Subscriber", false, 0),

+    IceInternal::Property("IceStorm.Trace.SubscriberPool", false, 0),

+    IceInternal::Property("IceStorm.Trace.Topic", false, 0),

+    IceInternal::Property("IceStorm.Trace.TopicManager", false, 0),

+    IceInternal::Property("IceStorm.Send.Timeout", false, 0),

+    IceInternal::Property("IceStorm.Discard.Interval", false, 0),

+};

+

+const IceInternal::PropertyArray

+    IceInternal::PropertyNames::IceStormProps(IceStormPropsData,

+                                                sizeof(IceStormPropsData)/sizeof(IceStormPropsData[0]));

+

+const IceInternal::Property Glacier2PropsData[] = 

+{

+    IceInternal::Property("Glacier2.AddSSLContext", false, 0),

+    IceInternal::Property("Glacier2.AddUserToAllowCategories", true, "Glacier2.Filter.Category.AcceptUser"),

+    IceInternal::Property("Glacier2.Admin.Endpoints", false, 0),

+    IceInternal::Property("Glacier2.Admin.PublishedEndpoints", false, 0),

+    IceInternal::Property("Glacier2.Admin.RegisterProcess", false, 0),

+    IceInternal::Property("Glacier2.AllowCategories", true, "Glacier2.Filter.Category.Accept"),

+    IceInternal::Property("Glacier2.Client.AlwaysBatch", false, 0),

+    IceInternal::Property("Glacier2.Client.Buffered", false, 0),

+    IceInternal::Property("Glacier2.Client.Endpoints", false, 0),

+    IceInternal::Property("Glacier2.Client.ForwardContext", false, 0),

+    IceInternal::Property("Glacier2.Client.PublishedEndpoints", false, 0),

+    IceInternal::Property("Glacier2.Client.RegisterProcess", false, 0),

+    IceInternal::Property("Glacier2.Client.SleepTime", false, 0),

+    IceInternal::Property("Glacier2.Client.Trace.Override", false, 0),

+    IceInternal::Property("Glacier2.Client.Trace.Reject", false, 0),

+    IceInternal::Property("Glacier2.Client.Trace.Request", false, 0),

+    IceInternal::Property("Glacier2.Filter.Address.Reject", false, 0),

+    IceInternal::Property("Glacier2.Filter.Address.Accept", false, 0),

+    IceInternal::Property("Glacier2.Filter.ProxySizeMax", false, 0),

+    IceInternal::Property("Glacier2.Filter.Category.Accept", false, 0),

+    IceInternal::Property("Glacier2.Filter.Category.AcceptUser", false, 0),

+    IceInternal::Property("Glacier2.Filter.AdapterId.Accept", false, 0),

+    IceInternal::Property("Glacier2.Filter.Identity.Accept", false, 0),

+    IceInternal::Property("Glacier2.CryptPasswords", false, 0),

+    IceInternal::Property("Glacier2.InstanceName", false, 0),

+    IceInternal::Property("Glacier2.PermissionsVerifier", false, 0),

+    IceInternal::Property("Glacier2.PermissionsVerifier.EndpointSelection", false, 0),

+    IceInternal::Property("Glacier2.PermissionsVerifier.ConnectionCached", false, 0),

+    IceInternal::Property("Glacier2.PermissionsVerifier.PreferSecure", false, 0),

+    IceInternal::Property("Glacier2.PermissionsVerifier.LocatorCacheTimeout", false, 0),

+    IceInternal::Property("Glacier2.PermissionsVerifier.Locator", false, 0),

+    IceInternal::Property("Glacier2.PermissionsVerifier.Router", false, 0),

+    IceInternal::Property("Glacier2.PermissionsVerifier.CollocationOptimization", false, 0),

+    IceInternal::Property("Glacier2.PermissionsVerifier.ThreadPerConnection", false, 0),

+    IceInternal::Property("Glacier2.ReturnClientProxy", false, 0),

+    IceInternal::Property("Glacier2.SSLPermissionsVerifier", false, 0),

+    IceInternal::Property("Glacier2.SSLPermissionsVerifier.EndpointSelection", false, 0),

+    IceInternal::Property("Glacier2.SSLPermissionsVerifier.ConnectionCached", false, 0),

+    IceInternal::Property("Glacier2.SSLPermissionsVerifier.PreferSecure", false, 0),

+    IceInternal::Property("Glacier2.SSLPermissionsVerifier.LocatorCacheTimeout", false, 0),

+    IceInternal::Property("Glacier2.SSLPermissionsVerifier.Locator", false, 0),

+    IceInternal::Property("Glacier2.SSLPermissionsVerifier.Router", false, 0),

+    IceInternal::Property("Glacier2.SSLPermissionsVerifier.CollocationOptimization", false, 0),

+    IceInternal::Property("Glacier2.SSLPermissionsVerifier.ThreadPerConnection", false, 0),

+    IceInternal::Property("Glacier2.RoutingTable.MaxSize", false, 0),

+    IceInternal::Property("Glacier2.Server.AlwaysBatch", false, 0),

+    IceInternal::Property("Glacier2.Server.Buffered", false, 0),

+    IceInternal::Property("Glacier2.Server.Endpoints", false, 0),

+    IceInternal::Property("Glacier2.Server.ForwardContext", false, 0),

+    IceInternal::Property("Glacier2.Server.PublishedEndpoints", false, 0),

+    IceInternal::Property("Glacier2.Server.RegisterProcess", false, 0),

+    IceInternal::Property("Glacier2.Server.SleepTime", false, 0),

+    IceInternal::Property("Glacier2.Server.Trace.Override", false, 0),

+    IceInternal::Property("Glacier2.Server.Trace.Request", false, 0),

+    IceInternal::Property("Glacier2.SessionManager", false, 0),

+    IceInternal::Property("Glacier2.SessionManager.EndpointSelection", false, 0),

+    IceInternal::Property("Glacier2.SessionManager.ConnectionCached", false, 0),

+    IceInternal::Property("Glacier2.SessionManager.PreferSecure", false, 0),

+    IceInternal::Property("Glacier2.SessionManager.LocatorCacheTimeout", false, 0),

+    IceInternal::Property("Glacier2.SessionManager.Locator", false, 0),

+    IceInternal::Property("Glacier2.SessionManager.Router", false, 0),

+    IceInternal::Property("Glacier2.SessionManager.CollocationOptimization", false, 0),

+    IceInternal::Property("Glacier2.SessionManager.ThreadPerConnection", false, 0),

+    IceInternal::Property("Glacier2.SSLSessionManager", false, 0),

+    IceInternal::Property("Glacier2.SSLSessionManager.EndpointSelection", false, 0),

+    IceInternal::Property("Glacier2.SSLSessionManager.ConnectionCached", false, 0),

+    IceInternal::Property("Glacier2.SSLSessionManager.PreferSecure", false, 0),

+    IceInternal::Property("Glacier2.SSLSessionManager.LocatorCacheTimeout", false, 0),

+    IceInternal::Property("Glacier2.SSLSessionManager.Locator", false, 0),

+    IceInternal::Property("Glacier2.SSLSessionManager.Router", false, 0),

+    IceInternal::Property("Glacier2.SSLSessionManager.CollocationOptimization", false, 0),

+    IceInternal::Property("Glacier2.SSLSessionManager.ThreadPerConnection", false, 0),

+    IceInternal::Property("Glacier2.SessionTimeout", false, 0),

+    IceInternal::Property("Glacier2.Trace.RoutingTable", false, 0),

+    IceInternal::Property("Glacier2.Trace.Session", false, 0),

+};

+

+const IceInternal::PropertyArray

+    IceInternal::PropertyNames::Glacier2Props(Glacier2PropsData,

+                                                sizeof(Glacier2PropsData)/sizeof(Glacier2PropsData[0]));

+

+const IceInternal::Property FreezePropsData[] = 

+{

+    IceInternal::Property("Freeze.DbEnv.*.CheckpointPeriod", false, 0),

+    IceInternal::Property("Freeze.DbEnv.*.DbHome", false, 0),

+    IceInternal::Property("Freeze.DbEnv.*.DbPrivate", false, 0),

+    IceInternal::Property("Freeze.DbEnv.*.DbRecoverFatal", false, 0),

+    IceInternal::Property("Freeze.DbEnv.*.OldLogsAutoDelete", false, 0),

+    IceInternal::Property("Freeze.DbEnv.*.PeriodicCheckpointMinSize", false, 0),

+    IceInternal::Property("Freeze.Evictor.*.MaxTxSize", false, 0),

+    IceInternal::Property("Freeze.Evictor.*.SavePeriod", false, 0),

+    IceInternal::Property("Freeze.Evictor.*.SaveSizeTrigger", false, 0),

+    IceInternal::Property("Freeze.Evictor.*.StreamTimeout", false, 0),

+    IceInternal::Property("Freeze.Evictor.*.PopulateEmptyIndices", false, 0),

+    IceInternal::Property("Freeze.Evictor.UseNonmutating", false, 0),

+    IceInternal::Property("Freeze.Trace.DbEnv", false, 0),

+    IceInternal::Property("Freeze.Trace.Evictor", false, 0),

+    IceInternal::Property("Freeze.Trace.Map", false, 0),

+    IceInternal::Property("Freeze.Trace.Transaction", false, 0),

+    IceInternal::Property("Freeze.Warn.CloseInFinalize", false, 0),

+    IceInternal::Property("Freeze.Warn.Deadlocks", false, 0),

+};

+

+const IceInternal::PropertyArray

+    IceInternal::PropertyNames::FreezeProps(FreezePropsData,

+                                                sizeof(FreezePropsData)/sizeof(FreezePropsData[0]));

+

+

+const IceInternal::PropertyArray IceInternal::PropertyNames::validProps[] =

+{

+    IceProps,

+    IceBoxProps,

+    IceGridAdminProps,

+    IceGridProps,

+    IcePatch2Props,

+    IceSSLProps,

+    IceStormAdminProps,

+    IceStormProps,

+    Glacier2Props,

+    FreezeProps,

+    IceInternal::PropertyArray(0,0)

+};

+

+

+const char* IceInternal::PropertyNames::clPropNames[] =

+{

+    "Ice",

+    "IceBox",

+    "IceGridAdmin",

+    "IceGrid",

+    "IcePatch2",

+    "IceSSL",

+    "IceStormAdmin",

+    "IceStorm",

+    "Glacier2",

+    "Freeze",

+    0

+};

+

diff --git a/cpp/src/Ice/PropertyNames.h b/cpp/src/Ice/PropertyNames.h
index 9acdaea97c0..4de5006eec0 100644
--- a/cpp/src/Ice/PropertyNames.h
+++ b/cpp/src/Ice/PropertyNames.h
@@ -1,42 +1,77 @@
-// **********************************************************************
-//
-// Copyright (c) 2003-2007 ZeroC, Inc. All rights reserved.
-//
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
-
-// Generated by makeprops.py from file `../config/PropertyNames.def', Wed May 23 14:21:55 2007
-
-// IMPORTANT: Do not edit this file -- any edits made here will be lost!
-
-#ifndef ICE_INTERNAL_PropertyNames_H
-#define ICE_INTERNAL_PropertyNames_H
-
-#include <Ice/Config.h>
-namespace IceInternal
-{
-
-class PropertyNames
-{
-public:
-
-    static const char* IceProps[];
-    static const char* IceBoxProps[];
-    static const char* IceGridAdminProps[];
-    static const char* IceGridProps[];
-    static const char* IcePatch2Props[];
-    static const char* IceSSLProps[];
-    static const char* IceStormAdminProps[];
-    static const char* IceStormProps[];
-    static const char* Glacier2Props[];
-    static const char* FreezeProps[];
-
-    static const char* const* validProps[];
-    static const char* clPropNames[];
-};
-
-}
-
-#endif
+// **********************************************************************

+//

+// Copyright (c) 2003-2007 ZeroC, Inc. All rights reserved.

+//

+// This copy of Ice is licensed to you under the terms described in the

+// ICE_LICENSE file included in this distribution.

+//

+// **********************************************************************

+

+// Generated by makeprops.py from file XXX- stuff needs to go here!

+

+// IMPORTANT: Do not edit this file -- any edits made here will be lost!

+

+#ifndef ICE_INTERNAL_PropertyNames_H

+#define ICE_INTERNAL_PropertyNames_H

+

+#include <Ice/Config.h>

+

+namespace IceInternal

+{

+

+struct Property

+{

+    const char* pattern;

+    bool deprecated;

+    const char* deprecatedBy;

+

+    Property(const char* n, bool d, const char* b) :

+	pattern(n),

+	deprecated(d),

+	deprecatedBy(b)

+    {

+    }

+

+    Property() :

+        pattern(0),

+        deprecated(false),

+        deprecatedBy(0)

+    {

+    }

+

+};

+

+struct PropertyArray

+{

+    const Property* properties;

+    const int length;

+

+    PropertyArray(const Property* p, int len) :

+        properties(p),

+        length(len)

+    {

+    }

+};

+

+class PropertyNames

+{

+public:

+

+    static const PropertyArray IceProps;

+    static const PropertyArray IceBoxProps;

+    static const PropertyArray IceGridAdminProps;

+    static const PropertyArray IceGridProps;

+    static const PropertyArray IcePatch2Props;

+    static const PropertyArray IceSSLProps;

+    static const PropertyArray IceStormAdminProps;

+    static const PropertyArray IceStormProps;

+    static const PropertyArray Glacier2Props;

+    static const PropertyArray FreezeProps;

+

+    static const PropertyArray IceInternal::PropertyNames::validProps[];

+    static const char * IceInternal::PropertyNames::clPropNames[];

+};

+

+}

+

+#endif