zeroc-ice 3.6.5 → 3.7.0

data/ext/ice/cpp/src/Slice/Util.h

@@ -0,0 +1,54 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2017 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.
+//
+// **********************************************************************
+
+#ifndef SLICE_UTIL_H
+#define SLICE_UTIL_H
+
+#include <Slice/Parser.h>
+#include <IceUtil/OutputUtil.h>
+
+namespace Slice
+{
+
+std::string fullPath(const std::string&);
+std::string changeInclude(const std::string&, const std::vector<std::string>&);
+void emitError(const std::string&, int, const std::string&);
+void emitWarning(const std::string&, int, const std::string&);
+void emitError(const std::string&, const std::string&, const std::string&);
+void emitWarning(const std::string&, const std::string&, const std::string&);
+void emitRaw(const char*);
+std::vector<std::string> filterMcppWarnings(const std::string&);
+void printGeneratedHeader(IceUtilInternal::Output& out, const std::string&, const std::string& commentStyle = "//");
+#ifdef _WIN32
+std::vector<std::string> argvToArgs(int argc, wchar_t* argv[]);
+#else
+std::vector<std::string> argvToArgs(int argc, char* argv[]);
+#endif
+
+enum EscapeMode { UCN, Octal, ShortUCN, EC6UCN };
+
+// Parameters:
+// const string& value: input string provided by Slice Parser
+// const string& nonPrintableEscaped: which of \a, \b, \f, \n, \r, \t, \v, \0 (null), \x20 (\s), \x1b (\e) are
+//                                    escaped in the target language
+//                                    Warning: don't include \0 if the target language recognizes octal escapes
+// const string& printableEscaped: additional printable ASCII characters other than \ and " that need to be escaped
+// EscapeMode escapeMode: whether we generate both UCNs, octal escape sequences, only short UCNs (\unnnn),
+//                        or ECMAScript 6-style UCNs with \u{...} for astral characters
+// unsigned char cutOff: characters < cutOff other than the nonPrintableEscaped are generated as
+//                       octal escape sequences, regardless of escapeMode.
+std::string
+toStringLiteral(const std::string&, const std::string&, const std::string&, EscapeMode, unsigned char);
+
+void
+writeDependencies(const std::string&, const std::string&);
+
+}
+
+#endif

data/ext/ice/mcpp/Makefile

@@ -1,6 +1,8 @@
+# **********************************************************************
 #
-# Copyright (c) ZeroC, Inc. All rights reserved.
+# Copyright (c) 2015-2017 ZeroC, Inc. All rights reserved.
 #
+# **********************************************************************
 
 PREFIX ?= /opt/mcpp-2.7.2
 
@@ -52,7 +54,8 @@ OBJS = directive.o eval.o expand.o main.o mbchar.o support.o system.o
 
 $(LIBDIR)/libmcpp.a: $(OBJS)
 	-mkdir -p $(LIBDIR)
-	$(AR) rcs $(LIBDIR)/libmcpp.a $(OBJS)
+	ar rcs $(LIBDIR)/libmcpp.a $(OBJS)
+	ranlib $(LIBDIR)/libmcpp.a
 
 install: $(LIBDIR)/libmcpp.a
 	@mkdir -p $(PREFIX)/$(LIBDIR)

data/ice.gemspec

@@ -2,14 +2,11 @@
 #
 # Copyright (c) 2003-2017 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.
-#
 # **********************************************************************
 
 Gem::Specification.new do |s|
   s.name        = 'zeroc-ice'
-  s.version     = '3.6.5'
+  s.version     = '3.7.0'
   s.summary     = "ZeroC Ice for Ruby"
   s.description = <<-eos
 The Internet Communications Engine (Ice) provides a robust, proven
@@ -30,12 +27,10 @@ Join us on our user forums if you have questions about Ice.
 eos
   s.authors     = ["ZeroC, Inc."]
   s.email       = 'info@zeroc.com'
-  s.files       = %w[ICE_LICENSE LICENSE MCPP_LICENSE ice.gemspec] + Dir.glob('lib/**/*.rb') + Dir.glob("ext/*") + Dir.glob("ext/**/*") + Dir.glob("slice/**/*.ice")
+  s.files       = %w[ICE_LICENSE LICENSE MCPP_LICENSE BZIP2_LICENSE ice.gemspec] + Dir.glob('lib/**/*.rb') + Dir.glob("ext/*") + Dir.glob("ext/**/*") + Dir.glob("slice/**/*.ice")
   s.homepage    = 'https://zeroc.com'
   s.license     = 'GPL-2.0'
   s.extensions = %w[ext/extconf.rb]
   s.rdoc_options = %w[--exclude=ext/IceRuby/.*\.o$ --exclude=IceRuby\.(bundle|so)$ --exclude=lib/slice2rb$]
   s.executables << 'slice2rb'
-  s.metadata['msys2_dependencies'] = 'make'
-  s.metadata['msys2_mingw_dependencies'] = 'gcc'
 end

data/lib/Glacier2.rb

@@ -1,6 +1,6 @@
 # **********************************************************************
 #
-# Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+# Copyright (c) 2003-2017 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.

data/lib/Glacier2/Metrics.rb

@@ -1,14 +1,14 @@
 # encoding: utf-8
 # **********************************************************************
 #
-# Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+# Copyright (c) 2003-2017 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.
 #
 # **********************************************************************
 #
-# Ice version 3.6.5
+# Ice version 3.7.0
 #
 # <auto-generated>
 #
@@ -22,32 +22,13 @@
 require 'Ice'
 require 'Ice/Metrics.rb'
 
-module ::IceMX
+module IceMX
 
-    if not defined?(::IceMX::SessionMetrics_mixin)
-        module SessionMetrics_mixin
-            include ::IceMX::Metrics_mixin
+    if not defined?(::IceMX::SessionMetrics_Mixin)
 
-            def ice_ids(current=nil)
-                ['::Ice::Object', '::IceMX::Metrics', '::IceMX::SessionMetrics']
-            end
-
-            def ice_id(current=nil)
-                '::IceMX::SessionMetrics'
-            end
-
-            def inspect
-                ::Ice::__stringify(self, T_SessionMetrics)
-            end
-
-            attr_accessor :forwardedClient, :forwardedServer, :routingTableSize, :queuedClient, :queuedServer, :overriddenClient, :overriddenServer
+        module ::IceMX::SessionMetrics_Mixin
         end
         class SessionMetrics < ::IceMX::Metrics
-            include SessionMetrics_mixin
-            
-            def SessionMetrics.ice_staticId()
-                '::IceMX::SessionMetrics'
-            end
 
             def initialize(id='', total=0, current=0, totalLifetime=0, failures=0, forwardedClient=0, forwardedServer=0, routingTableSize=0, queuedClient=0, queuedServer=0, overriddenClient=0, overriddenServer=0)
                 super(id, total, current, totalLifetime, failures)
@@ -59,31 +40,15 @@ module ::IceMX
                 @overriddenClient = overriddenClient
                 @overriddenServer = overriddenServer
             end
-        end
-        module SessionMetricsPrx_mixin
-            include ::IceMX::MetricsPrx_mixin
-        end
-        class SessionMetricsPrx < ::Ice::ObjectPrx
-            include SessionMetricsPrx_mixin
-
-            def SessionMetricsPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
-                ice_checkedCast(proxy, '::IceMX::SessionMetrics', facetOrCtx, _ctx)
-            end
 
-            def SessionMetricsPrx.uncheckedCast(proxy, facet=nil)
-                ice_uncheckedCast(proxy, facet)
-            end
-            def SessionMetricsPrx.ice_staticId()
-                '::IceMX::SessionMetrics'
-            end
+            attr_accessor :forwardedClient, :forwardedServer, :routingTableSize, :queuedClient, :queuedServer, :overriddenClient, :overriddenServer
         end
 
         if not defined?(::IceMX::T_SessionMetrics)
             T_SessionMetrics = ::Ice::__declareClass('::IceMX::SessionMetrics')
-            T_SessionMetricsPrx = ::Ice::__declareProxy('::IceMX::SessionMetrics')
         end
 
-        T_SessionMetrics.defineClass(SessionMetrics, -1, false, false, ::IceMX::T_Metrics, [], [
+        T_SessionMetrics.defineClass(SessionMetrics, -1, false, false, ::IceMX::T_Metrics, [
             ['forwardedClient', ::Ice::T_int, false, 0],
             ['forwardedServer', ::Ice::T_int, false, 0],
             ['routingTableSize', ::Ice::T_int, false, 0],
@@ -92,9 +57,5 @@ module ::IceMX
             ['overriddenClient', ::Ice::T_int, false, 0],
             ['overriddenServer', ::Ice::T_int, false, 0]
         ])
-        SessionMetrics_mixin::ICE_TYPE = T_SessionMetrics
-
-        T_SessionMetricsPrx.defineProxy(SessionMetricsPrx, T_SessionMetrics)
-        SessionMetricsPrx::ICE_TYPE = T_SessionMetricsPrx
     end
 end

data/lib/Glacier2/PermissionsVerifier.rb

@@ -1,14 +1,14 @@
 # encoding: utf-8
 # **********************************************************************
 #
-# Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+# Copyright (c) 2003-2017 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.
 #
 # **********************************************************************
 #
-# Ice version 3.6.5
+# Ice version 3.7.0
 #
 # <auto-generated>
 #
@@ -22,7 +22,7 @@
 require 'Ice'
 require 'Glacier2/SSLInfo.rb'
 
-module ::Glacier2
+module Glacier2
 
     if not defined?(::Glacier2::PermissionDeniedException)
         class PermissionDeniedException < Ice::UserException
@@ -31,139 +31,68 @@ module ::Glacier2
             end
 
             def to_s
-                'Glacier2::PermissionDeniedException'
+                '::Glacier2::PermissionDeniedException'
             end
 
             attr_accessor :reason
         end
 
         T_PermissionDeniedException = ::Ice::__defineException('::Glacier2::PermissionDeniedException', PermissionDeniedException, true, nil, [["reason", ::Ice::T_string, false, 0]])
-        PermissionDeniedException::ICE_TYPE = T_PermissionDeniedException
     end
 
-    if not defined?(::Glacier2::PermissionsVerifier_mixin)
-        module PermissionsVerifier_mixin
-            include ::Ice::Object_mixin
+    if not defined?(::Glacier2::PermissionsVerifier_Mixin)
 
-            def ice_ids(current=nil)
-                ['::Glacier2::PermissionsVerifier', '::Ice::Object']
-            end
-
-            def ice_id(current=nil)
-                '::Glacier2::PermissionsVerifier'
-            end
-
-            #
-            # Operation signatures.
-            #
-            # def checkPermissions(userId, password, current=nil)
-
-            def inspect
-                ::Ice::__stringify(self, T_PermissionsVerifier)
-            end
-        end
-        class PermissionsVerifier
-            include PermissionsVerifier_mixin
-            
-            def PermissionsVerifier.ice_staticId()
-                '::Glacier2::PermissionsVerifier'
-            end
+        module ::Glacier2::PermissionsVerifier_Mixin
         end
         module PermissionsVerifierPrx_mixin
 
-            def checkPermissions(userId, password, _ctx=nil)
-                PermissionsVerifier_mixin::OP_checkPermissions.invoke(self, [userId, password], _ctx)
+            def checkPermissions(userId, password, context=nil)
+                PermissionsVerifierPrx_mixin::OP_checkPermissions.invoke(self, [userId, password], context)
             end
         end
+
         class PermissionsVerifierPrx < ::Ice::ObjectPrx
+            include ::Ice::Proxy_mixin
             include PermissionsVerifierPrx_mixin
-
-            def PermissionsVerifierPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
-                ice_checkedCast(proxy, '::Glacier2::PermissionsVerifier', facetOrCtx, _ctx)
-            end
-
-            def PermissionsVerifierPrx.uncheckedCast(proxy, facet=nil)
-                ice_uncheckedCast(proxy, facet)
-            end
-            def PermissionsVerifierPrx.ice_staticId()
-                '::Glacier2::PermissionsVerifier'
-            end
         end
 
-        if not defined?(::Glacier2::T_PermissionsVerifier)
+        if not defined?(::Glacier2::T_PermissionsVerifierPrx)
             T_PermissionsVerifier = ::Ice::__declareClass('::Glacier2::PermissionsVerifier')
             T_PermissionsVerifierPrx = ::Ice::__declareProxy('::Glacier2::PermissionsVerifier')
         end
 
-        T_PermissionsVerifier.defineClass(PermissionsVerifier, -1, true, false, nil, [], [])
-        PermissionsVerifier_mixin::ICE_TYPE = T_PermissionsVerifier
+        T_PermissionsVerifier.defineClass(::Ice::Value, -1, false, true, nil, [])
 
-        T_PermissionsVerifierPrx.defineProxy(PermissionsVerifierPrx, T_PermissionsVerifier)
-        PermissionsVerifierPrx::ICE_TYPE = T_PermissionsVerifierPrx
+        T_PermissionsVerifierPrx.defineProxy(PermissionsVerifierPrx, nil, [])
 
-        PermissionsVerifier_mixin::OP_checkPermissions = ::Ice::__defineOperation('checkPermissions', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, ::Ice::FormatType::SlicedFormat, [[::Ice::T_string, false, 0], [::Ice::T_string, false, 0]], [[::Ice::T_string, false, 0]], [::Ice::T_bool, false, 0], [::Glacier2::T_PermissionDeniedException])
+        PermissionsVerifierPrx_mixin::OP_checkPermissions = ::Ice::__defineOperation('checkPermissions', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, ::Ice::FormatType::SlicedFormat, [[::Ice::T_string, false, 0], [::Ice::T_string, false, 0]], [[::Ice::T_string, false, 0]], [::Ice::T_bool, false, 0], [::Glacier2::T_PermissionDeniedException])
     end
 
-    if not defined?(::Glacier2::SSLPermissionsVerifier_mixin)
-        module SSLPermissionsVerifier_mixin
-            include ::Ice::Object_mixin
+    if not defined?(::Glacier2::SSLPermissionsVerifier_Mixin)
 
-            def ice_ids(current=nil)
-                ['::Glacier2::SSLPermissionsVerifier', '::Ice::Object']
-            end
-
-            def ice_id(current=nil)
-                '::Glacier2::SSLPermissionsVerifier'
-            end
-
-            #
-            # Operation signatures.
-            #
-            # def authorize(info, current=nil)
-
-            def inspect
-                ::Ice::__stringify(self, T_SSLPermissionsVerifier)
-            end
-        end
-        class SSLPermissionsVerifier
-            include SSLPermissionsVerifier_mixin
-            
-            def SSLPermissionsVerifier.ice_staticId()
-                '::Glacier2::SSLPermissionsVerifier'
-            end
+        module ::Glacier2::SSLPermissionsVerifier_Mixin
         end
         module SSLPermissionsVerifierPrx_mixin
 
-            def authorize(info, _ctx=nil)
-                SSLPermissionsVerifier_mixin::OP_authorize.invoke(self, [info], _ctx)
+            def authorize(info, context=nil)
+                SSLPermissionsVerifierPrx_mixin::OP_authorize.invoke(self, [info], context)
             end
         end
+
         class SSLPermissionsVerifierPrx < ::Ice::ObjectPrx
+            include ::Ice::Proxy_mixin
             include SSLPermissionsVerifierPrx_mixin
-
-            def SSLPermissionsVerifierPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
-                ice_checkedCast(proxy, '::Glacier2::SSLPermissionsVerifier', facetOrCtx, _ctx)
-            end
-
-            def SSLPermissionsVerifierPrx.uncheckedCast(proxy, facet=nil)
-                ice_uncheckedCast(proxy, facet)
-            end
-            def SSLPermissionsVerifierPrx.ice_staticId()
-                '::Glacier2::SSLPermissionsVerifier'
-            end
         end
 
-        if not defined?(::Glacier2::T_SSLPermissionsVerifier)
+        if not defined?(::Glacier2::T_SSLPermissionsVerifierPrx)
             T_SSLPermissionsVerifier = ::Ice::__declareClass('::Glacier2::SSLPermissionsVerifier')
             T_SSLPermissionsVerifierPrx = ::Ice::__declareProxy('::Glacier2::SSLPermissionsVerifier')
         end
 
-        T_SSLPermissionsVerifier.defineClass(SSLPermissionsVerifier, -1, true, false, nil, [], [])
-        SSLPermissionsVerifier_mixin::ICE_TYPE = T_SSLPermissionsVerifier
+        T_SSLPermissionsVerifier.defineClass(::Ice::Value, -1, false, true, nil, [])
 
-        T_SSLPermissionsVerifierPrx.defineProxy(SSLPermissionsVerifierPrx, T_SSLPermissionsVerifier)
-        SSLPermissionsVerifierPrx::ICE_TYPE = T_SSLPermissionsVerifierPrx
+        T_SSLPermissionsVerifierPrx.defineProxy(SSLPermissionsVerifierPrx, nil, [])
 
-        SSLPermissionsVerifier_mixin::OP_authorize = ::Ice::__defineOperation('authorize', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, ::Ice::FormatType::SlicedFormat, [[::Glacier2::T_SSLInfo, false, 0]], [[::Ice::T_string, false, 0]], [::Ice::T_bool, false, 0], [::Glacier2::T_PermissionDeniedException])
+        SSLPermissionsVerifierPrx_mixin::OP_authorize = ::Ice::__defineOperation('authorize', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, ::Ice::FormatType::SlicedFormat, [[::Glacier2::T_SSLInfo, false, 0]], [[::Ice::T_string, false, 0]], [::Ice::T_bool, false, 0], [::Glacier2::T_PermissionDeniedException])
     end
 end

data/lib/Glacier2/PermissionsVerifierF.rb

@@ -1,14 +1,14 @@
 # encoding: utf-8
 # **********************************************************************
 #
-# Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+# Copyright (c) 2003-2017 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.
 #
 # **********************************************************************
 #
-# Ice version 3.6.5
+# Ice version 3.7.0
 #
 # <auto-generated>
 #
@@ -21,7 +21,7 @@
 
 require 'Ice'
 
-module ::Glacier2
+module Glacier2
 
     if not defined?(::Glacier2::T_PermissionsVerifier)
         T_PermissionsVerifier = ::Ice::__declareClass('::Glacier2::PermissionsVerifier')

data/lib/Glacier2/Router.rb

@@ -1,14 +1,14 @@
 # encoding: utf-8
 # **********************************************************************
 #
-# Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+# Copyright (c) 2003-2017 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.
 #
 # **********************************************************************
 #
-# Ice version 3.6.5
+# Ice version 3.7.0
 #
 # <auto-generated>
 #
@@ -24,7 +24,7 @@ require 'Ice/Router.rb'
 require 'Glacier2/Session.rb'
 require 'Glacier2/PermissionsVerifier.rb'
 
-module ::Glacier2
+module Glacier2
 
     if not defined?(::Glacier2::SessionNotExistException)
         class SessionNotExistException < Ice::UserException
@@ -32,111 +32,69 @@ module ::Glacier2
             end
 
             def to_s
-                'Glacier2::SessionNotExistException'
+                '::Glacier2::SessionNotExistException'
             end
         end
 
         T_SessionNotExistException = ::Ice::__defineException('::Glacier2::SessionNotExistException', SessionNotExistException, false, nil, [])
-        SessionNotExistException::ICE_TYPE = T_SessionNotExistException
     end
 
-    if not defined?(::Glacier2::Router_mixin)
-        module Router_mixin
-            include ::Ice::Object_mixin
+    if not defined?(::Glacier2::Router_Mixin)
 
-            def ice_ids(current=nil)
-                ['::Glacier2::Router', '::Ice::Object', '::Ice::Router']
-            end
-
-            def ice_id(current=nil)
-                '::Glacier2::Router'
-            end
-
-            #
-            # Operation signatures.
-            #
-            # def getCategoryForClient(current=nil)
-            # def createSession(userId, password, current=nil)
-            # def createSessionFromSecureConnection(current=nil)
-            # def refreshSession(current=nil)
-            # def destroySession(current=nil)
-            # def getSessionTimeout(current=nil)
-            # def getACMTimeout(current=nil)
-
-            def inspect
-                ::Ice::__stringify(self, T_Router)
-            end
-        end
-        class Router
-            include Router_mixin
-            
-            def Router.ice_staticId()
-                '::Glacier2::Router'
-            end
+        module ::Glacier2::Router_Mixin
         end
         module RouterPrx_mixin
             include ::Ice::RouterPrx_mixin
 
-            def getCategoryForClient(_ctx=nil)
-                Router_mixin::OP_getCategoryForClient.invoke(self, [], _ctx)
+            def getCategoryForClient(context=nil)
+                RouterPrx_mixin::OP_getCategoryForClient.invoke(self, [], context)
             end
 
-            def createSession(userId, password, _ctx=nil)
-                Router_mixin::OP_createSession.invoke(self, [userId, password], _ctx)
+            def createSession(userId, password, context=nil)
+                RouterPrx_mixin::OP_createSession.invoke(self, [userId, password], context)
             end
 
-            def createSessionFromSecureConnection(_ctx=nil)
-                Router_mixin::OP_createSessionFromSecureConnection.invoke(self, [], _ctx)
+            def createSessionFromSecureConnection(context=nil)
+                RouterPrx_mixin::OP_createSessionFromSecureConnection.invoke(self, [], context)
             end
 
-            def refreshSession(_ctx=nil)
-                Router_mixin::OP_refreshSession.invoke(self, [], _ctx)
+            def refreshSession(context=nil)
+                RouterPrx_mixin::OP_refreshSession.invoke(self, [], context)
             end
 
-            def destroySession(_ctx=nil)
-                Router_mixin::OP_destroySession.invoke(self, [], _ctx)
+            def destroySession(context=nil)
+                RouterPrx_mixin::OP_destroySession.invoke(self, [], context)
             end
 
-            def getSessionTimeout(_ctx=nil)
-                Router_mixin::OP_getSessionTimeout.invoke(self, [], _ctx)
+            def getSessionTimeout(context=nil)
+                RouterPrx_mixin::OP_getSessionTimeout.invoke(self, [], context)
             end
 
-            def getACMTimeout(_ctx=nil)
-                Router_mixin::OP_getACMTimeout.invoke(self, [], _ctx)
+            def getACMTimeout(context=nil)
+                RouterPrx_mixin::OP_getACMTimeout.invoke(self, [], context)
             end
         end
+
         class RouterPrx < ::Ice::ObjectPrx
+            include ::Ice::Proxy_mixin
             include RouterPrx_mixin
-
-            def RouterPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
-                ice_checkedCast(proxy, '::Glacier2::Router', facetOrCtx, _ctx)
-            end
-
-            def RouterPrx.uncheckedCast(proxy, facet=nil)
-                ice_uncheckedCast(proxy, facet)
-            end
-            def RouterPrx.ice_staticId()
-                '::Glacier2::Router'
-            end
         end
 
-        if not defined?(::Glacier2::T_Router)
+        if not defined?(::Glacier2::T_RouterPrx)
             T_Router = ::Ice::__declareClass('::Glacier2::Router')
             T_RouterPrx = ::Ice::__declareProxy('::Glacier2::Router')
         end
 
-        T_Router.defineClass(Router, -1, true, false, nil, [::Ice::T_Router], [])
-        Router_mixin::ICE_TYPE = T_Router
+        T_Router.defineClass(::Ice::Value, -1, false, true, nil, [])
 
-        T_RouterPrx.defineProxy(RouterPrx, T_Router)
-        RouterPrx::ICE_TYPE = T_RouterPrx
+        T_RouterPrx.defineProxy(RouterPrx, nil, [::Ice::T_RouterPrx])
 
-        Router_mixin::OP_getCategoryForClient = ::Ice::__defineOperation('getCategoryForClient', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [], [], [::Ice::T_string, false, 0], [])
-        Router_mixin::OP_createSession = ::Ice::__defineOperation('createSession', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, true, ::Ice::FormatType::SlicedFormat, [[::Ice::T_string, false, 0], [::Ice::T_string, false, 0]], [], [::Glacier2::T_SessionPrx, false, 0], [::Glacier2::T_PermissionDeniedException, ::Glacier2::T_CannotCreateSessionException])
-        Router_mixin::OP_createSessionFromSecureConnection = ::Ice::__defineOperation('createSessionFromSecureConnection', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, true, ::Ice::FormatType::SlicedFormat, [], [], [::Glacier2::T_SessionPrx, false, 0], [::Glacier2::T_PermissionDeniedException, ::Glacier2::T_CannotCreateSessionException])
-        Router_mixin::OP_refreshSession = ::Ice::__defineOperation('refreshSession', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, true, nil, [], [], nil, [::Glacier2::T_SessionNotExistException])
-        Router_mixin::OP_destroySession = ::Ice::__defineOperation('destroySession', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [], [], nil, [::Glacier2::T_SessionNotExistException])
-        Router_mixin::OP_getSessionTimeout = ::Ice::__defineOperation('getSessionTimeout', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [], [], [::Ice::T_long, false, 0], [])
-        Router_mixin::OP_getACMTimeout = ::Ice::__defineOperation('getACMTimeout', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [], [], [::Ice::T_int, false, 0], [])
+        RouterPrx_mixin::OP_getCategoryForClient = ::Ice::__defineOperation('getCategoryForClient', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [], [], [::Ice::T_string, false, 0], [])
+        RouterPrx_mixin::OP_createSession = ::Ice::__defineOperation('createSession', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, true, ::Ice::FormatType::SlicedFormat, [[::Ice::T_string, false, 0], [::Ice::T_string, false, 0]], [], [::Glacier2::T_SessionPrx, false, 0], [::Glacier2::T_PermissionDeniedException, ::Glacier2::T_CannotCreateSessionException])
+        RouterPrx_mixin::OP_createSessionFromSecureConnection = ::Ice::__defineOperation('createSessionFromSecureConnection', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, true, ::Ice::FormatType::SlicedFormat, [], [], [::Glacier2::T_SessionPrx, false, 0], [::Glacier2::T_PermissionDeniedException, ::Glacier2::T_CannotCreateSessionException])
+        RouterPrx_mixin::OP_refreshSession = ::Ice::__defineOperation('refreshSession', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, true, nil, [], [], nil, [::Glacier2::T_SessionNotExistException])
+        RouterPrx_mixin::OP_destroySession = ::Ice::__defineOperation('destroySession', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [], [], nil, [::Glacier2::T_SessionNotExistException])
+        RouterPrx_mixin::OP_getSessionTimeout = ::Ice::__defineOperation('getSessionTimeout', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [], [], [::Ice::T_long, false, 0], [])
+        RouterPrx_mixin::OP_getACMTimeout = ::Ice::__defineOperation('getACMTimeout', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [], [], [::Ice::T_int, false, 0], [])
     end
 end