zeroc-ice 3.6.5 → 3.7.0

data/ext/ice/cpp/include/Ice/ServantManagerF.h

@@ -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/ext/ice/cpp/include/Ice/Service.h

@@ -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.
@@ -10,8 +10,8 @@
 #ifndef ICE_SERVICE_H
 #define ICE_SERVICE_H
 
-#include <IceUtil/Config.h>
-#include <Ice/Ice.h>
+#include <Ice/Initialize.h>
+#include <Ice/LoggerUtil.h>
 
 #ifdef _WIN32
 #   include <winsvc.h>
@@ -60,16 +60,13 @@ public:
     // The return value is an exit status code: EXIT_FAILURE or
     // EXIT_SUCCESS.
     //
-    int main(int&, char*[], const InitializationData& = InitializationData());
-    int main(int, char* const [], const Ice::InitializationData& = Ice::InitializationData());
+    int main(int, const char* const[], const InitializationData& = InitializationData(), int = ICE_INT_VERSION);
 
 #ifdef _WIN32
-
-    int main(int&, wchar_t*[], const InitializationData& = InitializationData());
-
+    int main(int, const wchar_t* const[], const InitializationData& = InitializationData(), int = ICE_INT_VERSION);
 #endif
 
-    int main(StringSeq&, const InitializationData& = InitializationData());
+    int main(const StringSeq&, const InitializationData& = InitializationData(), int = ICE_INT_VERSION);
 
     //
     // Returns the communicator created by the service.
@@ -112,12 +109,10 @@ public:
     // EXIT_SUCCESS.
     //
 #ifdef _WIN32
-    
-    int run(int&, wchar_t*[], const InitializationData& = InitializationData());
-    
+    int run(int, const wchar_t* const[], const InitializationData& = InitializationData(), int = ICE_INT_VERSION);
 #endif
 
-    int run(int&, char*[], const InitializationData& = InitializationData());
+    int run(int, const char* const[], const InitializationData& = InitializationData(), int = ICE_INT_VERSION);
 
 #ifdef _WIN32
 
@@ -171,7 +166,7 @@ protected:
     //
     // Initialize a communicator.
     //
-    virtual Ice::CommunicatorPtr initializeCommunicator(int&, char*[], const InitializationData&);
+    virtual Ice::CommunicatorPtr initializeCommunicator(int&, char*[], const InitializationData&, int);
 
     //
     // Log a system error, which includes a description of the
@@ -225,12 +220,12 @@ private:
     bool _nohup;
     bool _service;
     std::string _name;
-  
+
     static Service* _instance;
 
 #ifdef _WIN32
 
-    int runService(int, char*[], const InitializationData&);
+    int runService(int, const char* const[], const InitializationData&);
     void terminateService(DWORD);
     bool waitForServiceState(SC_HANDLE, DWORD, SERVICE_STATUS&);
     void showServiceStatus(const std::string&, SERVICE_STATUS&);
@@ -241,12 +236,12 @@ private:
 
 public:
 
-    void serviceMain(int, wchar_t*[]);
+    void serviceMain(int, const wchar_t* const[]);
     void control(int);
 
 #else
 
-    int runDaemon(int, char*[], const InitializationData&);
+    int runDaemon(int, char*[], const InitializationData&, int);
 
     bool _changeDirectory;
     bool _closeFiles;

data/ext/ice/cpp/include/Ice/SliceChecksums.h

@@ -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/ext/ice/cpp/include/Ice/SlicedData.h

@@ -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.
@@ -12,6 +12,7 @@
 
 #include <Ice/SlicedDataF.h>
 #include <Ice/GCObject.h>
+#include <Ice/Value.h>
 
 namespace Ice
 {
@@ -19,7 +20,10 @@ namespace Ice
 //
 // SliceInfo encapsulates the details of a slice for an unknown class or exception type.
 //
-struct ICE_API SliceInfo : public ::IceUtil::Shared
+struct ICE_API SliceInfo
+#ifndef ICE_CPP11_MAPPING
+    : public ::IceUtil::Shared
+#endif
 {
     //
     // The Slice type ID for this slice.
@@ -37,9 +41,9 @@ struct ICE_API SliceInfo : public ::IceUtil::Shared
     ::std::vector<Byte> bytes;
 
     //
-    // The Ice objects referenced by this slice.
+    // The class instances referenced by this slice.
     //
-    ::std::vector<ObjectPtr> objects;
+    ::std::vector<ValuePtr> instances;
 
     //
     // Whether or not the slice contains optional members.
@@ -55,43 +59,65 @@ struct ICE_API SliceInfo : public ::IceUtil::Shared
 //
 // SlicedData holds the slices of unknown types.
 //
-class ICE_API SlicedData : public ::IceUtil::Shared
+class ICE_API SlicedData
+#ifndef ICE_CPP11_MAPPING
+    : public ::IceUtil::Shared
+#endif
 {
 public:
 
+#ifndef ICE_CPP11_MAPPING
+    virtual ~SlicedData();
+#endif
+
     SlicedData(const SliceInfoSeq&);
 
     const SliceInfoSeq slices;
 
-    void __gcVisitMembers(IceInternal::GCVisitor&);
+    //
+    // Clear the slices to break potential cyclic references.
+    //
+    void clear();
+
+#ifndef ICE_CPP11_MAPPING
+    void _iceGcVisitMembers(IceInternal::GCVisitor&);
+#endif
+
 };
 
 //
 // Unknown sliced object holds instance of unknown type.
 //
-
-#ifdef __IBMCPP__
-// xlC does not handle properly the public/private multiple inheritance from Object
-class ICE_API UnknownSlicedObject : public IceInternal::GCObject
+class ICE_API UnknownSlicedValue :
+#ifdef ICE_CPP11_MAPPING
+    public Value
 #else
-class ICE_API UnknownSlicedObject : virtual public Object, private IceInternal::GCObject
+    public IceInternal::GCObject
 #endif
 {
 public:
 
-    UnknownSlicedObject(const std::string&);
+    UnknownSlicedValue(const std::string&);
 
-    const std::string& getUnknownTypeId() const;
+#ifdef ICE_CPP11_MAPPING
+    virtual SlicedDataPtr ice_getSlicedData() const override;
+    virtual std::string ice_id() const override;
+    std::shared_ptr<UnknownSlicedValue> ice_clone() const;
 
-    SlicedDataPtr getSlicedData() const;
+    virtual void _iceWrite(::Ice::OutputStream*) const override;
+    virtual void _iceRead(::Ice::InputStream*) override;
 
-    virtual void __gcVisitMembers(IceInternal::GCVisitor&);
+protected:
 
-    virtual void __write(::IceInternal::BasicStream*) const;
-    virtual void __read(::IceInternal::BasicStream*);
-    
-    using Object::__write;
-    using Object::__read;
+    virtual std::shared_ptr<Value> _iceCloneImpl() const override;
+#else
+    virtual SlicedDataPtr ice_getSlicedData() const;
+    virtual const std::string& ice_id(const Current& = Ice::emptyCurrent) const;
+
+    virtual void _iceGcVisitMembers(IceInternal::GCVisitor&);
+    virtual void _iceWrite(::Ice::OutputStream*) const;
+    virtual void _iceRead(::Ice::InputStream*);
+#endif
 
 private:
 

data/ext/ice/cpp/include/Ice/SlicedDataF.h

@@ -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.
@@ -17,17 +17,25 @@ namespace Ice
 {
 
 struct SliceInfo;
+class SlicedData;
+class UnknownSlicedValue;
+
+#ifdef ICE_CPP11_MAPPING
+using SliceInfoPtr = ::std::shared_ptr<SliceInfo>;
+using SlicedDataPtr = ::std::shared_ptr<SlicedData>;
+using UnknownSlicedValuePtr = ::std::shared_ptr<UnknownSlicedValue>;
+#else
 ICE_API IceUtil::Shared* upCast(SliceInfo*);
 typedef IceInternal::Handle<SliceInfo> SliceInfoPtr;
-typedef ::std::vector<SliceInfoPtr> SliceInfoSeq;
 
-class SlicedData;
 ICE_API IceUtil::Shared* upCast(SlicedData*);
 typedef IceInternal::Handle<SlicedData> SlicedDataPtr;
 
-class UnknownSlicedObject;
-ICE_API IceUtil::Shared* upCast(UnknownSlicedObject*);
-typedef IceInternal::Handle<UnknownSlicedObject> UnknownSlicedObjectPtr;
+ICE_API IceUtil::Shared* upCast(UnknownSlicedValue*);
+typedef IceInternal::Handle<UnknownSlicedValue> UnknownSlicedValuePtr;
+#endif
+
+typedef ::std::vector<SliceInfoPtr> SliceInfoSeq;
 
 }
 

data/ext/ice/cpp/include/Ice/StreamHelpers.h

@@ -1,20 +1,22 @@
 // **********************************************************************
 //
-// 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.
 //
 // **********************************************************************
 
-#ifndef ICE_STREAM_TRAITS_H
-#define ICE_STREAM_TRAITS_H
-
-#include <IceUtil/ScopedArray.h>
-#include <IceUtil/Iterator.h>
+#ifndef ICE_STREAM_HELPERS_H
+#define ICE_STREAM_HELPERS_H
 
 #include <Ice/ObjectF.h>
 
+#ifndef ICE_CPP11_MAPPING
+#   include <IceUtil/ScopedArray.h>
+#   include <IceUtil/Iterator.h>
+#endif
+
 namespace Ice
 {
 
@@ -44,19 +46,33 @@ const StreamHelperCategory StreamHelperCategoryUserException = 9;
 // and how it can be skipped by the unmarshaling code if the optional
 // isn't known to the receiver.
 //
+
+#ifdef ICE_CPP11_MAPPING
+enum class OptionalFormat : unsigned char
+{
+    F1 = 0,             // Fixed 1-byte encoding
+    F2 = 1,             // Fixed 2 bytes encoding
+    F4 = 2,             // Fixed 4 bytes encoding
+    F8 = 3,             // Fixed 8 bytes encoding
+    Size = 4,           // "Size encoding" on 1 to 5 bytes, e.g. enum, class identifier
+    VSize = 5,          // "Size encoding" on 1 to 5 bytes followed by data, e.g. string, fixed size
+                        // struct, or containers whose size can be computed prior to marshaling
+    FSize = 6,          // Fixed size on 4 bytes followed by data, e.g. variable-size struct, container.
+    Class = 7
+};
+#else
 enum OptionalFormat
 {
-    OptionalFormatF1 = 0,             // Fixed 1-byte encoding
-    OptionalFormatF2 = 1,             // Fixed 2 bytes encoding
-    OptionalFormatF4 = 2,             // Fixed 4 bytes encoding
-    OptionalFormatF8 = 3,             // Fixed 8 bytes encoding
-    OptionalFormatSize = 4,           // "Size encoding" on 1 to 5 bytes, e.g. enum, class identifier
-    OptionalFormatVSize = 5,          // "Size encoding" on 1 to 5 bytes followed by data, e.g. string, fixed size
-                                      // struct, or containers whose size can be computed prior to marshaling
-    OptionalFormatFSize = 6,          // Fixed size on 4 bytes followed by data, e.g. variable-size struct, container.
+    OptionalFormatF1 = 0,  // see above
+    OptionalFormatF2 = 1,
+    OptionalFormatF4 = 2,
+    OptionalFormatF8 = 3,
+    OptionalFormatSize = 4,
+    OptionalFormatVSize = 5,
+    OptionalFormatFSize = 6,
     OptionalFormatClass = 7
 };
-
+#endif
 
 //
 // Is the provided type a container?
@@ -92,43 +108,87 @@ struct IsMap
     static const bool value = IsContainer<T>::value && sizeof(test<T>(0)) == sizeof(char);
 };
 
+#ifdef ICE_CPP11_MAPPING
+
 //
 // Base traits template.
 // Types with no specialized trait use this trait.
 //
-template<typename T, typename Enabler = void>
+template<typename T,  typename Enabler = void>
 struct StreamableTraits
 {
-    static const StreamHelperCategory helper = IsMap<T>::value ? StreamHelperCategoryDictionary :
-        (IsContainer<T>::value ? StreamHelperCategorySequence : StreamHelperCategoryUnknown);
+    static const StreamHelperCategory helper = StreamHelperCategoryUnknown;
 
     //
     // When extracting a sequence<T> from a stream, we can ensure the
     // stream has at least StreamableTraits<T>::minWireSize * size bytes
     // For containers, the minWireSize is 1 (just 1 byte for an empty container).
     //
-    static const int minWireSize = 1;
+    //static const int minWireSize = 1;
 
     //
     // Is this type encoded on a fixed number of bytes?
     // Used only for marshaling/unmarshaling optional data members and parameters.
     //
+    //static const bool fixedLength = false;
+};
+
+template<typename T>
+struct StreamableTraits<T, typename ::std::enable_if<IsMap<T>::value || IsContainer<T>::value>::type>
+{
+    static const StreamHelperCategory helper = IsMap<T>::value ? StreamHelperCategoryDictionary : StreamHelperCategorySequence;
+    static const int minWireSize = 1;
     static const bool fixedLength = false;
 };
 
+template<typename T>
+struct StreamableTraits<T, typename ::std::enable_if<::std::is_base_of<::Ice::UserException, T>::value>::type>
+{
+    static const StreamHelperCategory helper = StreamHelperCategoryUserException;
+
+    //
+    // There is no sequence/dictionary of UserException (so no need for minWireSize)
+    // and no optional UserException (so no need for fixedLength)
+    //
+};
+
 //
-// StreamableTraits specialization for array / range mapped sequences
-// The type can be a std::pair<T, T> or a
-// std::pair<IceUtil::ScopedArray<T>, std::pair<const T*, const T*> >
+// StreamableTraits specialization for arrays (std::pair<const T*, const T*>).
 //
-template<typename T, typename U>
-struct StreamableTraits< ::std::pair<T, U> >
+template<typename T>
+struct StreamableTraits<std::pair<T*, T*>>
 {
     static const StreamHelperCategory helper = StreamHelperCategorySequence;
     static const int minWireSize = 1;
     static const bool fixedLength = false;
 };
 
+#else
+
+//
+// Base traits template.
+// Types with no specialized trait use this trait.
+//
+template<typename T,  typename Enabler = void>
+struct StreamableTraits
+{
+    static const StreamHelperCategory helper = IsMap<T>::value ? StreamHelperCategoryDictionary :
+        (IsContainer<T>::value ? StreamHelperCategorySequence : StreamHelperCategoryUnknown);
+
+    //
+    // When extracting a sequence<T> from a stream, we can ensure the
+    // stream has at least StreamableTraits<T>::minWireSize * size bytes
+    // For containers, the minWireSize is 1 (just 1 byte for an empty container).
+    //
+    static const int minWireSize = 1;
+
+    //
+    // Is this type encoded on a fixed number of bytes?
+    // Used only for marshaling/unmarshaling optional data members and parameters.
+    //
+    static const bool fixedLength = false;
+};
+
 //
 // StreamableTraits specialization for user exceptions.
 //
@@ -143,6 +203,19 @@ struct StreamableTraits<UserException>
     //
 };
 
+//
+// StreamableTraits specialization for array / range mapped sequences
+// The type can be a std::pair<T, T> or a
+// std::pair<IceUtil::ScopedArray<T>, std::pair<const T*, const T*> >
+//
+template<typename T, typename U>
+struct StreamableTraits< ::std::pair<T, U> >
+{
+    static const StreamHelperCategory helper = StreamHelperCategorySequence;
+    static const int minWireSize = 1;
+    static const bool fixedLength = false;
+};
+#endif
 
 //
 // StreamableTraits specialization for builtins (these are needed for sequence
@@ -232,7 +305,15 @@ struct StreamableTraits< ::std::vector<bool> >
     static const bool fixedLength = false;
 };
 
-
+#ifdef ICE_CPP11_MAPPING
+template<typename T>
+struct StreamableTraits<::std::shared_ptr<T>, typename ::std::enable_if<::std::is_base_of<::Ice::ObjectPrx, T>::value>::type>
+{
+    static const StreamHelperCategory helper = StreamHelperCategoryProxy;
+    static const int minWireSize = 2;
+    static const bool fixedLength = false;
+};
+#else
 template<typename T>
 struct StreamableTraits< ::IceInternal::ProxyHandle<T> >
 {
@@ -240,7 +321,17 @@ struct StreamableTraits< ::IceInternal::ProxyHandle<T> >
     static const int minWireSize = 2;
     static const bool fixedLength = false;
 };
+#endif
 
+#ifdef ICE_CPP11_MAPPING
+template<typename T>
+struct StreamableTraits<::std::shared_ptr<T>, typename ::std::enable_if<::std::is_base_of<::Ice::Value, T>::value>::type>
+{
+    static const StreamHelperCategory helper = StreamHelperCategoryClass;
+    static const int minWireSize = 1;
+    static const bool fixedLength = false;
+};
+#else
 template<typename T>
 struct StreamableTraits< ::IceInternal::Handle<T> >
 {
@@ -248,6 +339,7 @@ struct StreamableTraits< ::IceInternal::Handle<T> >
     static const int minWireSize = 1;
     static const bool fixedLength = false;
 };
+#endif
 
 //
 // StreamHelper templates used by streams to read and write data.
@@ -257,7 +349,6 @@ struct StreamableTraits< ::IceInternal::Handle<T> >
 template<typename T, StreamHelperCategory st>
 struct StreamHelper;
 
-
 // Helper for builtins, delegates read/write to the stream.
 template<typename T>
 struct StreamHelper<T, StreamHelperCategoryBuiltin>
@@ -275,15 +366,35 @@ struct StreamHelper<T, StreamHelperCategoryBuiltin>
     }
 };
 
+//
 // "helpers" for the StreamHelper<T, StreamHelperCategoryStruct[Class]> below
-// We generate specializations, which can be instantiated explicitly and exported from DLLs
+// slice2cpp generates specializations as needed
 //
 
 template<typename T, typename S>
-struct StreamWriter;
+struct StreamWriter
+{
+#ifdef ICE_CPP11_MAPPING
+    static inline void write(S* stream, const T& v)
+    {
+        stream->writeAll(v.ice_tuple());
+    }
+#else
+    static inline void write(S*, const T&)
+    {
+        // Default is to write nothing for C++98
+    }
+#endif
+};
 
 template<typename T, typename S>
-struct StreamReader;
+struct StreamReader
+{
+    static inline void read(S*, T&)
+    {
+        // Default is to read nothing
+    }
+};
 
 // Helper for structs
 template<typename T>
@@ -302,7 +413,6 @@ struct StreamHelper<T, StreamHelperCategoryStruct>
     }
 };
 
-
 // Helper for class structs
 template<typename T>
 struct StreamHelper<T, StreamHelperCategoryStructClass>
@@ -373,7 +483,7 @@ struct StreamHelper<T, StreamHelperCategorySequence>
     }
 };
 
-// Helper for array and range:array custom sequence parameters
+// Helper for array custom sequence parameters
 template<typename T>
 struct StreamHelper<std::pair<const T*, const T*>, StreamHelperCategorySequence>
 {
@@ -390,6 +500,8 @@ struct StreamHelper<std::pair<const T*, const T*>, StreamHelperCategorySequence>
     }
 };
 
+#ifndef ICE_CPP11_MAPPING
+
 // Helper for range custom sequence parameters
 template<typename T>
 struct StreamHelper<std::pair<T, T>, StreamHelperCategorySequence>
@@ -425,8 +537,6 @@ struct StreamHelper<std::pair< ::std::vector<bool>::const_iterator,
             stream->write(static_cast<bool>(*p));
         }
     }
-
-    // no read: only used for marshaling
 };
 
 // Helper for zero-copy array sequence parameters
@@ -441,6 +551,7 @@ struct StreamHelper<std::pair<IceUtil::ScopedArray<T>, std::pair<const T*, const
 
     // no write: only used for unmarshaling
 };
+#endif
 
 // Helper for dictionaries
 template<typename T>
@@ -519,7 +630,6 @@ struct StreamHelper<T, StreamHelperCategoryClass>
     }
 };
 
-
 //
 // Helpers to read/write optional attributes or members.
 //
@@ -536,46 +646,45 @@ struct GetOptionalFormat;
 template<>
 struct GetOptionalFormat<StreamHelperCategoryBuiltin, 1, true>
 {
-    static const OptionalFormat value = OptionalFormatF1;
+    static const OptionalFormat value = ICE_SCOPED_ENUM(OptionalFormat, F1);
 };
 
 template<>
 struct GetOptionalFormat<StreamHelperCategoryBuiltin, 2, true>
 {
-    static const OptionalFormat value = OptionalFormatF2;
+    static const OptionalFormat value = ICE_SCOPED_ENUM(OptionalFormat, F2);
 };
 
 template<>
 struct GetOptionalFormat<StreamHelperCategoryBuiltin, 4, true>
 {
-    static const OptionalFormat value = OptionalFormatF4;
+    static const OptionalFormat value = ICE_SCOPED_ENUM(OptionalFormat, F4);
 };
 
 template<>
 struct GetOptionalFormat<StreamHelperCategoryBuiltin, 8, true>
 {
-    static const OptionalFormat value = OptionalFormatF8;
+    static const OptionalFormat value = ICE_SCOPED_ENUM(OptionalFormat, F8);
 };
 
 template<>
 struct GetOptionalFormat<StreamHelperCategoryBuiltin, 1, false>
 {
-    static const OptionalFormat value = OptionalFormatVSize;
+    static const OptionalFormat value = ICE_SCOPED_ENUM(OptionalFormat, VSize);
 };
 
 template<>
 struct GetOptionalFormat<StreamHelperCategoryClass, 1, false>
 {
-    static const OptionalFormat value = OptionalFormatClass;
+    static const OptionalFormat value = ICE_SCOPED_ENUM(OptionalFormat, Class);
 };
 
 template<int minWireSize>
 struct GetOptionalFormat<StreamHelperCategoryEnum, minWireSize, false>
 {
-    static const OptionalFormat value = OptionalFormatSize;
+    static const OptionalFormat value = ICE_SCOPED_ENUM(OptionalFormat, Size);
 };
 
-
 // Base helper: simply read/write the data
 template<typename T, StreamHelperCategory st, bool fixedLength>
 struct StreamOptionalHelper
@@ -606,7 +715,7 @@ struct StreamOptionalHelper
 template<typename T>
 struct StreamOptionalHelper<T, StreamHelperCategoryStruct, true>
 {
-    static const OptionalFormat optionalFormat = OptionalFormatVSize;
+    static const OptionalFormat optionalFormat = ICE_SCOPED_ENUM(OptionalFormat, VSize);
 
     template<class S> static inline void
     write(S* stream, const T& v)
@@ -627,7 +736,7 @@ struct StreamOptionalHelper<T, StreamHelperCategoryStruct, true>
 template<typename T>
 struct StreamOptionalHelper<T, StreamHelperCategoryStruct, false>
 {
-    static const OptionalFormat optionalFormat = OptionalFormatFSize;
+    static const OptionalFormat optionalFormat = ICE_SCOPED_ENUM(OptionalFormat, FSize);
 
     template<class S> static inline void
     write(S* stream, const T& v)
@@ -657,7 +766,6 @@ struct StreamOptionalHelper<T, StreamHelperCategoryProxy, false> : StreamOptiona
 {
 };
 
-
 //
 // Helpers to read/write optional sequences or dictionaries
 //
@@ -673,7 +781,7 @@ struct StreamOptionalContainerHelper;
 template<typename T, int sz>
 struct StreamOptionalContainerHelper<T, false, sz>
 {
-    static const OptionalFormat optionalFormat = OptionalFormatFSize;
+    static const OptionalFormat optionalFormat = ICE_SCOPED_ENUM(OptionalFormat, FSize);
 
     template<class S> static inline void
     write(S* stream, const T& v, Int)
@@ -696,7 +804,7 @@ struct StreamOptionalContainerHelper<T, false, sz>
 template<typename T, int sz>
 struct StreamOptionalContainerHelper<T, true, sz>
 {
-    static const OptionalFormat optionalFormat = OptionalFormatVSize;
+    static const OptionalFormat optionalFormat = ICE_SCOPED_ENUM(OptionalFormat, VSize);
 
     template<class S> static inline void
     write(S* stream, const T& v, Int n)
@@ -727,7 +835,7 @@ struct StreamOptionalContainerHelper<T, true, sz>
 template<typename T>
 struct StreamOptionalContainerHelper<T, true, 1>
 {
-    static const OptionalFormat optionalFormat = OptionalFormatVSize;
+    static const OptionalFormat optionalFormat = ICE_SCOPED_ENUM(OptionalFormat, VSize);
 
     template<class S> static inline void
     write(S* stream, const T& v, Int)
@@ -742,7 +850,6 @@ struct StreamOptionalContainerHelper<T, true, 1>
     }
 };
 
-
 //
 // Helper to write sequences, delegates to the optional container
 // helper template partial specializations.
@@ -796,6 +903,8 @@ struct StreamOptionalHelper<std::pair<const T*, const T*>, StreamHelperCategoryS
     }
 };
 
+#ifndef ICE_CPP11_MAPPING
+
 template<typename T>
 struct StreamOptionalHelper<std::pair<T, T>, StreamHelperCategorySequence, false>
 {
@@ -841,6 +950,7 @@ struct StreamOptionalHelper<std::pair<IceUtil::ScopedArray<T>, std::pair<const T
 
     // no write: only used for unmarshaling
 };
+#endif
 
 //
 // Helper to write dictionaries, delegates to the optional container