New C++11 optional mapping

21 files changed, 2355 insertions, 361 deletions

diff --git a/cpp/allTests.py b/cpp/allTests.py
index 619e67c5427..937155a6455 100755
--- a/cpp/allTests.py
+++ b/cpp/allTests.py
@@ -47,7 +47,7 @@ tests = [
     ("Ice/inheritance", ["core", "bt"]),
     ("Ice/facets", ["core", "bt"]),
     ("Ice/objects", ["core", "bt"]),
-    ("Ice/optional", ["core", "bt", "noc++11"]),
+    ("Ice/optional", ["core", "bt"]),
     ("Ice/binding", ["core", "nosocks", "bt"]),
     ("Ice/faultTolerance", ["core", "novalgrind"]), # valgrind reports leak with aborted servers
     ("Ice/location", ["core"]),
diff --git a/cpp/config/Make.rules b/cpp/config/Make.rules
index 0fe6fe8a16e..933f2064fd3 100644
--- a/cpp/config/Make.rules
+++ b/cpp/config/Make.rules
@@ -67,7 +67,6 @@ cpp11_projects		= test/Common \
 			  test/IceBox/%
 
 cpp11_excludes  	= IcePatch2 \
-			  test/Ice/optional \
 			  test/Ice/gc \
 			  test/Ice/echo
 
diff --git a/cpp/include/Ice/Ice.h b/cpp/include/Ice/Ice.h
index 92ac30b9c47..23d9ee6236e 100644
--- a/cpp/include/Ice/Ice.h
+++ b/cpp/include/Ice/Ice.h
@@ -14,6 +14,7 @@
 #include <Ice/Config.h>
 #include <Ice/Comparable.h>
 #include <Ice/Initialize.h>
+#include <Ice/Optional.h>
 #include <Ice/LocalException.h>
 #include <Ice/PropertiesAdmin.h>
 #include <Ice/Properties.h>
diff --git a/cpp/include/Ice/InputStream.h b/cpp/include/Ice/InputStream.h
index e6b08af4314..7a7ae8e2712 100644
--- a/cpp/include/Ice/InputStream.h
+++ b/cpp/include/Ice/InputStream.h
@@ -383,7 +383,11 @@ public:
                                              StreamableTraits<T>::helper,
                                              StreamableTraits<T>::fixedLength>::optionalFormat))
         {
+#ifdef ICE_CPP11_MAPPING
+            v.emplace();
+#else
             v.__setIsSet();
+#endif
             StreamOptionalHelper<T,
                                  StreamableTraits<T>::helper,
                                  StreamableTraits<T>::fixedLength>::read(this, *v);
diff --git a/cpp/include/Ice/Optional.h b/cpp/include/Ice/Optional.h
new file mode 100644
index 00000000000..7ab17c3deab
--- /dev/null
+++ b/cpp/include/Ice/Optional.h
@@ -0,0 +1,1107 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2016 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::optional is a placeholder std::optional:
+// http://en.cppreference.com/w/cpp/utility/optional/optional
+//
+// This implementation is a slighly modified version of Optional.hpp,
+// published at https://github.com/akrzemi1/Optional
+// commit 3922965396fc455c6b1770374b9b4111799588a9
+
+// Copyright (C) 2011 - 2012 Andrzej Krzemienski.
+//
+// Use, modification, and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// The idea and interface is based on Boost.Optional library
+// authored by Fernando Luis Cacciola Carballal
+
+#ifndef ICE_OPTIONAL_H
+#define ICE_OPTIONAL_H
+
+#ifdef ICE_CPP11_MAPPING
+
+# include <utility>
+# include <type_traits>
+# include <initializer_list>
+# include <cassert>
+# include <functional>
+# include <string>
+# include <stdexcept>
+
+# define TR2_OPTIONAL_REQUIRES(...) typename enable_if<__VA_ARGS__::value, bool>::type = false
+
+# if defined __GNUC__ // NOTE: GNUC is also defined for Clang
+#   if (__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)
+#     define TR2_OPTIONAL_GCC_4_8_AND_HIGHER___
+#   elif (__GNUC__ > 4)
+#     define TR2_OPTIONAL_GCC_4_8_AND_HIGHER___
+#   endif
+#
+#   if (__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)
+#     define TR2_OPTIONAL_GCC_4_7_AND_HIGHER___
+#   elif (__GNUC__ > 4)
+#     define TR2_OPTIONAL_GCC_4_7_AND_HIGHER___
+#   endif
+#
+#   if (__GNUC__ == 4) && (__GNUC_MINOR__ == 8) && (__GNUC_PATCHLEVEL__ >= 1)
+#     define TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___
+#   elif (__GNUC__ == 4) && (__GNUC_MINOR__ >= 9)
+#     define TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___
+#   elif (__GNUC__ > 4)
+#     define TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___
+#   endif
+# endif
+#
+# if defined __clang_major__
+#   if (__clang_major__ == 3 && __clang_minor__ >= 5)
+#     define TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_
+#   elif (__clang_major__ > 3)
+#     define TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_
+#   endif
+#   if defined TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_
+#     define TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_
+#   elif (__clang_major__ == 3 && __clang_minor__ == 4 && __clang_patchlevel__ >= 2)
+#     define TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_
+#   endif
+# endif
+#
+# if defined _MSC_VER
+#   if (_MSC_VER >= 1900)
+#     define TR2_OPTIONAL_MSVC_2015_AND_HIGHER___
+#   endif
+# endif
+
+# if defined __clang__
+#   if (__clang_major__ > 2) || (__clang_major__ == 2) && (__clang_minor__ >= 9)
+#     define OPTIONAL_HAS_THIS_RVALUE_REFS 1
+#   else
+#     define OPTIONAL_HAS_THIS_RVALUE_REFS 0
+#   endif
+# elif defined TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___
+#   define OPTIONAL_HAS_THIS_RVALUE_REFS 1
+# elif defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___
+#   define OPTIONAL_HAS_THIS_RVALUE_REFS 1
+# else
+#   define OPTIONAL_HAS_THIS_RVALUE_REFS 0
+# endif
+
+
+# if defined TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___
+#   define OPTIONAL_HAS_CONSTEXPR_INIT_LIST 1
+#   define OPTIONAL_CONSTEXPR_INIT_LIST constexpr
+# else
+#   define OPTIONAL_HAS_CONSTEXPR_INIT_LIST 0
+#   define OPTIONAL_CONSTEXPR_INIT_LIST
+# endif
+
+# if defined TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_ && (defined __cplusplus) && (__cplusplus != 201103L)
+#   define OPTIONAL_HAS_MOVE_ACCESSORS 1
+# else
+#   define OPTIONAL_HAS_MOVE_ACCESSORS 0
+# endif
+
+# // In C++11 constexpr implies const, so we need to make non-const members also non-constexpr
+# if (defined __cplusplus) && (__cplusplus == 201103L)
+#   define OPTIONAL_MUTABLE_CONSTEXPR
+# else
+#   define OPTIONAL_MUTABLE_CONSTEXPR constexpr
+# endif
+
+namespace std{
+
+namespace experimental{
+
+//
+// Add namespace Ice to avoid conflict with other std::experimental::optional
+// implementation
+//
+namespace Ice{
+
+// BEGIN workaround for missing is_trivially_destructible
+# if defined TR2_OPTIONAL_GCC_4_8_AND_HIGHER___
+    // leave it: it is already there
+# elif defined TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_
+    // leave it: it is already there
+# elif defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___
+    // leave it: it is already there
+# elif defined TR2_OPTIONAL_DISABLE_EMULATION_OF_TYPE_TRAITS
+    // leave it: the user doesn't want it
+# else
+        template <typename T>
+        using is_trivially_destructible = std::has_trivial_destructor<T>;
+# endif
+// END workaround for missing is_trivially_destructible
+
+# if (defined TR2_OPTIONAL_GCC_4_7_AND_HIGHER___)
+    // leave it; our metafunctions are already defined.
+# elif defined TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_
+    // leave it; our metafunctions are already defined.
+# elif defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___
+    // leave it: it is already there
+# elif defined TR2_OPTIONAL_DISABLE_EMULATION_OF_TYPE_TRAITS
+    // leave it: the user doesn't want it
+# else
+
+
+// workaround for missing traits in GCC and CLANG
+template <class T>
+struct is_nothrow_move_constructible
+{
+  constexpr static bool value = std::is_nothrow_constructible<T, T&&>::value;
+};
+
+
+template <class T, class U>
+struct is_assignable
+{
+  template <class X, class Y>
+  constexpr static bool has_assign(...) { return false; }
+
+  template <class X, class Y, size_t S = sizeof((std::declval<X>() = std::declval<Y>(), true)) >
+  // the comma operator is necessary for the cases where operator= returns void
+  constexpr static bool has_assign(bool) { return true; }
+
+  constexpr static bool value = has_assign<T, U>(true);
+};
+
+
+template <class T>
+struct is_nothrow_move_assignable
+{
+  template <class X, bool has_any_move_assign>
+  struct has_nothrow_move_assign {
+    constexpr static bool value = false;
+  };
+
+  template <class X>
+  struct has_nothrow_move_assign<X, true> {
+    constexpr static bool value = noexcept( std::declval<X&>() = std::declval<X&&>() );
+  };
+
+  constexpr static bool value = has_nothrow_move_assign<T, is_assignable<T&, T&&>::value>::value;
+};
+// end workaround
+
+
+# endif
+
+
+
+// 20.5.4, optional for object types
+template <class T> class optional;
+
+// 20.5.5, optional for lvalue reference types
+template <class T> class optional<T&>;
+
+
+// workaround: std utility functions aren't constexpr yet
+template <class T> inline constexpr T&& constexpr_forward(typename std::remove_reference<T>::type& t) noexcept
+{
+  return static_cast<T&&>(t);
+}
+
+template <class T> inline constexpr T&& constexpr_forward(typename std::remove_reference<T>::type&& t) noexcept
+{
+    static_assert(!std::is_lvalue_reference<T>::value, "!!");
+    return static_cast<T&&>(t);
+}
+
+template <class T> inline constexpr typename std::remove_reference<T>::type&& constexpr_move(T&& t) noexcept
+{
+    return static_cast<typename std::remove_reference<T>::type&&>(t);
+}
+
+
+#if defined NDEBUG
+# define TR2_OPTIONAL_ASSERTED_EXPRESSION(CHECK, EXPR) (EXPR)
+#else
+# define TR2_OPTIONAL_ASSERTED_EXPRESSION(CHECK, EXPR) ((CHECK) ? (EXPR) : ([]{assert(!#CHECK);}(), (EXPR)))
+#endif
+
+
+namespace detail_
+{
+
+// static_addressof: a constexpr version of addressof
+template <typename T>
+struct has_overloaded_addressof
+{
+  template <class X>
+  constexpr static bool has_overload(...) { return false; }
+
+  template <class X, size_t S = sizeof(std::declval<X&>().operator&()) >
+  constexpr static bool has_overload(bool) { return true; }
+
+  constexpr static bool value = has_overload<T>(true);
+};
+
+template <typename T, TR2_OPTIONAL_REQUIRES(!has_overloaded_addressof<T>)>
+constexpr T* static_addressof(T& ref)
+{
+  return &ref;
+}
+
+template <typename T, TR2_OPTIONAL_REQUIRES(has_overloaded_addressof<T>)>
+T* static_addressof(T& ref)
+{
+  return std::addressof(ref);
+}
+
+
+// the call to convert<A>(b) has return type A and converts b to type A iff b decltype(b) is implicitly convertible to A
+template <class U>
+constexpr U convert(U v) { return v; }
+
+} // namespace detail
+
+
+constexpr struct trivial_init_t{} trivial_init{};
+
+
+// 20.5.6, In-place construction
+constexpr struct in_place_t{} in_place{};
+
+
+// 20.5.7, Disengaged state indicator
+struct nullopt_t
+{
+  struct init{};
+  constexpr explicit nullopt_t(init){}
+};
+constexpr nullopt_t nullopt{nullopt_t::init()};
+
+
+// 20.5.8, class bad_optional_access
+class bad_optional_access : public logic_error {
+public:
+  explicit bad_optional_access(const string& what_arg) : logic_error{what_arg} {}
+  explicit bad_optional_access(const char* what_arg) : logic_error{what_arg} {}
+};
+
+
+template <class T>
+union storage_t
+{
+  unsigned char dummy_;
+  T value_;
+
+  constexpr storage_t( trivial_init_t ) noexcept : dummy_() {};
+
+  template <class... Args>
+  constexpr storage_t( Args&&... args ) : value_(constexpr_forward<Args>(args)...) {}
+
+  ~storage_t(){}
+};
+
+
+template <class T>
+union constexpr_storage_t
+{
+    unsigned char dummy_;
+    T value_;
+
+    constexpr constexpr_storage_t( trivial_init_t ) noexcept : dummy_() {};
+
+    template <class... Args>
+    constexpr constexpr_storage_t( Args&&... args ) : value_(constexpr_forward<Args>(args)...) {}
+
+    ~constexpr_storage_t() = default;
+};
+
+
+template <class T>
+struct optional_base
+{
+    bool init_;
+    storage_t<T> storage_;
+
+    constexpr optional_base() noexcept : init_(false), storage_(trivial_init) {};
+
+    explicit constexpr optional_base(const T& v) : init_(true), storage_(v) {}
+
+    explicit constexpr optional_base(T&& v) : init_(true), storage_(constexpr_move(v)) {}
+
+    template <class... Args> explicit optional_base(in_place_t, Args&&... args)
+        : init_(true), storage_(constexpr_forward<Args>(args)...) {}
+
+    template <class U, class... Args, TR2_OPTIONAL_REQUIRES(is_constructible<T, std::initializer_list<U>>)>
+    explicit optional_base(in_place_t, std::initializer_list<U> il, Args&&... args)
+        : init_(true), storage_(il, std::forward<Args>(args)...) {}
+
+    ~optional_base() { if (init_) storage_.value_.T::~T(); }
+};
+
+
+template <class T>
+struct constexpr_optional_base
+{
+    bool init_;
+    constexpr_storage_t<T> storage_;
+
+    constexpr constexpr_optional_base() noexcept : init_(false), storage_(trivial_init) {};
+
+    explicit constexpr constexpr_optional_base(const T& v) : init_(true), storage_(v) {}
+
+    explicit constexpr constexpr_optional_base(T&& v) : init_(true), storage_(constexpr_move(v)) {}
+
+    template <class... Args> explicit constexpr constexpr_optional_base(in_place_t, Args&&... args)
+      : init_(true), storage_(constexpr_forward<Args>(args)...) {}
+
+    template <class U, class... Args, TR2_OPTIONAL_REQUIRES(is_constructible<T, std::initializer_list<U>>)>
+    OPTIONAL_CONSTEXPR_INIT_LIST explicit constexpr_optional_base(in_place_t, std::initializer_list<U> il, Args&&... args)
+      : init_(true), storage_(il, std::forward<Args>(args)...) {}
+
+    ~constexpr_optional_base() = default;
+};
+
+template <class T>
+using OptionalBase = typename std::conditional<
+    is_trivially_destructible<T>::value,
+    constexpr_optional_base<typename std::remove_const<T>::type>,
+    optional_base<typename std::remove_const<T>::type>
+>::type;
+
+
+
+template <class T>
+class optional : private OptionalBase<T>
+{
+  static_assert( !std::is_same<typename std::decay<T>::type, nullopt_t>::value, "bad T" );
+  static_assert( !std::is_same<typename std::decay<T>::type, in_place_t>::value, "bad T" );
+
+
+  constexpr bool initialized() const noexcept { return OptionalBase<T>::init_; }
+  typename std::remove_const<T>::type* dataptr() {  return std::addressof(OptionalBase<T>::storage_.value_); }
+  constexpr const T* dataptr() const { return detail_::static_addressof(OptionalBase<T>::storage_.value_); }
+
+# if OPTIONAL_HAS_THIS_RVALUE_REFS == 1
+  constexpr const T& contained_val() const& { return OptionalBase<T>::storage_.value_; }
+#   if OPTIONAL_HAS_MOVE_ACCESSORS == 1
+  OPTIONAL_MUTABLE_CONSTEXPR T&& contained_val() && { return std::move(OptionalBase<T>::storage_.value_); }
+  OPTIONAL_MUTABLE_CONSTEXPR T& contained_val() & { return OptionalBase<T>::storage_.value_; }
+#   else
+  T& contained_val() & { return OptionalBase<T>::storage_.value_; }
+  T&& contained_val() && { return std::move(OptionalBase<T>::storage_.value_); }
+#   endif
+# else
+  constexpr const T& contained_val() const { return OptionalBase<T>::storage_.value_; }
+  T& contained_val() { return OptionalBase<T>::storage_.value_; }
+# endif
+
+  void clear() noexcept {
+    if (initialized()) dataptr()->T::~T();
+    OptionalBase<T>::init_ = false;
+  }
+
+  template <class... Args>
+  void initialize(Args&&... args) noexcept(noexcept(T(std::forward<Args>(args)...)))
+  {
+    assert(!OptionalBase<T>::init_);
+    ::new (static_cast<void*>(dataptr())) T(std::forward<Args>(args)...);
+    OptionalBase<T>::init_ = true;
+  }
+
+  template <class U, class... Args>
+  void initialize(std::initializer_list<U> il, Args&&... args) noexcept(noexcept(T(il, std::forward<Args>(args)...)))
+  {
+    assert(!OptionalBase<T>::init_);
+    ::new (static_cast<void*>(dataptr())) T(il, std::forward<Args>(args)...);
+    OptionalBase<T>::init_ = true;
+  }
+
+public:
+  typedef T value_type;
+
+  // 20.5.5.1, constructors
+  constexpr optional() noexcept : OptionalBase<T>()  {};
+  constexpr optional(nullopt_t) noexcept : OptionalBase<T>() {};
+
+  optional(const optional& rhs)
+  : OptionalBase<T>()
+  {
+    if (rhs.initialized()) {
+        ::new (static_cast<void*>(dataptr())) T(*rhs);
+        OptionalBase<T>::init_ = true;
+    }
+  }
+
+  optional(optional&& rhs) noexcept(is_nothrow_move_constructible<T>::value)
+  : OptionalBase<T>()
+  {
+    if (rhs.initialized()) {
+        ::new (static_cast<void*>(dataptr())) T(std::move(*rhs));
+        OptionalBase<T>::init_ = true;
+    }
+  }
+
+  constexpr optional(const T& v) : OptionalBase<T>(v) {}
+
+  constexpr optional(T&& v) : OptionalBase<T>(constexpr_move(v)) {}
+
+  template <class... Args>
+  explicit constexpr optional(in_place_t, Args&&... args)
+  : OptionalBase<T>(in_place_t{}, constexpr_forward<Args>(args)...) {}
+
+  template <class U, class... Args, TR2_OPTIONAL_REQUIRES(is_constructible<T, std::initializer_list<U>>)>
+  OPTIONAL_CONSTEXPR_INIT_LIST explicit optional(in_place_t, std::initializer_list<U> il, Args&&... args)
+  : OptionalBase<T>(in_place_t{}, il, constexpr_forward<Args>(args)...) {}
+
+  // 20.5.4.2, Destructor
+  ~optional() = default;
+
+  // 20.5.4.3, assignment
+  optional& operator=(nullopt_t) noexcept
+  {
+    clear();
+    return *this;
+  }
+
+  optional& operator=(const optional& rhs)
+  {
+    if      (initialized() == true  && rhs.initialized() == false) clear();
+    else if (initialized() == false && rhs.initialized() == true)  initialize(*rhs);
+    else if (initialized() == true  && rhs.initialized() == true)  contained_val() = *rhs;
+    return *this;
+  }
+
+  optional& operator=(optional&& rhs)
+  noexcept(is_nothrow_move_assignable<T>::value && is_nothrow_move_constructible<T>::value)
+  {
+    if      (initialized() == true  && rhs.initialized() == false) clear();
+    else if (initialized() == false && rhs.initialized() == true)  initialize(std::move(*rhs));
+    else if (initialized() == true  && rhs.initialized() == true)  contained_val() = std::move(*rhs);
+    return *this;
+  }
+
+  template <class U>
+  auto operator=(U&& v)
+  -> typename enable_if
+  <
+    is_same<typename decay<U>::type, T>::value,
+    optional&
+  >::type
+  {
+    if (initialized()) { contained_val() = std::forward<U>(v); }
+    else               { initialize(std::forward<U>(v));  }
+    return *this;
+  }
+
+
+  template <class... Args>
+  void emplace(Args&&... args)
+  {
+    clear();
+    initialize(std::forward<Args>(args)...);
+  }
+
+  template <class U, class... Args>
+  void emplace(initializer_list<U> il, Args&&... args)
+  {
+    clear();
+    initialize<U, Args...>(il, std::forward<Args>(args)...);
+  }
+
+  // 20.5.4.4, Swap
+  void swap(optional<T>& rhs) noexcept(is_nothrow_move_constructible<T>::value && noexcept(swap(declval<T&>(), declval<T&>())))
+  {
+    if      (initialized() == true  && rhs.initialized() == false) { rhs.initialize(std::move(**this)); clear(); }
+    else if (initialized() == false && rhs.initialized() == true)  { initialize(std::move(*rhs)); rhs.clear(); }
+    else if (initialized() == true  && rhs.initialized() == true)  { using std::swap; swap(**this, *rhs); }
+  }
+
+  // 20.5.4.5, Observers
+
+  explicit constexpr operator bool() const noexcept { return initialized(); }
+
+  constexpr T const* operator ->() const {
+    return TR2_OPTIONAL_ASSERTED_EXPRESSION(initialized(), dataptr());
+  }
+
+# if OPTIONAL_HAS_MOVE_ACCESSORS == 1
+
+  OPTIONAL_MUTABLE_CONSTEXPR T* operator ->() {
+    assert (initialized());
+    return dataptr();
+  }
+
+  constexpr T const& operator *() const& {
+    return TR2_OPTIONAL_ASSERTED_EXPRESSION(initialized(), contained_val());
+  }
+
+  OPTIONAL_MUTABLE_CONSTEXPR T& operator *() & {
+    assert (initialized());
+    return contained_val();
+  }
+
+  OPTIONAL_MUTABLE_CONSTEXPR T&& operator *() && {
+    assert (initialized());
+    return constexpr_move(contained_val());
+  }
+
+  constexpr T const& value() const& {
+    return initialized() ? contained_val() : (throw bad_optional_access("bad optional access"), contained_val());
+  }
+
+  OPTIONAL_MUTABLE_CONSTEXPR T& value() & {
+    return initialized() ? contained_val() : (throw bad_optional_access("bad optional access"), contained_val());
+  }
+
+  OPTIONAL_MUTABLE_CONSTEXPR T&& value() && {
+    if (!initialized()) throw bad_optional_access("bad optional access");
+        return std::move(contained_val());
+  }
+
+# else
+
+  T* operator ->() {
+    assert (initialized());
+    return dataptr();
+  }
+
+  constexpr T const& operator *() const {
+    return TR2_OPTIONAL_ASSERTED_EXPRESSION(initialized(), contained_val());
+  }
+
+  T& operator *() {
+    assert (initialized());
+    return contained_val();
+  }
+
+  constexpr T const& value() const {
+    return initialized() ? contained_val() : (throw bad_optional_access("bad optional access"), contained_val());
+  }
+
+  T& value() {
+    return initialized() ? contained_val() : (throw bad_optional_access("bad optional access"), contained_val());
+  }
+
+# endif
+
+# if OPTIONAL_HAS_THIS_RVALUE_REFS == 1
+
+  template <class V>
+  constexpr T value_or(V&& v) const&
+  {
+    return *this ? **this : detail_::convert<T>(constexpr_forward<V>(v));
+  }
+
+#   if OPTIONAL_HAS_MOVE_ACCESSORS == 1
+
+  template <class V>
+  OPTIONAL_MUTABLE_CONSTEXPR T value_or(V&& v) &&
+  {
+    return *this ? constexpr_move(const_cast<optional<T>&>(*this).contained_val()) : detail_::convert<T>(constexpr_forward<V>(v));
+  }
+
+#   else
+
+  template <class V>
+  T value_or(V&& v) &&
+  {
+    return *this ? constexpr_move(const_cast<optional<T>&>(*this).contained_val()) : detail_::convert<T>(constexpr_forward<V>(v));
+  }
+
+#   endif
+
+# else
+
+  template <class V>
+  constexpr T value_or(V&& v) const
+  {
+    return *this ? **this : detail_::convert<T>(constexpr_forward<V>(v));
+  }
+
+# endif
+
+};
+
+
+template <class T>
+class optional<T&>
+{
+  static_assert( !std::is_same<T, nullopt_t>::value, "bad T" );
+  static_assert( !std::is_same<T, in_place_t>::value, "bad T" );
+  T* ref;
+
+public:
+
+  // 20.5.5.1, construction/destruction
+  constexpr optional() noexcept : ref(nullptr) {}
+
+  constexpr optional(nullopt_t) noexcept : ref(nullptr) {}
+
+  constexpr optional(T& v) noexcept : ref(detail_::static_addressof(v)) {}
+
+  optional(T&&) = delete;
+
+  constexpr optional(const optional& rhs) noexcept : ref(rhs.ref) {}
+
+  explicit constexpr optional(in_place_t, T& v) noexcept : ref(detail_::static_addressof(v)) {}
+
+  explicit optional(in_place_t, T&&) = delete;
+
+  ~optional() = default;
+
+  // 20.5.5.2, mutation
+  optional& operator=(nullopt_t) noexcept {
+    ref = nullptr;
+    return *this;
+  }
+
+  // optional& operator=(const optional& rhs) noexcept {
+    // ref = rhs.ref;
+    // return *this;
+  // }
+
+  // optional& operator=(optional&& rhs) noexcept {
+    // ref = rhs.ref;
+    // return *this;
+  // }
+
+  template <typename U>
+  auto operator=(U&& rhs) noexcept
+  -> typename enable_if
+  <
+    is_same<typename decay<U>::type, optional<T&>>::value,
+    optional&
+  >::type
+  {
+    ref = rhs.ref;
+    return *this;
+  }
+
+  template <typename U>
+  auto operator=(U&& rhs) noexcept
+  -> typename enable_if
+  <
+    !is_same<typename decay<U>::type, optional<T&>>::value,
+    optional&
+  >::type
+  = delete;
+
+  void emplace(T& v) noexcept {
+    ref = detail_::static_addressof(v);
+  }
+
+  void emplace(T&&) = delete;
+
+
+  void swap(optional<T&>& rhs) noexcept
+  {
+    std::swap(ref, rhs.ref);
+  }
+
+  // 20.5.5.3, observers
+  constexpr T* operator->() const {
+    return TR2_OPTIONAL_ASSERTED_EXPRESSION(ref, ref);
+  }
+
+  constexpr T& operator*() const {
+    return TR2_OPTIONAL_ASSERTED_EXPRESSION(ref, *ref);
+  }
+
+  constexpr T& value() const {
+    return ref ? *ref : (throw bad_optional_access("bad optional access"), *ref);
+  }
+
+  explicit constexpr operator bool() const noexcept {
+    return ref != nullptr;
+  }
+
+  template <class V>
+  constexpr typename decay<T>::type value_or(V&& v) const
+  {
+    return *this ? **this : detail_::convert<typename decay<T>::type>(constexpr_forward<V>(v));
+  }
+};
+
+
+template <class T>
+class optional<T&&>
+{
+  static_assert( sizeof(T) == 0, "optional rvalue references disallowed" );
+};
+
+
+// 20.5.8, Relational operators
+template <class T> constexpr bool operator==(const optional<T>& x, const optional<T>& y)
+{
+  return bool(x) != bool(y) ? false : bool(x) == false ? true : *x == *y;
+}
+
+template <class T> constexpr bool operator!=(const optional<T>& x, const optional<T>& y)
+{
+  return !(x == y);
+}
+
+template <class T> constexpr bool operator<(const optional<T>& x, const optional<T>& y)
+{
+  return (!y) ? false : (!x) ? true : *x < *y;
+}
+
+template <class T> constexpr bool operator>(const optional<T>& x, const optional<T>& y)
+{
+  return (y < x);
+}
+
+template <class T> constexpr bool operator<=(const optional<T>& x, const optional<T>& y)
+{
+  return !(y < x);
+}
+
+template <class T> constexpr bool operator>=(const optional<T>& x, const optional<T>& y)
+{
+  return !(x < y);
+}
+
+
+// 20.5.9, Comparison with nullopt
+template <class T> constexpr bool operator==(const optional<T>& x, nullopt_t) noexcept
+{
+  return (!x);
+}
+
+template <class T> constexpr bool operator==(nullopt_t, const optional<T>& x) noexcept
+{
+  return (!x);
+}
+
+template <class T> constexpr bool operator!=(const optional<T>& x, nullopt_t) noexcept
+{
+  return bool(x);
+}
+
+template <class T> constexpr bool operator!=(nullopt_t, const optional<T>& x) noexcept
+{
+  return bool(x);
+}
+
+template <class T> constexpr bool operator<(const optional<T>&, nullopt_t) noexcept
+{
+  return false;
+}
+
+template <class T> constexpr bool operator<(nullopt_t, const optional<T>& x) noexcept
+{
+  return bool(x);
+}
+
+template <class T> constexpr bool operator<=(const optional<T>& x, nullopt_t) noexcept
+{
+  return (!x);
+}
+
+template <class T> constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept
+{
+  return true;
+}
+
+template <class T> constexpr bool operator>(const optional<T>& x, nullopt_t) noexcept
+{
+  return bool(x);
+}
+
+template <class T> constexpr bool operator>(nullopt_t, const optional<T>&) noexcept
+{
+  return false;
+}
+
+template <class T> constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept
+{
+  return true;
+}
+
+template <class T> constexpr bool operator>=(nullopt_t, const optional<T>& x) noexcept
+{
+  return (!x);
+}
+
+
+
+// 20.5.10, Comparison with T
+template <class T> constexpr bool operator==(const optional<T>& x, const T& v)
+{
+  return bool(x) ? *x == v : false;
+}
+
+template <class T> constexpr bool operator==(const T& v, const optional<T>& x)
+{
+  return bool(x) ? v == *x : false;
+}
+
+template <class T> constexpr bool operator!=(const optional<T>& x, const T& v)
+{
+  return bool(x) ? *x != v : true;
+}
+
+template <class T> constexpr bool operator!=(const T& v, const optional<T>& x)
+{
+  return bool(x) ? v != *x : true;
+}
+
+template <class T> constexpr bool operator<(const optional<T>& x, const T& v)
+{
+  return bool(x) ? *x < v : true;
+}
+
+template <class T> constexpr bool operator>(const T& v, const optional<T>& x)
+{
+  return bool(x) ? v > *x : true;
+}
+
+template <class T> constexpr bool operator>(const optional<T>& x, const T& v)
+{
+  return bool(x) ? *x > v : false;
+}
+
+template <class T> constexpr bool operator<(const T& v, const optional<T>& x)
+{
+  return bool(x) ? v < *x : false;
+}
+
+template <class T> constexpr bool operator>=(const optional<T>& x, const T& v)
+{
+  return bool(x) ? *x >= v : false;
+}
+
+template <class T> constexpr bool operator<=(const T& v, const optional<T>& x)
+{
+  return bool(x) ? v <= *x : false;
+}
+
+template <class T> constexpr bool operator<=(const optional<T>& x, const T& v)
+{
+  return bool(x) ? *x <= v : true;
+}
+
+template <class T> constexpr bool operator>=(const T& v, const optional<T>& x)
+{
+  return bool(x) ? v >= *x : true;
+}
+
+
+// Comparison of optional<T&> with T
+template <class T> constexpr bool operator==(const optional<T&>& x, const T& v)
+{
+  return bool(x) ? *x == v : false;
+}
+
+template <class T> constexpr bool operator==(const T& v, const optional<T&>& x)
+{
+  return bool(x) ? v == *x : false;
+}
+
+template <class T> constexpr bool operator!=(const optional<T&>& x, const T& v)
+{
+  return bool(x) ? *x != v : true;
+}
+
+template <class T> constexpr bool operator!=(const T& v, const optional<T&>& x)
+{
+  return bool(x) ? v != *x : true;
+}
+
+template <class T> constexpr bool operator<(const optional<T&>& x, const T& v)
+{
+  return bool(x) ? *x < v : true;
+}
+
+template <class T> constexpr bool operator>(const T& v, const optional<T&>& x)
+{
+  return bool(x) ? v > *x : true;
+}
+
+template <class T> constexpr bool operator>(const optional<T&>& x, const T& v)
+{
+  return bool(x) ? *x > v : false;
+}
+
+template <class T> constexpr bool operator<(const T& v, const optional<T&>& x)
+{
+  return bool(x) ? v < *x : false;
+}
+
+template <class T> constexpr bool operator>=(const optional<T&>& x, const T& v)
+{
+  return bool(x) ? *x >= v : false;
+}
+
+template <class T> constexpr bool operator<=(const T& v, const optional<T&>& x)
+{
+  return bool(x) ? v <= *x : false;
+}
+
+template <class T> constexpr bool operator<=(const optional<T&>& x, const T& v)
+{
+  return bool(x) ? *x <= v : true;
+}
+
+template <class T> constexpr bool operator>=(const T& v, const optional<T&>& x)
+{
+  return bool(x) ? v >= *x : true;
+}
+
+// Comparison of optional<T const&> with T
+template <class T> constexpr bool operator==(const optional<const T&>& x, const T& v)
+{
+  return bool(x) ? *x == v : false;
+}
+
+template <class T> constexpr bool operator==(const T& v, const optional<const T&>& x)
+{
+  return bool(x) ? v == *x : false;
+}
+
+template <class T> constexpr bool operator!=(const optional<const T&>& x, const T& v)
+{
+  return bool(x) ? *x != v : true;
+}
+
+template <class T> constexpr bool operator!=(const T& v, const optional<const T&>& x)
+{
+  return bool(x) ? v != *x : true;
+}
+
+template <class T> constexpr bool operator<(const optional<const T&>& x, const T& v)
+{
+  return bool(x) ? *x < v : true;
+}
+
+template <class T> constexpr bool operator>(const T& v, const optional<const T&>& x)
+{
+  return bool(x) ? v > *x : true;
+}
+
+template <class T> constexpr bool operator>(const optional<const T&>& x, const T& v)
+{
+  return bool(x) ? *x > v : false;
+}
+
+template <class T> constexpr bool operator<(const T& v, const optional<const T&>& x)
+{
+  return bool(x) ? v < *x : false;
+}
+
+template <class T> constexpr bool operator>=(const optional<const T&>& x, const T& v)
+{
+  return bool(x) ? *x >= v : false;
+}
+
+template <class T> constexpr bool operator<=(const T& v, const optional<const T&>& x)
+{
+  return bool(x) ? v <= *x : false;
+}
+
+template <class T> constexpr bool operator<=(const optional<const T&>& x, const T& v)
+{
+  return bool(x) ? *x <= v : true;
+}
+
+template <class T> constexpr bool operator>=(const T& v, const optional<const T&>& x)
+{
+  return bool(x) ? v >= *x : true;
+}
+
+
+// 20.5.12, Specialized algorithms
+template <class T>
+void swap(optional<T>& x, optional<T>& y) noexcept(noexcept(x.swap(y)))
+{
+  x.swap(y);
+}
+
+
+template <class T>
+constexpr optional<typename decay<T>::type> make_optional(T&& v)
+{
+  return optional<typename decay<T>::type>(constexpr_forward<T>(v));
+}
+
+template <class X>
+constexpr optional<X&> make_optional(reference_wrapper<X> v)
+{
+  return optional<X&>(v.get());
+}
+
+} // namespace Ice
+} // namespace experimental
+} // namespace std
+
+namespace std
+{
+  template <typename T>
+  struct hash<std::experimental::Ice::optional<T>>
+  {
+    typedef typename hash<T>::result_type result_type;
+    typedef std::experimental::Ice::optional<T> argument_type;
+
+    constexpr result_type operator()(argument_type const& arg) const {
+      return arg ? std::hash<T>{}(*arg) : result_type{};
+    }
+  };
+
+  template <typename T>
+  struct hash<std::experimental::Ice::optional<T&>>
+  {
+    typedef typename hash<T>::result_type result_type;
+    typedef std::experimental::Ice::optional<T&> argument_type;
+
+    constexpr result_type operator()(argument_type const& arg) const {
+      return arg ? std::hash<T>{}(*arg) : result_type{};
+    }
+  };
+}
+
+# undef TR2_OPTIONAL_REQUIRES
+# undef TR2_OPTIONAL_ASSERTED_EXPRESSION
+
+namespace Ice{
+
+template<class T> using optional = std::experimental::Ice::optional<T>;
+
+using std::experimental::Ice::operator==;
+using std::experimental::Ice::operator!=;
+using std::experimental::Ice::operator<;
+using std::experimental::Ice::operator<=;
+using std::experimental::Ice::operator>;
+using std::experimental::Ice::operator>=;
+
+using std::experimental::Ice::make_optional;
+using std::experimental::Ice::swap;
+
+using nullopt_t = std::experimental::Ice::nullopt_t;
+using std::experimental::Ice::nullopt;
+
+using bad_optional_access = std::experimental::Ice::bad_optional_access;
+
+using in_place_t = std::experimental::Ice::in_place_t;
+using std::experimental::Ice::in_place;
+
+}
+
+//
+// For compatibility with the Ice C++98 mapping, do not use in new code:
+//
+namespace IceUtil{
+
+template<class T> using Optional = std::experimental::Ice::optional<T>;
+constexpr std::experimental::Ice::nullopt_t None{std::experimental::Ice::nullopt_t::init()};
+
+}
+
+#else // C++98 mapping
+
+#   include <IceUtil/Optional.h>
+
+#endif
+
+#endif
diff --git a/cpp/include/IceUtil/Optional.h b/cpp/include/IceUtil/Optional.h
index 0a94556825e..60493e30fe3 100644
--- a/cpp/include/IceUtil/Optional.h
+++ b/cpp/include/IceUtil/Optional.h
@@ -10,6 +10,8 @@
 #ifndef ICE_UTIL_OPTIONAL_H
 #define ICE_UTIL_OPTIONAL_H
 
+#ifndef ICE_CPP11_MAPPING
+
 #include <IceUtil/Config.h>
 
 namespace IceUtilInternal
@@ -85,33 +87,44 @@ public:
         return *this;
     }
 
-    const T& get() const
+    const T& value() const
     {
         checkIsSet();
         return _value;
     }
-    T& get()
+
+    T& value()
     {
         checkIsSet();
         return _value;
     }
 
+    const T& get() const
+    {
+        return value();
+    }
+
+    T& get()
+    {
+        return value();
+    }
+
     const T* operator->() const
     {
-        return &get();
+        return &value();
     }
     T* operator->()
     {
-        return &get();
+        return &value();
     }
 
     const T& operator*() const
     {
-        return get();
+        return value();
     }
     T& operator*()
     {
-        return get();
+        return value();
     }
 
     operator bool() const
@@ -320,3 +333,4 @@ inline bool operator>=(const Y& lhs, const Optional<T>& rhs)
 }
 
 #endif
+#endif
diff --git a/cpp/msbuild/ice.test.sln b/cpp/msbuild/ice.test.sln
index 81b83a5bbab..a31068e48f6 100644
--- a/cpp/msbuild/ice.test.sln
+++ b/cpp/msbuild/ice.test.sln
@@ -2063,9 +2063,13 @@ Global
 		{306B9C8B-F11B-4071-AE80-CF69EF0BBB2B}.Release|x64.ActiveCfg = Release|x64
 		{306B9C8B-F11B-4071-AE80-CF69EF0BBB2B}.Release|x64.Build.0 = Release|x64
 		{A82A6A91-4EEC-4F0A-BA2D-A689BDCDA9C2}.Cpp11-Debug|Win32.ActiveCfg = Cpp11-Debug|Win32
+		{A82A6A91-4EEC-4F0A-BA2D-A689BDCDA9C2}.Cpp11-Debug|Win32.Build.0 = Cpp11-Debug|Win32
 		{A82A6A91-4EEC-4F0A-BA2D-A689BDCDA9C2}.Cpp11-Debug|x64.ActiveCfg = Cpp11-Debug|x64
+		{A82A6A91-4EEC-4F0A-BA2D-A689BDCDA9C2}.Cpp11-Debug|x64.Build.0 = Cpp11-Debug|x64
 		{A82A6A91-4EEC-4F0A-BA2D-A689BDCDA9C2}.Cpp11-Release|Win32.ActiveCfg = Cpp11-Release|Win32
+		{A82A6A91-4EEC-4F0A-BA2D-A689BDCDA9C2}.Cpp11-Release|Win32.Build.0 = Cpp11-Release|Win32
 		{A82A6A91-4EEC-4F0A-BA2D-A689BDCDA9C2}.Cpp11-Release|x64.ActiveCfg = Cpp11-Release|x64
+		{A82A6A91-4EEC-4F0A-BA2D-A689BDCDA9C2}.Cpp11-Release|x64.Build.0 = Cpp11-Release|x64
 		{A82A6A91-4EEC-4F0A-BA2D-A689BDCDA9C2}.Debug|Win32.ActiveCfg = Debug|Win32
 		{A82A6A91-4EEC-4F0A-BA2D-A689BDCDA9C2}.Debug|Win32.Build.0 = Debug|Win32
 		{A82A6A91-4EEC-4F0A-BA2D-A689BDCDA9C2}.Debug|x64.ActiveCfg = Debug|x64
@@ -2075,9 +2079,13 @@ Global
 		{A82A6A91-4EEC-4F0A-BA2D-A689BDCDA9C2}.Release|x64.ActiveCfg = Release|x64
 		{A82A6A91-4EEC-4F0A-BA2D-A689BDCDA9C2}.Release|x64.Build.0 = Release|x64
 		{E64764EB-2B8E-454F-9635-0729D07CCA24}.Cpp11-Debug|Win32.ActiveCfg = Cpp11-Debug|Win32
+		{E64764EB-2B8E-454F-9635-0729D07CCA24}.Cpp11-Debug|Win32.Build.0 = Cpp11-Debug|Win32
 		{E64764EB-2B8E-454F-9635-0729D07CCA24}.Cpp11-Debug|x64.ActiveCfg = Cpp11-Debug|x64
+		{E64764EB-2B8E-454F-9635-0729D07CCA24}.Cpp11-Debug|x64.Build.0 = Cpp11-Debug|x64
 		{E64764EB-2B8E-454F-9635-0729D07CCA24}.Cpp11-Release|Win32.ActiveCfg = Cpp11-Release|Win32
+		{E64764EB-2B8E-454F-9635-0729D07CCA24}.Cpp11-Release|Win32.Build.0 = Cpp11-Release|Win32
 		{E64764EB-2B8E-454F-9635-0729D07CCA24}.Cpp11-Release|x64.ActiveCfg = Cpp11-Release|x64
+		{E64764EB-2B8E-454F-9635-0729D07CCA24}.Cpp11-Release|x64.Build.0 = Cpp11-Release|x64
 		{E64764EB-2B8E-454F-9635-0729D07CCA24}.Debug|Win32.ActiveCfg = Debug|Win32
 		{E64764EB-2B8E-454F-9635-0729D07CCA24}.Debug|Win32.Build.0 = Debug|Win32
 		{E64764EB-2B8E-454F-9635-0729D07CCA24}.Debug|x64.ActiveCfg = Debug|x64
@@ -2087,9 +2095,13 @@ Global
 		{E64764EB-2B8E-454F-9635-0729D07CCA24}.Release|x64.ActiveCfg = Release|x64
 		{E64764EB-2B8E-454F-9635-0729D07CCA24}.Release|x64.Build.0 = Release|x64
 		{9D99D6A3-3087-4B6B-BF7E-AD1D8BB9BEDA}.Cpp11-Debug|Win32.ActiveCfg = Cpp11-Debug|Win32
+		{9D99D6A3-3087-4B6B-BF7E-AD1D8BB9BEDA}.Cpp11-Debug|Win32.Build.0 = Cpp11-Debug|Win32
 		{9D99D6A3-3087-4B6B-BF7E-AD1D8BB9BEDA}.Cpp11-Debug|x64.ActiveCfg = Cpp11-Debug|x64
+		{9D99D6A3-3087-4B6B-BF7E-AD1D8BB9BEDA}.Cpp11-Debug|x64.Build.0 = Cpp11-Debug|x64
 		{9D99D6A3-3087-4B6B-BF7E-AD1D8BB9BEDA}.Cpp11-Release|Win32.ActiveCfg = Cpp11-Release|Win32
+		{9D99D6A3-3087-4B6B-BF7E-AD1D8BB9BEDA}.Cpp11-Release|Win32.Build.0 = Cpp11-Release|Win32
 		{9D99D6A3-3087-4B6B-BF7E-AD1D8BB9BEDA}.Cpp11-Release|x64.ActiveCfg = Cpp11-Release|x64
+		{9D99D6A3-3087-4B6B-BF7E-AD1D8BB9BEDA}.Cpp11-Release|x64.Build.0 = Cpp11-Release|x64
 		{9D99D6A3-3087-4B6B-BF7E-AD1D8BB9BEDA}.Debug|Win32.ActiveCfg = Debug|Win32
 		{9D99D6A3-3087-4B6B-BF7E-AD1D8BB9BEDA}.Debug|Win32.Build.0 = Debug|Win32
 		{9D99D6A3-3087-4B6B-BF7E-AD1D8BB9BEDA}.Debug|x64.ActiveCfg = Debug|x64
diff --git a/cpp/src/Slice/CPlusPlusUtil.cpp b/cpp/src/Slice/CPlusPlusUtil.cpp
index 57fdf1bf2ff..dd282d5b68e 100644
--- a/cpp/src/Slice/CPlusPlusUtil.cpp
+++ b/cpp/src/Slice/CPlusPlusUtil.cpp
@@ -49,6 +49,26 @@ string toTemplateArg(const string& arg)
 }
 
 string
+toOptional(const string& s, int typeCtx)
+{
+    bool cpp11 = (typeCtx & TypeContextCpp11) != 0;
+    string result = cpp11 ? "Ice::optional" : "IceUtil::Optional";
+    result += '<';
+    if(cpp11)
+    {
+        result += s;
+    }
+    else
+    {
+        result += toTemplateArg(s);
+    }
+
+    result += '>';
+    return result;
+}
+
+
+string
 stringTypeToString(const TypePtr& type, const StringList& metaData, int typeCtx)
 {
     string strType = findMetaData(metaData, typeCtx);
@@ -98,7 +118,7 @@ sequenceTypeToString(const SequencePtr& seq, const StringList& metaData, int typ
                     return "::std::vector<" + s + '>';
                 }
             }
-            string s = typeToString(seq->type(), seq->typeMetaData(), inWstringModule(seq) ? TypeContextUseWstring : 0);
+            string s = typeToString(seq->type(), seq->typeMetaData(), typeCtx | (inWstringModule(seq) ? TypeContextUseWstring : 0));
             return "::std::pair<const " + s + "*, const " + s + "*>";
         }
         else if(seqType.find("%range") == 0)
@@ -154,7 +174,7 @@ writeParamAllocateCode(Output& out, const TypePtr& type, bool optional, const st
     string s = typeToString(type, metaData, typeCtx);
     if(optional)
     {
-        s = "IceUtil::Optional<" + toTemplateArg(s) + '>';
+        s = toOptional(s, typeCtx);
     }
     out << nl << s << ' ' << fixedName << ';';
 
@@ -195,7 +215,7 @@ writeParamAllocateCode(Output& out, const TypePtr& type, bool optional, const st
         {
             if(optional)
             {
-                s = "IceUtil::Optional<" + toTemplateArg(s) + '>';
+                s = toOptional(s, typeCtx);
             }
             out << nl << s << " ___" << fixedName << ";";
         }
@@ -746,7 +766,7 @@ Slice::typeToString(const TypePtr& type, bool optional, const StringList& metaDa
 {
     if(optional)
     {
-        return "IceUtil::Optional<" + toTemplateArg(typeToString(type, metaData, typeCtx)) + ">";
+        return toOptional(typeToString(type, metaData, typeCtx), typeCtx);
     }
     else
     {
@@ -764,7 +784,7 @@ Slice::returnTypeToString(const TypePtr& type, bool optional, const StringList&
 
     if(optional)
     {
-        return "IceUtil::Optional<" + toTemplateArg(typeToString(type, metaData, typeCtx)) + ">";
+        return toOptional(typeToString(type, metaData, typeCtx), typeCtx);
     }
 
     return typeToString(type, metaData, typeCtx);
@@ -811,7 +831,7 @@ Slice::inputTypeToString(const TypePtr& type, bool optional, const StringList& m
 
     if(optional)
     {
-        return "const IceUtil::Optional<" + toTemplateArg(typeToString(type, metaData, typeCtx)) +">&";
+        return "const " + toOptional(typeToString(type, metaData, typeCtx), typeCtx) + '&';
     }
 
     BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
@@ -819,7 +839,7 @@ Slice::inputTypeToString(const TypePtr& type, bool optional, const StringList& m
     {
         if(builtin->kind() == Builtin::KindString)
         {
-            return string("const ") + stringTypeToString(type, metaData, typeCtx) + "&";
+            return string("const ") + stringTypeToString(type, metaData, typeCtx) + '&';
         }
         else
         {
@@ -972,7 +992,7 @@ Slice::outputTypeToString(const TypePtr& type, bool optional, const StringList&
 
     if(optional)
     {
-        return "IceUtil::Optional<" + toTemplateArg(typeToString(type, metaData, typeCtx)) +">&";
+        return toOptional(typeToString(type, metaData, typeCtx), typeCtx) + '&';
     }
 
     BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
diff --git a/cpp/src/slice2cpp/Gen.cpp b/cpp/src/slice2cpp/Gen.cpp
index 4ee6807b16b..6b64c5832b1 100644
--- a/cpp/src/slice2cpp/Gen.cpp
+++ b/cpp/src/slice2cpp/Gen.cpp
@@ -811,7 +811,7 @@ Slice::Gen::generate(const UnitPtr& p)
     }
 
     H << "\n#include <IceUtil/ScopedArray.h>";
-    H << "\n#include <IceUtil/Optional.h>";
+    H << "\n#include <Ice/Optional.h>";
 
     if(p->hasExceptions())
     {
@@ -5937,8 +5937,21 @@ Slice::Gen::Cpp11TypesVisitor::visitDataMember(const DataMemberPtr& p)
     string defaultValue = p->defaultValue();
     if(!defaultValue.empty())
     {
-        H << " = ";
-        writeConstantValue(H, p->type(), p->defaultValueType(), defaultValue, _useWstring, p->getMetaData(), true);
+        BuiltinPtr builtin = BuiltinPtr::dynamicCast(p->type());
+        if(p->optional() && builtin->kind() == Builtin::KindString)
+        {
+            //
+            // = "<string literal>" doesn't work for optional<std::string>
+            //
+            H << '{';
+            writeConstantValue(H, p->type(), p->defaultValueType(), defaultValue, _useWstring, p->getMetaData(), true);
+            H << '}';
+        }
+        else
+        {
+            H << " = ";
+            writeConstantValue(H, p->type(), p->defaultValueType(), defaultValue, _useWstring, p->getMetaData(), true);
+        }
     }
 
     H << ';';
@@ -6603,8 +6616,21 @@ Slice::Gen::Cpp11ObjectVisitor::emitDataMember(const DataMemberPtr& p)
     string defaultValue = p->defaultValue();
     if(!defaultValue.empty())
     {
-        H << " = ";
-        writeConstantValue(H, p->type(), p->defaultValueType(), defaultValue, _useWstring, p->getMetaData(), true);
+        BuiltinPtr builtin = BuiltinPtr::dynamicCast(p->type());
+        if(p->optional() && builtin->kind() == Builtin::KindString)
+        {
+            //
+            // = "<string literal>" doesn't work for optional<std::string>
+            //
+            H << '{';
+            writeConstantValue(H, p->type(), p->defaultValueType(), defaultValue, _useWstring, p->getMetaData(), true);
+            H << '}';
+        }
+        else
+        {
+            H << " = ";
+            writeConstantValue(H, p->type(), p->defaultValueType(), defaultValue, _useWstring, p->getMetaData(), true);
+        }
     }
     H << ";";
 }
@@ -7593,7 +7619,6 @@ Slice::Gen::Cpp11ValueVisitor::visitClassDefStart(const ClassDefPtr& p)
     H.inc();
 
     // Out of line dtor to avoid weak vtable
-    H << sp;
     H << nl << _dllMemberExport << "virtual ~" << name << "();";
     C << sp;
     C << nl << scoped.substr(2) << "::~" << name << "()";
diff --git a/cpp/test/Ice/optional/AllTests.cpp b/cpp/test/Ice/optional/AllTests.cpp
index fe12b5fbe8a..a3fbd96a8ee 100644
--- a/cpp/test/Ice/optional/AllTests.cpp
+++ b/cpp/test/Ice/optional/AllTests.cpp
@@ -11,9 +11,38 @@
 #include <TestCommon.h>
 #include <Test.h>
 
+#ifdef ICE_CPP11_MAPPING
+namespace Test
+{
+using OneOptionalPrx = Ice::ObjectPrx;
+using OneOptionalPrxPtr = ::std::shared_ptr<Ice::ObjectPrx>;
+using MultiOptionalPrx = Ice::ObjectPrx;
+}
+#endif
+
 using namespace std;
 using namespace Test;
 
+namespace
+{
+
+//
+// Converts a vector to an "array range"
+//
+template<typename T> pair<const T*, const T*>
+toArrayRange(const vector<T>& v)
+{
+    return make_pair(&v[0], &v[0] + v.size());
+}
+
+template<typename T> pair<const T*, const T*>
+toArrayRange(const T* v, size_t sz)
+{
+    return make_pair(v, v + sz);
+}
+
+}
+
 #ifdef ICE_CPP11_MAPPING
 class TestObjectReader : public Ice::Value
 #else
@@ -30,6 +59,18 @@ public:
         in->endSlice();
         in->endValue(false);
     }
+
+#ifdef ICE_CPP11_MAPPING
+
+protected:
+
+    virtual std::shared_ptr<Value> cloneImpl() const
+    {
+        assert(0); // not used
+        return nullptr;
+    }
+
+#endif
 };
 
 #ifdef ICE_CPP11_MAPPING
@@ -55,6 +96,18 @@ public:
         in->endSlice();
         in->endValue(false);
     }
+
+#ifdef ICE_CPP11_MAPPING
+
+protected:
+
+    virtual std::shared_ptr<Value> cloneImpl() const
+    {
+        assert(0); // not used
+        return nullptr;
+    }
+
+#endif
 };
 
 #ifdef ICE_CPP11_MAPPING
@@ -83,6 +136,18 @@ public:
         in->endSlice();
         in->endValue(false);
     }
+
+#ifdef ICE_CPP11_MAPPING
+
+protected:
+
+    virtual std::shared_ptr<Value> cloneImpl() const
+    {
+        assert(0); // not used
+        return nullptr;
+    }
+
+#endif
 };
 
 #ifdef ICE_CPP11_MAPPING
@@ -107,7 +172,7 @@ public:
         o->push_back("test3");
         o->push_back("test4");
         out->write(1, o);
-        APtr a = new A();
+        APtr a = ICE_MAKE_SHARED(A);
         a->mc = 18;
         out->write(1000, IceUtil::Optional<APtr>(a));
         out->endSlice();
@@ -124,6 +189,19 @@ public:
     }
 
     virtual void __read(Ice::InputStream*) { }
+
+#ifdef ICE_CPP11_MAPPING
+
+protected:
+
+    virtual std::shared_ptr<Value> cloneImpl() const
+    {
+        assert(0); // not used
+        return nullptr;
+    }
+
+#endif
+
 };
 
 #ifdef ICE_CPP11_MAPPING
@@ -166,6 +244,18 @@ public:
         test((*a)->mc == 18);
     }
 
+#ifdef ICE_CPP11_MAPPING
+
+protected:
+
+    virtual std::shared_ptr<Value> cloneImpl() const
+    {
+        assert(0); // not used
+        return nullptr;
+    }
+
+#endif
+
 private:
 
     IceUtil::Optional<APtr> a;
@@ -182,7 +272,7 @@ public:
 
     virtual void __read(Ice::InputStream* in)
     {
-        _f = new F();
+        _f = ICE_MAKE_SHARED(F);
         in->startValue();
         in->startSlice();
         // Don't read af on purpose
@@ -200,12 +290,29 @@ public:
         return _f;
     }
 
+#ifdef ICE_CPP11_MAPPING
+
+protected:
+
+    virtual std::shared_ptr<Value> cloneImpl() const
+    {
+        assert(0); // not used
+        return nullptr;
+    }
+
+#endif
+
 private:
 
     FPtr _f;
 };
 
-class FactoryI : public Ice::ValueFactory
+
+class FactoryI
+#ifndef ICE_CPP11_MAPPING
+               : public Ice::ValueFactory
+#endif
+
 {
     bool _enabled;
 
@@ -215,7 +322,7 @@ public:
     {
     }
 
-    Ice::ObjectPtr
+    Ice::ValuePtr
     create(const string& typeId)
     {
         if(!_enabled)
@@ -225,27 +332,27 @@ public:
 
         if(typeId == "::Test::OneOptional")
         {
-            return new TestObjectReader;
+           return ICE_MAKE_SHARED(TestObjectReader);
         }
         else if(typeId == "::Test::MultiOptional")
         {
-            return new TestObjectReader;
+           return ICE_MAKE_SHARED(TestObjectReader);
         }
         else if(typeId == "::Test::B")
         {
-            return new BObjectReader;
+           return ICE_MAKE_SHARED(BObjectReader);
         }
         else if(typeId == "::Test::C")
         {
-            return new CObjectReader;
+           return ICE_MAKE_SHARED(CObjectReader);
         }
         else if(typeId == "::Test::D")
         {
-            return new DObjectReader;
+           return ICE_MAKE_SHARED(DObjectReader);
         }
         else if(typeId == "::Test::F")
         {
-            return new FObjectReader;
+           return ICE_MAKE_SHARED(FObjectReader);
         }
 
         return 0;
@@ -257,48 +364,63 @@ public:
         _enabled = enabled;
     }
 };
+
+#ifdef ICE_CPP11_MAPPING
+using FactoryIPtr = shared_ptr<FactoryI>;
+#else
 typedef IceUtil::Handle<FactoryI> FactoryIPtr;
+#endif
 
-InitialPrx
+InitialPrxPtr
 allTests(const Ice::CommunicatorPtr& communicator, bool)
 {
-    FactoryIPtr factory = new FactoryI();
+    FactoryIPtr factory = ICE_MAKE_SHARED(FactoryI);
+
+#ifdef ICE_CPP11_MAPPING
+    communicator->getValueFactoryManager()->add([factory](const string& typeId) { return factory->create(typeId); }, "");
+#else
     communicator->getValueFactoryManager()->add(factory, "");
+#endif
 
     cout << "testing stringToProxy... " << flush;
     string ref = "initial:" + getTestEndpoint(communicator, 0);
-    Ice::ObjectPrx base = communicator->stringToProxy(ref);
+    Ice::ObjectPrxPtr base = communicator->stringToProxy(ref);
     test(base);
     cout << "ok" << endl;
 
     cout << "testing checked cast... " << flush;
-    InitialPrx initial = InitialPrx::checkedCast(base);
+    InitialPrxPtr initial = ICE_CHECKED_CAST(InitialPrx, base);
     test(initial);
+
+#ifdef ICE_CPP11_MAPPING
+    test(targetEquals(initial, base));
+#else
     test(initial == base);
+#endif
 
     bool supportsCppStringView = initial->supportsCppStringView();
     cout << "ok" << endl;
 
     cout << "testing constructor, copy constructor, and assignment operator... " << flush;
 
-    OneOptionalPtr oo1 = new OneOptional();
+    OneOptionalPtr oo1 = ICE_MAKE_SHARED(OneOptional);
     test(!oo1->a);
     oo1->a = 15;
     test(oo1->a && *oo1->a == 15);
 
-    OneOptionalPtr oo2 = new OneOptional(16);
+    OneOptionalPtr oo2 = ICE_MAKE_SHARED(OneOptional, 16);
     test(oo2->a && *oo2->a == 16);
 
-    OneOptionalPtr oo3 = new OneOptional(*oo2);
+    OneOptionalPtr oo3 = ICE_MAKE_SHARED(OneOptional, *oo2);
     test(oo3->a && *oo3->a == 16);
 
     *oo3 = *oo1;
     test(oo3->a && *oo3->a == 15);
 
-    OneOptionalPtr oon = new OneOptional(IceUtil::None);
+    OneOptionalPtr oon = ICE_MAKE_SHARED(OneOptional, IceUtil::None);
     test(!oon->a);
 
-    MultiOptionalPtr mo1 = new MultiOptional();
+    MultiOptionalPtr mo1 = ICE_MAKE_SHARED(MultiOptional);
     mo1->a = 15;
     mo1->b = true;
     mo1->c = 19;
@@ -306,9 +428,9 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
     mo1->e = 99;
     mo1->f = 5.5f;
     mo1->g = 1.0;
-    mo1->h = "test";
-    mo1->i = Test::MyEnumMember;
-    mo1->j = MultiOptionalPrx::uncheckedCast(communicator->stringToProxy("test"));
+    mo1->h = string("test");
+    mo1->i = ICE_ENUM(MyEnum, MyEnumMember);
+    mo1->j = ICE_UNCHECKED_CAST(MultiOptionalPrx, communicator->stringToProxy("test"));
     mo1->k = mo1;
     mo1->bs = ByteSeq();
     (*mo1->bs).push_back(5);
@@ -329,8 +451,8 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
     mo1->shs = ShortSeq();
     mo1->shs->push_back(1);
     mo1->es = MyEnumSeq();
-    mo1->es->push_back(MyEnumMember);
-    mo1->es->push_back(MyEnumMember);
+    mo1->es->push_back(ICE_ENUM(MyEnum, MyEnumMember));
+    mo1->es->push_back(ICE_ENUM(MyEnum, MyEnumMember));
     mo1->fss = FixedStructSeq();
     mo1->fss->push_back(fs);
     mo1->vss = VarStructSeq();
@@ -338,41 +460,44 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
     mo1->oos = OneOptionalSeq();
     mo1->oos->push_back(oo1);
     mo1->oops = OneOptionalPrxSeq();
-    mo1->oops->push_back(OneOptionalPrx::uncheckedCast(communicator->stringToProxy("test")));
+    mo1->oops->push_back(ICE_UNCHECKED_CAST(OneOptionalPrx, communicator->stringToProxy("test")));
 
     mo1->ied = IntEnumDict();
-    mo1->ied.get()[4] = MyEnumMember;
+    mo1->ied.value()[4] = ICE_ENUM(MyEnum, MyEnumMember);
     mo1->ifsd = IntFixedStructDict();
-    mo1->ifsd.get()[4] = fs;
+    mo1->ifsd.value()[4] = fs;
     mo1->ivsd = IntVarStructDict();
-    mo1->ivsd.get()[5] = vs;
+    mo1->ivsd.value()[5] = vs;
     mo1->iood = IntOneOptionalDict();
-    mo1->iood.get()[5] = new OneOptional();
-    mo1->iood.get()[5]->a = 15;
+    mo1->iood.value()[5] = ICE_MAKE_SHARED(OneOptional);
+    mo1->iood.value()[5]->a = 15;
     mo1->ioopd = IntOneOptionalPrxDict();
-    mo1->ioopd.get()[5] = OneOptionalPrx::uncheckedCast(communicator->stringToProxy("test"));
+    mo1->ioopd.value()[5] = ICE_UNCHECKED_CAST(OneOptionalPrx, communicator->stringToProxy("test"));
 
     mo1->bos = BoolSeq();
     mo1->bos->push_back(false);
     mo1->bos->push_back(true);
     mo1->bos->push_back(false);
+
+#ifndef ICE_CPP11_MAPPING
     mo1->ice_collectable(true);
+#endif
 
-    MultiOptionalPtr mo2 = new MultiOptional(*mo1);
+    MultiOptionalPtr mo2 = ICE_MAKE_SHARED(MultiOptional, *mo1);
 
-    MultiOptionalPtr mo3 = new MultiOptional();
+    MultiOptionalPtr mo3 = ICE_MAKE_SHARED(MultiOptional);
     *mo3 = *mo2;
 
-    test(mo3->a == 15);
+    test(mo3->a == static_cast<Ice::Byte>(15));
     test(mo3->b == true);
-    test(mo3->c == 19);
+    test(mo3->c == static_cast<short>(19));
     test(mo3->d == 78);
-    test(mo3->e == 99);
+    test(mo3->e == static_cast<Ice::Long>(99));
     test(mo3->f == 5.5f);
     test(mo3->g == 1.0);
-    test(mo3->h == "test");
-    test(mo3->i == Test::MyEnumMember);
-    test(mo3->j == MultiOptionalPrx::uncheckedCast(communicator->stringToProxy("test")));
+    test(mo3->h == string("test"));
+    test(mo3->i = ICE_ENUM(MyEnum, MyEnumMember));
+    test(mo3->j = ICE_UNCHECKED_CAST(MultiOptionalPrx, communicator->stringToProxy("test")));
     test(mo3->k == mo1);
     test(mo3->bs == mo1->bs);
     test(mo3->ss == mo1->ss);
@@ -400,28 +525,31 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
 
     cout << "testing comparison operators... " << flush;
 
-    test(mo1->a == 15 && 15 == mo1->a && mo1->a != 16 && 16 != mo1->a);
-    test(mo1->a < 16 && mo1->a > 14 && mo1->a <= 15 && mo1->a >= 15 && mo1->a <= 16 && mo1->a >= 14);
-    test(mo1->a > IceUtil::Optional<int>() && IceUtil::Optional<int>() < mo1->a);
+    test(mo1->a == static_cast<Ice::Byte>(15) && static_cast<Ice::Byte>(15) == mo1->a &&
+        mo1->a != static_cast<Ice::Byte>(16) && static_cast<Ice::Byte>(16) != mo1->a);
+    test(mo1->a < static_cast<Ice::Byte>(16) && mo1->a > static_cast<Ice::Byte>(14) &&
+        mo1->a <= static_cast<Ice::Byte>(15) && mo1->a >= static_cast<Ice::Byte>(15) &&
+        mo1->a <= static_cast<Ice::Byte>(16) && mo1->a >= static_cast<Ice::Byte>(14));
+    test(mo1->a > IceUtil::Optional<Ice::Byte>() && IceUtil::Optional<Ice::Byte>() < mo1->a);
     test(14 > IceUtil::Optional<int>() && IceUtil::Optional<int>() < 14);
 
-    test(mo1->h == "test" && "test" == mo1->h && mo1->h != "testa" && "testa" != mo1->h);
-    test(mo1->h < "test1" && mo1->h > "tesa" && mo1->h <= "test");
-    test(mo1->h >= "test" && mo1->h <= "test1" && mo1->h >= "tesa");
+    test(mo1->h == string("test") && string("test") == mo1->h && mo1->h != string("testa") && string("testa") != mo1->h);
+    test(mo1->h < string("test1") && mo1->h > string("tesa") && mo1->h <= string("test"));
+    test(mo1->h >= string("test") && mo1->h <= string("test1") && mo1->h >= string("tesa"));
     test(mo1->h > IceUtil::Optional<string>() && IceUtil::Optional<string>() < mo1->h);
-    test("test1" > IceUtil::Optional<string>() && IceUtil::Optional<string>() < "test1");
+    test(string("test1") > IceUtil::Optional<string>() && IceUtil::Optional<string>() < string("test1"));
 
     cout << "ok" << endl;
 
 
     cout << "testing marshalling... " << flush;
-    OneOptionalPtr oo4 = OneOptionalPtr::dynamicCast(initial->pingPong(new OneOptional()));
+    OneOptionalPtr oo4 = ICE_DYNAMIC_CAST(OneOptional, initial->pingPong(ICE_MAKE_SHARED(OneOptional)));
     test(!oo4->a);
 
-    OneOptionalPtr oo5 = OneOptionalPtr::dynamicCast(initial->pingPong(oo1));
+    OneOptionalPtr oo5 = ICE_DYNAMIC_CAST(OneOptional, initial->pingPong(oo1));
     test(oo1->a == oo5->a);
 
-    MultiOptionalPtr mo4 = MultiOptionalPtr::dynamicCast(initial->pingPong(new MultiOptional()));
+    MultiOptionalPtr mo4 = ICE_DYNAMIC_CAST(MultiOptional, initial->pingPong(ICE_MAKE_SHARED(MultiOptional)));
     test(!mo4->a);
     test(!mo4->b);
     test(!mo4->c);
@@ -456,7 +584,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
     test(!mo4->bos);
 
     mo1->k = mo1;
-    MultiOptionalPtr mo5 = MultiOptionalPtr::dynamicCast(initial->pingPong(mo1));
+    MultiOptionalPtr mo5 = ICE_DYNAMIC_CAST(MultiOptional, initial->pingPong(mo1));
     test(mo5->a == mo1->a);
     test(mo5->b == mo1->b);
     test(mo5->c == mo1->c);
@@ -466,7 +594,11 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
     test(mo5->g == mo1->g);
     test(mo5->h == mo1->h);
     test(mo5->i == mo1->i);
+#ifdef ICE_CPP11_MAPPING
+    test(targetEquals(mo5->j.value(), mo1->j.value()));
+#else
     test(mo5->j == mo1->j);
+#endif
     test(mo5->k == mo5->k);
     test(mo5->bs == mo1->bs);
     test(mo5->ss == mo1->ss);
@@ -480,18 +612,36 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
     test(mo5->fss == mo1->fss);
     test(mo5->vss == mo1->vss);
     test(!mo5->oos->empty() && (*mo5->oos)[0]->a == oo1->a);
+
+#ifdef ICE_CPP11_MAPPING
+    test(mo5->oops.value().size() == mo1->oops.value().size());
+    for(size_t i = 0; i< mo5->oops.value().size(); ++i)
+    {
+        test(targetEquals(mo5->oops.value()[i], mo1->oops.value()[i]));
+    }
+#else
     test(mo5->oops == mo1->oops);
+#endif
 
     test(mo5->ied == mo1->ied);
     test(mo5->ifsd == mo1->ifsd);
     test(mo5->ivsd == mo1->ivsd);
     test(!mo5->iood->empty() && (*mo5->iood)[5]->a == 15);
+
+#ifdef ICE_CPP11_MAPPING
+    test(mo5->ioopd.value().size() == mo1->ioopd.value().size());
+    for(auto& v : mo5->ioopd.value())
+    {
+        test(targetEquals(mo1->ioopd.value()[v.first], v.second));
+    }
+#else
     test(mo5->ioopd == mo1->ioopd);
+#endif
 
     test(mo5->bos == mo1->bos);
 
     // Clear the first half of the optional parameters
-    MultiOptionalPtr mo6 = new MultiOptional(*mo5);
+    MultiOptionalPtr mo6 = ICE_MAKE_SHARED(MultiOptional, *mo5);
     mo6->a = IceUtil::None;
     mo6->c = IceUtil::None;
     mo6->e = IceUtil::None;
@@ -510,7 +660,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
     mo6->ivsd = IceUtil::None;
     mo6->ioopd = IceUtil::None;
 
-    MultiOptionalPtr mo7 = MultiOptionalPtr::dynamicCast(initial->pingPong(mo6));
+    MultiOptionalPtr mo7 = ICE_DYNAMIC_CAST(MultiOptional, initial->pingPong(mo6));
     test(!mo7->a);
     test(mo7->b == mo1->b);
     test(!mo7->c);
@@ -520,7 +670,11 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
     test(!mo7->g);
     test(mo7->h == mo1->h);
     test(!mo7->i);
+#ifdef ICE_CPP11_MAPPING
+    test(targetEquals(mo7->j.value(), mo1->j.value()));
+#else
     test(mo7->j == mo1->j);
+#endif
     test(!mo7->k);
     test(mo7->bs == mo1->bs);
     test(!mo7->ss);
@@ -543,7 +697,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
     test(!mo7->ioopd);
 
     // Clear the second half of the optional parameters
-    MultiOptionalPtr mo8 = new MultiOptional(*mo5);
+    MultiOptionalPtr mo8 = ICE_MAKE_SHARED(MultiOptional, *mo5);
     mo8->b = IceUtil::None;
     mo8->d = IceUtil::None;
     mo8->f = IceUtil::None;
@@ -560,7 +714,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
     mo8->ifsd = IceUtil::None;
     mo8->iood = IceUtil::None;
 
-    MultiOptionalPtr mo9 = MultiOptionalPtr::dynamicCast(initial->pingPong(mo8));
+    MultiOptionalPtr mo9 = ICE_DYNAMIC_CAST(MultiOptional, initial->pingPong(mo8));
     test(mo9->a == mo1->a);
     test(!mo9->b);
     test(mo9->c == mo1->c);
@@ -584,7 +738,16 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
     test(!mo8->fss);
     test(mo8->vss == mo1->vss);
     test(!mo8->oos);
+
+#ifdef ICE_CPP11_MAPPING
+    test(mo8->oops.value().size() == mo1->oops.value().size());
+    for(size_t i = 0; i< mo8->oops.value().size(); ++i)
+    {
+        test(targetEquals(mo8->oops.value()[i], mo1->oops.value()[i]));
+    }
+#else
     test(mo8->oops == mo1->oops);
+#endif
 
     test(mo8->ied == mo1->ied);
     test(!mo8->ifsd);
@@ -606,10 +769,10 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         out.write(oo1);
         out.endEncapsulation();
         out.finished(inEncaps);
-        test(initial->ice_invoke("pingPong", Ice::Normal, inEncaps, outEncaps));
+        test(initial->ice_invoke("pingPong", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps));
         Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
         in.startEncapsulation();
-        Ice::ObjectPtr obj;
+        Ice::ValuePtr obj;
         in.read(obj);
         in.endEncapsulation();
         test(obj && dynamic_cast<TestObjectReader*>(obj.get()));
@@ -621,10 +784,10 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         out.write(mo1);
         out.endEncapsulation();
         out.finished(inEncaps);
-        test(initial->ice_invoke("pingPong", Ice::Normal, inEncaps, outEncaps));
+        test(initial->ice_invoke("pingPong", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps));
         Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
         in.startEncapsulation();
-        Ice::ObjectPtr obj;
+        Ice::ValuePtr obj;
         in.read(obj);
         in.endEncapsulation();
         test(obj && dynamic_cast<TestObjectReader*>(obj.get()));
@@ -634,7 +797,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
     //
     // Use the 1.0 encoding with operations whose only class parameters are optional.
     //
-    IceUtil::Optional<OneOptionalPtr> oo(new OneOptional(53));
+    IceUtil::Optional<OneOptionalPtr> oo(ICE_MAKE_SHARED(OneOptional, 53));
     initial->sendOptionalClass(true, oo);
     initial->ice_encodingVersion(Ice::Encoding_1_0)->sendOptionalClass(true, oo);
 
@@ -644,23 +807,23 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
     test(!oo);
 
     RecursiveSeq recursive1;
-    recursive1.push_back(new Recursive());
+    recursive1.push_back(ICE_MAKE_SHARED(Recursive));
     RecursiveSeq recursive2;
-    recursive2.push_back(new Recursive());
+    recursive2.push_back(ICE_MAKE_SHARED(Recursive));
     recursive1[0]->value = recursive2;
-    RecursivePtr outer = new Recursive();
+    RecursivePtr outer = ICE_MAKE_SHARED(Recursive);
     outer->value = recursive1;
     initial->pingPong(outer);
 
-    GPtr g = new G();
-    g->gg1Opt = new G1("gg1Opt");
-    g->gg2 = new G2(10);
-    g->gg2Opt = new G2(20);
-    g->gg1 = new G1("gg1");
+    GPtr g = ICE_MAKE_SHARED(G);
+    g->gg1Opt = ICE_MAKE_SHARED(G1, "gg1Opt");
+    g->gg2 = ICE_MAKE_SHARED(G2, 10);
+    g->gg2Opt = ICE_MAKE_SHARED(G2, 20);
+    g->gg1 = ICE_MAKE_SHARED(G1, "gg1");
     GPtr r = initial->opG(g);
-    test("gg1Opt" == r->gg1Opt.get()->a);
+    test("gg1Opt" == r->gg1Opt.value()->a);
     test(10 == r->gg2->a);
-    test(20 == r->gg2Opt.get()->a);
+    test(20 == r->gg2Opt.value()->a);
     test("gg1" == r->gg1->a);
 
     initial->opVoid();
@@ -672,13 +835,13 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         out.write(2, IceUtil::Optional<string>("test"));
         out.endEncapsulation();
         out.finished(inEncaps);
-        test(initial->ice_invoke("opVoid", Ice::Normal, inEncaps, outEncaps));
+        test(initial->ice_invoke("opVoid", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps));
     }
 
     cout << "ok" << endl;
 
     cout << "testing marshalling of large containers with fixed size elements..." << flush;
-    MultiOptionalPtr mc = new MultiOptional();
+    MultiOptionalPtr mc = ICE_MAKE_SHARED(MultiOptional);
 
     ByteSeq byteSeq;
     byteSeq.resize(1000);
@@ -699,7 +862,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
     }
     mc->ifsd = ifsd;
 
-    mc = MultiOptionalPtr::dynamicCast(initial->pingPong(mc));
+    mc = ICE_DYNAMIC_CAST(MultiOptional, initial->pingPong(mc));
     test(mc->bs->size() == 1000);
     test(mc->shs->size() == 300);
     test(mc->fss->size() == 300);
@@ -712,10 +875,10 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         out.write(mc);
         out.endEncapsulation();
         out.finished(inEncaps);
-        test(initial->ice_invoke("pingPong", Ice::Normal, inEncaps, outEncaps));
+        test(initial->ice_invoke("pingPong", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps));
         Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
         in.startEncapsulation();
-        Ice::ObjectPtr obj;
+        Ice::ValuePtr obj;
         in.read(obj);
         in.endEncapsulation();
         test(obj && dynamic_cast<TestObjectReader*>(obj.get()));
@@ -725,8 +888,8 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
     cout << "ok" << endl;
 
     cout << "testing tag marshalling... " << flush;
-    BPtr b = new B();
-    BPtr b2 = BPtr::dynamicCast(initial->pingPong(b));
+    BPtr b = ICE_MAKE_SHARED(B);
+    BPtr b2 = ICE_DYNAMIC_CAST(B, initial->pingPong(b));
     test(!b2->ma);
     test(!b2->mb);
     test(!b2->mc);
@@ -736,7 +899,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
     b->mc = 12;
     b->md = 13;
 
-    b2 = BPtr::dynamicCast(initial->pingPong(b));
+    b2 = ICE_DYNAMIC_CAST(B, initial->pingPong(b));
     test(b2->ma == 10);
     test(b2->mb == 11);
     test(b2->mc == 12);
@@ -749,10 +912,10 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         out.write(b);
         out.endEncapsulation();
         out.finished(inEncaps);
-        test(initial->ice_invoke("pingPong", Ice::Normal, inEncaps, outEncaps));
+        test(initial->ice_invoke("pingPong", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps));
         Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
         in.startEncapsulation();
-        Ice::ObjectPtr obj;
+        Ice::ValuePtr obj;
         in.read(obj);
         in.endEncapsulation();
         test(obj);
@@ -763,12 +926,12 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
 
     cout << "testing marshalling of objects with optional objects..." << flush;
     {
-        FPtr f = new F();
+        FPtr f = ICE_MAKE_SHARED(F);
 
-        f->af = new A();
+        f->af = ICE_MAKE_SHARED(A);
         f->ae = *f->af;
 
-        FPtr rf = FPtr::dynamicCast(initial->pingPong(f));
+        FPtr rf = ICE_DYNAMIC_CAST(F, initial->pingPong(f));
         test(rf->ae == *rf->af);
 
         factory->setEnabled(true);
@@ -779,7 +942,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         out.finished(inEncaps);
         Ice::InputStream in(communicator, out.getEncoding(), inEncaps);
         in.startEncapsulation();
-        Ice::ObjectPtr obj;
+        Ice::ValuePtr obj;
         in.read(obj);
         in.endEncapsulation();
         factory->setEnabled(false);
@@ -790,12 +953,12 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
     cout << "ok" << endl;
 
     cout << "testing optional with default values... " << flush;
-    WDPtr wd = WDPtr::dynamicCast(initial->pingPong(new WD()));
+    WDPtr wd = ICE_DYNAMIC_CAST(WD, initial->pingPong(ICE_MAKE_SHARED(WD)));
     test(*wd->a == 5);
     test(*wd->s == "test");
     wd->a = IceUtil::None;
     wd->s = IceUtil::None;
-    wd = WDPtr::dynamicCast(initial->pingPong(wd));
+    wd = ICE_DYNAMIC_CAST(WD, initial->pingPong(wd));
     test(!wd->a);
     test(!wd->s);
     cout << "ok" << endl;
@@ -804,9 +967,9 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
     {
         cout << "testing marshalling with unknown class slices... " << flush;
         {
-            CPtr c = new C();
+            CPtr c = ICE_MAKE_SHARED(C);
             c->ss = "test";
-            c->ms = "testms";
+            c->ms = string("testms");
 
             {
                 Ice::OutputStream out(communicator);
@@ -815,10 +978,10 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
                 out.endEncapsulation();
                 out.finished(inEncaps);
                 factory->setEnabled(true);
-                test(initial->ice_invoke("pingPong", Ice::Normal, inEncaps, outEncaps));
+                test(initial->ice_invoke("pingPong", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps));
                 Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
                 in.startEncapsulation();
-                Ice::ObjectPtr obj;
+                Ice::ValuePtr obj;
                 in.read(obj);
                 in.endEncapsulation();
                 test(dynamic_cast<CObjectReader*>(obj.get()));
@@ -829,14 +992,14 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
                 factory->setEnabled(true);
                 Ice::OutputStream out(communicator);
                 out.startEncapsulation();
-                Ice::ObjectPtr d = new DObjectWriter();
+                Ice::ValuePtr d = ICE_MAKE_SHARED(DObjectWriter);
                 out.write(d);
                 out.endEncapsulation();
                 out.finished(inEncaps);
-                test(initial->ice_invoke("pingPong", Ice::Normal, inEncaps, outEncaps));
+                test(initial->ice_invoke("pingPong", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps));
                 Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
                 in.startEncapsulation();
-                Ice::ObjectPtr obj;
+                Ice::ValuePtr obj;
                 in.read(obj);
                 in.endEncapsulation();
                 test(obj && dynamic_cast<DObjectReader*>(obj.get()));
@@ -848,15 +1011,19 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
 
         cout << "testing optionals with unknown classes..." << flush;
         {
-            APtr a = new A();
+            APtr a = ICE_MAKE_SHARED(A);
 
             Ice::OutputStream out(communicator);
             out.startEncapsulation();
             out.write(a);
+#ifdef ICE_CPP11_MAPPING
+            out.write(1, Ice::make_optional(make_shared<DObjectWriter>()));
+#else
             out.write(1, IceUtil::makeOptional(Ice::ObjectPtr(new DObjectWriter)));
+#endif
             out.endEncapsulation();
             out.finished(inEncaps);
-            test(initial->ice_invoke("opClassAndUnknownOptional", Ice::Normal, inEncaps, outEncaps));
+            test(initial->ice_invoke("opClassAndUnknownOptional", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps));
 
             Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
             in.startEncapsulation();
@@ -872,16 +1039,18 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         IceUtil::Optional<Ice::Byte> p2 = initial->opByte(p1, p3);
         test(!p2 && !p3);
 
-        p1 = 56;
+        const Ice::Byte bval = 56;
+
+        p1 = bval;
         p2 = initial->opByte(p1, p3);
-        test(p2 == 56 && p3 == 56);
+        test(p2 == bval && p3 == bval);
 
         Ice::OutputStream out(communicator);
         out.startEncapsulation();
         out.write(2, p1);
         out.endEncapsulation();
         out.finished(inEncaps);
-        initial->ice_invoke("opByte", Ice::Normal, inEncaps, outEncaps);
+        initial->ice_invoke("opByte", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps);
         Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
         in.startEncapsulation();
         in.read(1, p2);
@@ -891,7 +1060,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         in.read(89, p4);
 
         in.endEncapsulation();
-        test(p2 == 56 && p3 == 56 && !p4);
+        test(p2 == bval && p3 == bval && !p4);
 
         Ice::InputStream in2(communicator, out.getEncoding(), outEncaps);
         in2.startEncapsulation();
@@ -913,7 +1082,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         out.write(2, p1);
         out.endEncapsulation();
         out.finished(inEncaps);
-        initial->ice_invoke("opBool", Ice::Normal, inEncaps, outEncaps);
+        initial->ice_invoke("opBool", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps);
         Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
         in.startEncapsulation();
         in.read(1, p2);
@@ -932,22 +1101,24 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         IceUtil::Optional<Ice::Short> p2 = initial->opShort(p1, p3);
         test(!p2 && !p3);
 
-        p1 = 56;
+        const Ice::Short sval = 56;
+
+        p1 = sval;
         p2 = initial->opShort(p1, p3);
-        test(p2 == 56 && p3 == 56);
+        test(p2 == sval && p3 == sval);
 
         Ice::OutputStream out(communicator);
         out.startEncapsulation();
         out.write(2, p1);
         out.endEncapsulation();
         out.finished(inEncaps);
-        initial->ice_invoke("opShort", Ice::Normal, inEncaps, outEncaps);
+        initial->ice_invoke("opShort", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps);
         Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
         in.startEncapsulation();
         in.read(1, p2);
         in.read(3, p3);
         in.endEncapsulation();
-        test(p2 == 56 && p3 == 56);
+        test(p2 == sval && p3 == sval);
 
         Ice::InputStream in2(communicator, out.getEncoding(), outEncaps);
         in2.startEncapsulation();
@@ -960,7 +1131,9 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         IceUtil::Optional<Ice::Int> p2 = initial->opInt(p1, p3);
         test(!p2 && !p3);
 
-        p1 = 56;
+        const Ice::Int ival = 56;
+
+        p1 = ival;
         p2 = initial->opInt(p1, p3);
         test(p2 == 56 && p3 == 56);
 
@@ -969,13 +1142,13 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         out.write(2, p1);
         out.endEncapsulation();
         out.finished(inEncaps);
-        initial->ice_invoke("opInt", Ice::Normal, inEncaps, outEncaps);
+        initial->ice_invoke("opInt", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps);
         Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
         in.startEncapsulation();
         in.read(1, p2);
         in.read(3, p3);
         in.endEncapsulation();
-        test(p2 == 56 && p3 == 56);
+        test(p2 == ival && p3 == ival);
 
         Ice::InputStream in2(communicator, out.getEncoding(), outEncaps);
         in2.startEncapsulation();
@@ -988,22 +1161,24 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         IceUtil::Optional<Ice::Long> p2 = initial->opLong(p1, p3);
         test(!p2 && !p3);
 
-        p1 = 56;
+        const Ice::Long lval = 56;
+
+        p1 = lval;
         p2 = initial->opLong(p1, p3);
-        test(p2 == 56 && p3 == 56);
+        test(p2 == lval && p3 == lval);
 
         Ice::OutputStream out(communicator);
         out.startEncapsulation();
         out.write(1, p1);
         out.endEncapsulation();
         out.finished(inEncaps);
-        initial->ice_invoke("opLong", Ice::Normal, inEncaps, outEncaps);
+        initial->ice_invoke("opLong", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps);
         Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
         in.startEncapsulation();
         in.read(2, p3);
         in.read(3, p2);
         in.endEncapsulation();
-        test(p2 == 56 && p3 == 56);
+        test(p2 == lval && p3 == lval);
 
         Ice::InputStream in2(communicator, out.getEncoding(), outEncaps);
         in2.startEncapsulation();
@@ -1016,22 +1191,24 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         IceUtil::Optional<Ice::Float> p2 = initial->opFloat(p1, p3);
         test(!p2 && !p3);
 
-        p1 = 1.0f;
+        const Ice::Float fval = 1.0f;
+
+        p1 = fval;
         p2 = initial->opFloat(p1, p3);
-        test(p2 == 1.0f && p3 == 1.0f);
+        test(p2 == fval && p3 == fval);
 
         Ice::OutputStream out(communicator);
         out.startEncapsulation();
         out.write(2, p1);
         out.endEncapsulation();
         out.finished(inEncaps);
-        initial->ice_invoke("opFloat", Ice::Normal, inEncaps, outEncaps);
+        initial->ice_invoke("opFloat", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps);
         Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
         in.startEncapsulation();
         in.read(1, p2);
         in.read(3, p3);
         in.endEncapsulation();
-        test(p2 == 1.0f && p3 == 1.0f);
+        test(p2 == fval && p3 == fval);
 
         Ice::InputStream in2(communicator, out.getEncoding(), outEncaps);
         in2.startEncapsulation();
@@ -1044,22 +1221,24 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         IceUtil::Optional<Ice::Double> p2 = initial->opDouble(p1, p3);
         test(!p2 && !p3);
 
-        p1 = 1.0;
+        const Ice::Double dval = 1.0;
+
+        p1 = dval;
         p2 = initial->opDouble(p1, p3);
-        test(p2 == 1.0 && p3 == 1.0);
+        test(p2 == dval && p3 == dval);
 
         Ice::OutputStream out(communicator);
         out.startEncapsulation();
         out.write(2, p1);
         out.endEncapsulation();
         out.finished(inEncaps);
-        initial->ice_invoke("opDouble", Ice::Normal, inEncaps, outEncaps);
+        initial->ice_invoke("opDouble", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps);
         Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
         in.startEncapsulation();
         in.read(1, p2);
         in.read(3, p3);
         in.endEncapsulation();
-        test(p2 == 1.0 && p3 == 1.0);
+        test(p2 == dval && p3 == dval);
 
         Ice::InputStream in2(communicator, out.getEncoding(), outEncaps);
         in2.startEncapsulation();
@@ -1072,22 +1251,24 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         IceUtil::Optional<string> p2 = initial->opString(p1, p3);
         test(!p2 && !p3);
 
-        p1 = "test";
-        p2 = initial->opString("test", p3);
-        test(p2 == "test" && p3 == "test");
+        const string sval = "test";
+
+        p1 = sval;
+        p2 = initial->opString(sval, p3);
+        test(p2 == sval && p3 == sval);
 
         Ice::OutputStream out(communicator);
         out.startEncapsulation();
         out.write(2, p1);
         out.endEncapsulation();
         out.finished(inEncaps);
-        initial->ice_invoke("opString", Ice::Normal, inEncaps, outEncaps);
+        initial->ice_invoke("opString", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps);
         Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
         in.startEncapsulation();
         in.read(1, p2);
         in.read(3, p3);
         in.endEncapsulation();
-        test(p2 == "test" && p3 == "test");
+        test(p2 == sval && p3 == sval);
 
         Ice::InputStream in2(communicator, out.getEncoding(), outEncaps);
         in2.startEncapsulation();
@@ -1102,22 +1283,24 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
             IceUtil::Optional<string> p2 = initial->opCustomString(p1, p3);
             test(!p2 && !p3);
 
-            p1 = "test";
-            p2 = initial->opString("test", p3);
-            test(p2 == "test" && p3 == "test");
+            const string sval = "test";
+
+            p1 = Util::string_view(sval);
+            p2 = initial->opString(sval, p3);
+            test(p2 == sval && p3 == sval);
 
             Ice::OutputStream out(communicator);
             out.startEncapsulation();
             out.write(2, p1);
             out.endEncapsulation();
             out.finished(inEncaps);
-            initial->ice_invoke("opCustomString", Ice::Normal, inEncaps, outEncaps);
+            initial->ice_invoke("opCustomString", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps);
             Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
             in.startEncapsulation();
             in.read(1, p2);
             in.read(3, p3);
             in.endEncapsulation();
-            test(p2 == "test" && p3 == "test");
+            test(p2 == sval && p3 == sval);
 
             Ice::InputStream in2(communicator, out.getEncoding(), outEncaps);
             in2.startEncapsulation();
@@ -1131,22 +1314,22 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         IceUtil::Optional<Test::MyEnum> p2 = initial->opMyEnum(p1, p3);
         test(!p2 && !p3);
 
-        p1 = Test::MyEnumMember;
+        p1 = ICE_ENUM(MyEnum, MyEnumMember);
         p2 = initial->opMyEnum(p1, p3);
-        test(p2 == Test::MyEnumMember && p3 == Test::MyEnumMember);
+        test(p2 == ICE_ENUM(MyEnum, MyEnumMember) && p3 == ICE_ENUM(MyEnum, MyEnumMember));
 
         Ice::OutputStream out(communicator);
         out.startEncapsulation();
         out.write(2, p1);
         out.endEncapsulation();
         out.finished(inEncaps);
-        initial->ice_invoke("opMyEnum", Ice::Normal, inEncaps, outEncaps);
+        initial->ice_invoke("opMyEnum", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps);
         Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
         in.startEncapsulation();
         in.read(1, p2);
         in.read(3, p3);
         in.endEncapsulation();
-        test(p2 == Test::MyEnumMember && p3 == Test::MyEnumMember);
+        test(p2 == ICE_ENUM(MyEnum, MyEnumMember) && p3 == ICE_ENUM(MyEnum, MyEnumMember));
 
         Ice::InputStream in2(communicator, out.getEncoding(), outEncaps);
         in2.startEncapsulation();
@@ -1169,7 +1352,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         out.write(2, p1);
         out.endEncapsulation();
         out.finished(inEncaps);
-        initial->ice_invoke("opSmallStruct", Ice::Normal, inEncaps, outEncaps);
+        initial->ice_invoke("opSmallStruct", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps);
         Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
         in.startEncapsulation();
         in.read(1, p2);
@@ -1198,7 +1381,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         out.write(2, p1);
         out.endEncapsulation();
         out.finished(inEncaps);
-        initial->ice_invoke("opFixedStruct", Ice::Normal, inEncaps, outEncaps);
+        initial->ice_invoke("opFixedStruct", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps);
         Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
         in.startEncapsulation();
         in.read(1, p2);
@@ -1227,7 +1410,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         out.write(2, p1);
         out.endEncapsulation();
         out.finished(inEncaps);
-        initial->ice_invoke("opVarStruct", Ice::Normal, inEncaps, outEncaps);
+        initial->ice_invoke("opVarStruct", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps);
         Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
         in.startEncapsulation();
         in.read(1, p2);
@@ -1246,7 +1429,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         IceUtil::Optional<OneOptionalPtr> p2 = initial->opOneOptional(p1, p3);
         test(!p2 && !p3);
 
-        p1 = new OneOptional(58);
+        p1 = ICE_MAKE_SHARED(OneOptional, 58);
         p2 = initial->opOneOptional(p1, p3);
         test((*p2)->a == 58 && (*p3)->a == 58);
 
@@ -1255,7 +1438,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         out.write(2, p1);
         out.endEncapsulation();
         out.finished(inEncaps);
-        initial->ice_invoke("opOneOptional", Ice::Normal, inEncaps, outEncaps);
+        initial->ice_invoke("opOneOptional", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps);
         Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
         in.startEncapsulation();
         in.read(1, p2);
@@ -1269,27 +1452,37 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
     }
 
     {
-        IceUtil::Optional<OneOptionalPrx> p1;
-        IceUtil::Optional<OneOptionalPrx> p3;
-        IceUtil::Optional<OneOptionalPrx> p2 = initial->opOneOptionalProxy(p1, p3);
+        IceUtil::Optional<OneOptionalPrxPtr> p1;
+        IceUtil::Optional<OneOptionalPrxPtr> p3;
+        IceUtil::Optional<OneOptionalPrxPtr> p2 = initial->opOneOptionalProxy(p1, p3);
         test(!p2 && !p3);
 
-        p1 = OneOptionalPrx::uncheckedCast(communicator->stringToProxy("test"));
+        p1 = ICE_UNCHECKED_CAST(OneOptionalPrx, communicator->stringToProxy("test"));
         p2 = initial->opOneOptionalProxy(p1, p3);
+
+#ifdef ICE_CPP11_MAPPING
+        test(targetEquals(p2.value(), p1.value()) && targetEquals(p3.value(), p1.value()));
+#else
         test(p2 == p1 && p3 == p1);
+#endif
 
         Ice::OutputStream out(communicator);
         out.startEncapsulation();
         out.write(2, p1);
         out.endEncapsulation();
         out.finished(inEncaps);
-        initial->ice_invoke("opOneOptionalProxy", Ice::Normal, inEncaps, outEncaps);
+        initial->ice_invoke("opOneOptionalProxy", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps);
         Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
         in.startEncapsulation();
         in.read(1, p2);
         in.read(3, p3);
         in.endEncapsulation();
+
+#ifdef ICE_CPP11_MAPPING
+        test(targetEquals(p2.value(), p1.value()) && targetEquals(p3.value(), p1.value()));
+#else
         test(p2 == p1 && p3 == p1);
+#endif
 
         Ice::InputStream in2(communicator, out.getEncoding(), outEncaps);
         in2.startEncapsulation();
@@ -1297,15 +1490,20 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
     }
 
     {
-        FPtr f = new F();
-        f->af = new A();
+        FPtr f = ICE_MAKE_SHARED(F);
+        f->af = ICE_MAKE_SHARED(A);
         (*f->af)->requiredA = 56;
         f->ae = *f->af;
 
         Ice::OutputStream out(communicator);
         out.startEncapsulation();
+#ifdef ICE_CPP11_MAPPING
+        out.write(1, make_optional(f));
+        out.write(2, make_optional(f->ae));
+#else
         out.write(1, makeOptional(f));
         out.write(2, makeOptional(f->ae));
+#endif
         out.endEncapsulation();
         out.finished(inEncaps);
 
@@ -1327,12 +1525,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
 
         vector<Ice::Byte> bs(100);
         fill(bs.begin(), bs.end(), 56);
-#if defined(__SUNPRO_CC) && defined(_RWSTD_NO_MEMBER_TEMPLATES)
-        std::pair<const Ice::Byte*, const Ice::Byte*> cpair(&bs[0], &bs[0] + bs.size());
-        p1 = cpair;
-#else
-        p1 = make_pair(&bs[0], &bs[0] + bs.size());
-#endif
+        p1 = toArrayRange(bs);
         p2 = initial->opByteSeq(p1, p3);
         test(p2 && p3);
         test(p2 == bs && p3 == bs);
@@ -1342,7 +1535,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         out.write(2, p1);
         out.endEncapsulation();
         out.finished(inEncaps);
-        initial->ice_invoke("opByteSeq", Ice::Normal, inEncaps, outEncaps);
+        initial->ice_invoke("opByteSeq", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps);
         Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
         in.startEncapsulation();
         in.read(1, p2);
@@ -1364,12 +1557,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         bool bs[100];
         fill(&bs[0], &bs[0] + 100, true);
         vector<bool> bsv(&bs[0], &bs[0] + 100);
-#if defined(__SUNPRO_CC) && defined(_RWSTD_NO_MEMBER_TEMPLATES)
-        std::pair<const bool*, const bool*> cpair(&bs[0], &bs[0] + 100);
-        p1 = cpair;
-#else
-        p1 = make_pair(&bs[0], &bs[0] + 100);
-#endif
+        p1 = toArrayRange(bs, 100);
         p2 = initial->opBoolSeq(p1, p3);
         test(p2 && p3);
         test(p2 == bsv && p3 == bsv);
@@ -1379,7 +1567,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         out.write(2, p1);
         out.endEncapsulation();
         out.finished(inEncaps);
-        initial->ice_invoke("opBoolSeq", Ice::Normal, inEncaps, outEncaps);
+        initial->ice_invoke("opBoolSeq", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps);
         Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
         in.startEncapsulation();
         in.read(1, p2);
@@ -1400,12 +1588,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
 
         vector<Ice::Short> bs(100);
         fill(bs.begin(), bs.end(), 56);
-#if defined(__SUNPRO_CC) && defined(_RWSTD_NO_MEMBER_TEMPLATES)
-        std::pair<const Ice::Short*, const Ice::Short*> cpair(&bs[0], &bs[0] + bs.size());
-        p1 = cpair;
-#else
-        p1 = make_pair(&bs[0], &bs[0] + bs.size());
-#endif
+        p1 = toArrayRange(bs);
         p2 = initial->opShortSeq(p1, p3);
         test(p2 && p3);
         test(p2 == bs && p3 == bs);
@@ -1415,7 +1598,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         out.write(2, p1);
         out.endEncapsulation();
         out.finished(inEncaps);
-        initial->ice_invoke("opShortSeq", Ice::Normal, inEncaps, outEncaps);
+        initial->ice_invoke("opShortSeq", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps);
         Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
         in.startEncapsulation();
         in.read(1, p2);
@@ -1436,12 +1619,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
 
         vector<Ice::Int> bs(100);
         fill(bs.begin(), bs.end(), 56);
-#if defined(__SUNPRO_CC) && defined(_RWSTD_NO_MEMBER_TEMPLATES)
-        std::pair<const Ice::Int*, const Ice::Int*> cpair(&bs[0], &bs[0] + bs.size());
-        p1 = cpair;
-#else
-        p1 = make_pair(&bs[0], &bs[0] + bs.size());
-#endif
+        p1 = toArrayRange(bs);
         p2 = initial->opIntSeq(p1, p3);
         test(p2 && p3);
         test(p2 == bs && p3 == bs);
@@ -1451,7 +1629,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         out.write(2, p1);
         out.endEncapsulation();
         out.finished(inEncaps);
-        initial->ice_invoke("opIntSeq", Ice::Normal, inEncaps, outEncaps);
+        initial->ice_invoke("opIntSeq", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps);
         Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
         in.startEncapsulation();
         in.read(1, p2);
@@ -1472,12 +1650,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
 
         vector<Ice::Long> bs(100);
         fill(bs.begin(), bs.end(), 56);
-#if defined(__SUNPRO_CC) && defined(_RWSTD_NO_MEMBER_TEMPLATES)
-        std::pair<const Ice::Long*, const Ice::Long*> cpair(&bs[0], &bs[0] + bs.size());
-        p1 = cpair;
-#else
-        p1 = make_pair(&bs[0], &bs[0] + bs.size());
-#endif
+        p1 = toArrayRange(bs);
         p2 = initial->opLongSeq(p1, p3);
         test(p2 && p3);
         test(p2 == bs && p3 == bs);
@@ -1487,7 +1660,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         out.write(2, p1);
         out.endEncapsulation();
         out.finished(inEncaps);
-        initial->ice_invoke("opLongSeq", Ice::Normal, inEncaps, outEncaps);
+        initial->ice_invoke("opLongSeq", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps);
         Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
         in.startEncapsulation();
         in.read(1, p2);
@@ -1508,12 +1681,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
 
         vector<Ice::Float> bs(100);
         fill(bs.begin(), bs.end(), 1.0f);
-#if defined(__SUNPRO_CC) && defined(_RWSTD_NO_MEMBER_TEMPLATES)
-        std::pair<const Ice::Float*, const Ice::Float*> cpair(&bs[0], &bs[0] + bs.size());
-        p1 = cpair;
-#else
-        p1 = make_pair(&bs[0], &bs[0] + bs.size());
-#endif
+        p1 = toArrayRange(bs);
         p2 = initial->opFloatSeq(p1, p3);
         test(p2 && p3);
         test(p2 == bs && p3 == bs);
@@ -1523,7 +1691,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         out.write(2, p1);
         out.endEncapsulation();
         out.finished(inEncaps);
-        initial->ice_invoke("opFloatSeq", Ice::Normal, inEncaps, outEncaps);
+        initial->ice_invoke("opFloatSeq", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps);
         Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
         in.startEncapsulation();
         in.read(1, p2);
@@ -1544,12 +1712,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
 
         vector<Ice::Double> bs(100);
         fill(bs.begin(), bs.end(), 1.0);
-#if defined(__SUNPRO_CC) && defined(_RWSTD_NO_MEMBER_TEMPLATES)
-        std::pair<const Ice::Double*, const Ice::Double*> cpair(&bs[0], &bs[0] + bs.size());
-        p1 = cpair;
-#else
-        p1 = make_pair(&bs[0], &bs[0] + bs.size());
-#endif
+        p1 = toArrayRange(bs);
         p2 = initial->opDoubleSeq(p1, p3);
         test(p2 && p3);
         test(p2 == bs && p3 == bs);
@@ -1559,7 +1722,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         out.write(2, p1);
         out.endEncapsulation();
         out.finished(inEncaps);
-        initial->ice_invoke("opDoubleSeq", Ice::Normal, inEncaps, outEncaps);
+        initial->ice_invoke("opDoubleSeq", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps);
         Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
         in.startEncapsulation();
         in.read(1, p2);
@@ -1572,6 +1735,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         in2.endEncapsulation();
     }
 
+#ifndef ICE_CPP11_MAPPING
     {
         IceUtil::Optional<std::pair<StringSeq::const_iterator, StringSeq::const_iterator> > p1;
         IceUtil::Optional<StringSeq> p3;
@@ -1595,7 +1759,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         out.write(2, p1);
         out.endEncapsulation();
         out.finished(inEncaps);
-        initial->ice_invoke("opStringSeq", Ice::Normal, inEncaps, outEncaps);
+        initial->ice_invoke("opStringSeq", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps);
         Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
         in.startEncapsulation();
         in.read(1, p2);
@@ -1607,6 +1771,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         in2.startEncapsulation();
         in2.endEncapsulation();
     }
+#endif
 
     {
         IceUtil::Optional<std::pair<const FixedStruct*, const FixedStruct*> > p1;
@@ -1617,7 +1782,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         std::pair<const FixedStruct*, const FixedStruct*> p;
         p.first = p.second = 0;
         p2 = initial->opFixedStructSeq(p, p3);
-        test(p2 && p3 && p2.get().empty() && p3.get().empty());
+        test(p2 && p3 && p2.value().empty() && p3.value().empty());
 
         FixedStruct fss[10];
         fss[0].m = 1;
@@ -1631,12 +1796,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         fss[8].m = 9;
         fss[9].m = 10;
         vector<FixedStruct> fssv(&fss[0], &fss[0] + 10);
-#if defined(__SUNPRO_CC) && defined(_RWSTD_NO_MEMBER_TEMPLATES)
-        std::pair<const FixedStruct*, const FixedStruct*> cpair(&fss[0], &fss[0] + 10);
-        p1 = cpair;
-#else
-        p1 = make_pair(&fss[0], &fss[0] + 10);
-#endif
+        p1 = toArrayRange(fss, 10);
         p2 = initial->opFixedStructSeq(p1, p3);
         test(p2 && p3);
         test(p2 == fssv && p3 == fssv);
@@ -1646,7 +1806,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         out.write(2, p1);
         out.endEncapsulation();
         out.finished(inEncaps);
-        initial->ice_invoke("opFixedStructSeq", Ice::Normal, inEncaps, outEncaps);
+        initial->ice_invoke("opFixedStructSeq", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps);
         Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
         in.startEncapsulation();
         in.read(1, p2);
@@ -1659,6 +1819,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         in2.endEncapsulation();
     }
 
+#ifndef ICE_CPP11_MAPPING
     {
         IceUtil::Optional<std::pair<VarStructSeq::const_iterator, VarStructSeq::const_iterator> > p1;
         IceUtil::Optional<VarStructSeq> p3;
@@ -1681,7 +1842,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         out.write(2, p1);
         out.endEncapsulation();
         out.finished(inEncaps);
-        initial->ice_invoke("opVarStructSeq", Ice::Normal, inEncaps, outEncaps);
+        initial->ice_invoke("opVarStructSeq", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps);
         Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
         in.startEncapsulation();
         in.read(1, p2);
@@ -1693,6 +1854,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         in2.startEncapsulation();
         in2.endEncapsulation();
     }
+#endif
     cout << "ok" << endl;
 
     cout << "testing optional parameters and dictionaries... " << flush;
@@ -1714,7 +1876,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         out.write(2, p1);
         out.endEncapsulation();
         out.finished(inEncaps);
-        initial->ice_invoke("opIntIntDict", Ice::Normal, inEncaps, outEncaps);
+        initial->ice_invoke("opIntIntDict", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps);
         Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
         in.startEncapsulation();
         in.read(1, p2);
@@ -1745,7 +1907,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         out.write(2, p1);
         out.endEncapsulation();
         out.finished(inEncaps);
-        initial->ice_invoke("opStringIntDict", Ice::Normal, inEncaps, outEncaps);
+        initial->ice_invoke("opStringIntDict", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps);
         Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
         in.startEncapsulation();
         in.read(1, p2);
@@ -1765,7 +1927,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         test(!p2 && !p3);
 
         IntOneOptionalDict ss;
-        ss.insert(make_pair<int, OneOptionalPtr>(1, new OneOptional(58)));
+        ss.insert(make_pair<int, OneOptionalPtr>(1, ICE_MAKE_SHARED(OneOptional, 58)));
         p1 = ss;
         p2 = initial->opIntOneOptionalDict(p1, p3);
         test(p2 && p3);
@@ -1776,7 +1938,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         out.write(2, p1);
         out.endEncapsulation();
         out.finished(inEncaps);
-        initial->ice_invoke("opIntOneOptionalDict", Ice::Normal, inEncaps, outEncaps);
+        initial->ice_invoke("opIntOneOptionalDict", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps);
         Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
         in.startEncapsulation();
         in.read(1, p2);
@@ -1811,7 +1973,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
             out.write(2, p1);
             out.endEncapsulation();
             out.finished(inEncaps);
-            initial->ice_invoke("opCustomIntStringDict", Ice::Normal, inEncaps, outEncaps);
+            initial->ice_invoke("opCustomIntStringDict", Ice::ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps);
             Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
             in.startEncapsulation();
             in.read(1, p2);
@@ -1846,13 +2008,13 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
 
         try
         {
-            initial->opOptionalException(30, "test", new OneOptional(53));
+            initial->opOptionalException(30, string("test"), ICE_MAKE_SHARED(OneOptional, 53));
             test(false);
         }
         catch(const OptionalException& ex)
         {
             test(ex.a == 30);
-            test(ex.b == "test");
+            test(ex.b == string("test"));
             test((*ex.o)->a = 53);
         }
 
@@ -1862,7 +2024,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
             // Use the 1.0 encoding with an exception whose only class members are optional.
             //
             initial->ice_encodingVersion(Ice::Encoding_1_0)->
-                opOptionalException(30, "test", new OneOptional(53));
+                opOptionalException(30, string("test"), ICE_MAKE_SHARED(OneOptional, 53));
             test(false);
         }
         catch(const OptionalException& ex)
@@ -1896,17 +2058,17 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         try
         {
             IceUtil::Optional<Ice::Int> a = 30;
-            IceUtil::Optional<string> b = "test2";
-            IceUtil::Optional<OneOptionalPtr> o = new OneOptional(53);
+            IceUtil::Optional<string> b = string("test2");
+            IceUtil::Optional<OneOptionalPtr> o = ICE_MAKE_SHARED(OneOptional, 53);
             initial->opDerivedException(a, b, o);
             test(false);
         }
         catch(const DerivedException& ex)
         {
             test(ex.a == 30);
-            test(ex.b == "test2");
+            test(ex.b == string("test2"));
             test((*ex.o)->a == 53);
-            test(ex.ss == "test2");
+            test(ex.ss == string("test2"));
             test((*ex.o2)->a == 53);
         }
         catch(const OptionalException&)
@@ -1927,7 +2089,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
             test(!ex.a);
             test(!ex.b);
             test(!ex.o);
-            test(ex.ss == "test");
+            test(ex.ss == string("test"));
             test(!ex.o2);
         }
         catch(const OptionalException&)
@@ -1938,17 +2100,17 @@ allTests(const Ice::CommunicatorPtr& communicator, bool)
         try
         {
             IceUtil::Optional<Ice::Int> a = 30;
-            IceUtil::Optional<string> b = "test2";
-            IceUtil::Optional<OneOptionalPtr> o = new OneOptional(53);
+            IceUtil::Optional<string> b = string("test2");
+            IceUtil::Optional<OneOptionalPtr> o = ICE_MAKE_SHARED(OneOptional, 53);
             initial->opRequiredException(a, b, o);
             test(false);
         }
         catch(const RequiredException& ex)
         {
             test(ex.a == 30);
-            test(ex.b == "test2");
+            test(ex.b == string("test2"));
             test((*ex.o)->a == 53);
-            test(ex.ss == "test2");
+            test(ex.ss == string("test2"));
             test(ex.o2->a == 53);
         }
         catch(const OptionalException&)
diff --git a/cpp/test/Ice/optional/Client.cpp b/cpp/test/Ice/optional/Client.cpp
index d8a550ffd13..4983ad69a88 100644
--- a/cpp/test/Ice/optional/Client.cpp
+++ b/cpp/test/Ice/optional/Client.cpp
@@ -19,8 +19,8 @@ using namespace Test;
 int
 run(int, char**, const Ice::CommunicatorPtr& communicator)
 {
-    InitialPrx allTests(const Ice::CommunicatorPtr&, bool);
-    InitialPrx initial = allTests(communicator, false);
+    InitialPrxPtr allTests(const Ice::CommunicatorPtr&, bool);
+    InitialPrxPtr initial = allTests(communicator, false);
     initial->shutdown();
     return EXIT_SUCCESS;
 }
diff --git a/cpp/test/Ice/optional/Server.cpp b/cpp/test/Ice/optional/Server.cpp
index dad0a56fd58..fe22e6abe87 100644
--- a/cpp/test/Ice/optional/Server.cpp
+++ b/cpp/test/Ice/optional/Server.cpp
@@ -21,7 +21,7 @@ run(int, char**, const Ice::CommunicatorPtr& communicator)
 {
     communicator->getProperties()->setProperty("TestAdapter.Endpoints", getTestEndpoint(communicator, 0));
     Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
-    adapter->add(new InitialI(), communicator->stringToIdentity("initial"));
+    adapter->add(ICE_MAKE_SHARED(InitialI), communicator->stringToIdentity("initial"));
     adapter->activate();
     TEST_READY
     communicator->waitForShutdown();
diff --git a/cpp/test/Ice/optional/ServerAMD.cpp b/cpp/test/Ice/optional/ServerAMD.cpp
index 47976af6280..9b4c93e894b 100644
--- a/cpp/test/Ice/optional/ServerAMD.cpp
+++ b/cpp/test/Ice/optional/ServerAMD.cpp
@@ -20,7 +20,7 @@ run(int, char**, const Ice::CommunicatorPtr& communicator)
 {
     communicator->getProperties()->setProperty("TestAdapter.Endpoints", getTestEndpoint(communicator, 0));
     Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
-    adapter->add(new InitialI(), communicator->stringToIdentity("initial"));
+    adapter->add(ICE_MAKE_SHARED(InitialI), communicator->stringToIdentity("initial"));
     adapter->activate();
     TEST_READY
     communicator->waitForShutdown();
diff --git a/cpp/test/Ice/optional/StringView.h b/cpp/test/Ice/optional/StringView.h
index 8dd1d7d6f73..43e5bf74bb7 100644
--- a/cpp/test/Ice/optional/StringView.h
+++ b/cpp/test/Ice/optional/StringView.h
@@ -153,11 +153,13 @@ struct StreamHelper<Util::string_view, StreamHelperCategoryBuiltin>
     template<class S> static inline void
     write(S* stream, const Util::string_view& v)
     {
-
-#ifdef STRING_VIEW_IGNORE_STRING_CONVERTER
-        stream->write(v.data(), v.size(), false);
+#ifdef ICE_CPP11_MAPPING
+        stream->write(v.data(), v.size());
 #else
-        stream->write(v.data(), v.size(), true);
+        //
+        // In C++98, for consistency with the read, we don't string-convert
+        //
+        stream->write(v.data(), v.size(), false);
 #endif
     }
 
@@ -167,19 +169,10 @@ struct StreamHelper<Util::string_view, StreamHelperCategoryBuiltin>
         const char* vdata = 0;
         size_t vsize = 0;
 
-#ifdef STRING_VIEW_IGNORE_STRING_CONVERTER
+        //
+        // In C++98, we ignore the string converter
+        //
         stream->read(vdata, vsize);
-#else
-        std::string holder;
-        stream->read(vdata, vsize, holder);
-        
-        // If holder is not empty, a string conversion occured, and we can't return a 
-        // string_view since it does not hold the memory
-        if(!holder.empty())
-        {
-            throw Ice::MarshalException(__FILE__, __LINE__, "string conversion not supported");
-        }
-#endif
 
         if(vsize > 0)
         {
diff --git a/cpp/test/Ice/optional/TestAMDI.cpp b/cpp/test/Ice/optional/TestAMDI.cpp
index 1dd8489d5c4..9e277a1ad7e 100644
--- a/cpp/test/Ice/optional/TestAMDI.cpp
+++ b/cpp/test/Ice/optional/TestAMDI.cpp
@@ -19,6 +19,397 @@ InitialI::InitialI()
 {
 }
 
+#ifdef ICE_CPP11_MAPPING
+
+void
+InitialI::shutdownAsync(::std::function<void()> response,
+                        ::std::function<void(::std::exception_ptr)>, const Ice::Current& current)
+{
+    current.adapter->getCommunicator()->shutdown();
+    response();
+}
+
+void
+InitialI::pingPongAsync(::std::shared_ptr<::Ice::Value> obj,
+                        ::std::function<void(const ::std::shared_ptr<::Ice::Value>&)> response,
+                        ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(obj);
+}
+
+void
+InitialI::opOptionalExceptionAsync(Ice::optional<int> a, Ice::optional<::std::string> b, Ice::optional<::std::shared_ptr<::Test::OneOptional>> o,
+                                   ::std::function<void()>,
+                                   ::std::function<void(::std::exception_ptr)> ex, const Ice::Current&)
+{
+    ex(make_exception_ptr(OptionalException(false, a, b, o)));
+}
+
+void
+InitialI::opDerivedExceptionAsync(Ice::optional<int> a, Ice::optional<::std::string> b, Ice::optional<::std::shared_ptr<::Test::OneOptional>> o,
+                                  ::std::function<void()>,
+                                  ::std::function<void(::std::exception_ptr)> ex, const Ice::Current&)
+{
+    ex(make_exception_ptr(DerivedException(false, a, b, o, b, o)));
+}
+
+
+void
+InitialI::opRequiredExceptionAsync(Ice::optional<int> a, Ice::optional<::std::string> b, Ice::optional<::std::shared_ptr<::Test::OneOptional>> o,
+                                   ::std::function<void()>,
+                                   ::std::function<void(::std::exception_ptr)> ex, const Ice::Current&)
+{
+    RequiredException e;
+    e.a = a;
+    e.b = b;
+    e.o = o;
+    if(b)
+    {
+        e.ss = b.value();
+    }
+    if(o)
+    {
+        e.o2 = o.value();
+    }
+
+    ex(make_exception_ptr(e));
+}
+
+void
+InitialI::opByteAsync(Ice::optional<::Ice::Byte> p1,
+                      ::std::function<void(const Ice::optional<::Ice::Byte>&, const Ice::optional<::Ice::Byte>&)> response,
+                      ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(p1, p1);
+}
+
+void
+InitialI::opBoolAsync(Ice::optional<bool> p1,
+                      ::std::function<void(const Ice::optional<bool>&, const Ice::optional<bool>&)> response,
+                      ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(p1, p1);
+}
+
+void
+InitialI::opShortAsync(Ice::optional<short> p1,
+                            ::std::function<void(const Ice::optional<short>&, const Ice::optional<short>&)> response,
+                            ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(p1, p1);
+}
+
+void
+InitialI::opIntAsync(Ice::optional<int> p1,
+                     ::std::function<void(const Ice::optional<int>&, const Ice::optional<int>&)> response,
+                     ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(p1, p1);
+}
+
+void
+InitialI::opLongAsync(Ice::optional<long long int> p1,
+                           ::std::function<void(const Ice::optional<long long int>&, const Ice::optional<long long int>&)> response,
+                           ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(p1, p1);
+}
+
+void
+InitialI::opFloatAsync(Ice::optional<float> p1,
+                            ::std::function<void(const Ice::optional<float>&, const Ice::optional<float>&)> response,
+                            ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(p1, p1);
+}
+
+void
+InitialI::opDoubleAsync(Ice::optional<double> p1,
+                             ::std::function<void(const Ice::optional<double>&, const Ice::optional<double>&)> response,
+                             ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(p1, p1);
+}
+
+void
+InitialI::opStringAsync(Ice::optional<::std::string> p1,
+                             ::std::function<void(const Ice::optional<::std::string>&, const Ice::optional<::std::string>&)> response,
+                             ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(p1, p1);
+}
+
+void
+InitialI::opCustomStringAsync(Ice::optional<Util::string_view> p1,
+                                   ::std::function<void(const Ice::optional<Util::string_view>&, const Ice::optional<Util::string_view>&)> response,
+                                   ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(p1, p1);
+}
+
+void
+InitialI::opMyEnumAsync(Ice::optional<::Test::MyEnum> p1,
+                             ::std::function<void(const Ice::optional<::Test::MyEnum>&, const Ice::optional<::Test::MyEnum>&)> response,
+                             ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(p1, p1);
+}
+
+void
+InitialI::opSmallStructAsync(Ice::optional<::Test::SmallStruct> p1,
+                                  ::std::function<void(const Ice::optional<::Test::SmallStruct>&, const Ice::optional<::Test::SmallStruct>&)> response,
+                                  ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(p1, p1);
+}
+
+void
+InitialI::opFixedStructAsync(Ice::optional<::Test::FixedStruct> p1,
+                                  ::std::function<void(const Ice::optional<::Test::FixedStruct>&, const Ice::optional<::Test::FixedStruct>&)> response,
+                                  ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(p1, p1);
+}
+
+void
+InitialI::opVarStructAsync(Ice::optional<::Test::VarStruct> p1,
+                                ::std::function<void(const Ice::optional<::Test::VarStruct>&, const Ice::optional<::Test::VarStruct>&)> response,
+                                ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(p1, p1);
+}
+
+void
+InitialI::opOneOptionalAsync(Ice::optional<::std::shared_ptr<::Test::OneOptional>> p1,
+                                  ::std::function<void(const Ice::optional<::std::shared_ptr<::Test::OneOptional>>&, const Ice::optional<::std::shared_ptr<::Test::OneOptional>>&)> response,
+                                  ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(p1, p1);
+}
+
+void
+InitialI::opOneOptionalProxyAsync(Ice::optional<::std::shared_ptr<::Ice::ObjectPrx>> p1,
+                                       ::std::function<void(const Ice::optional<::std::shared_ptr<::Ice::ObjectPrx>>&, const Ice::optional<::std::shared_ptr<::Ice::ObjectPrx>>&)> response,
+                                       ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(p1, p1);
+}
+
+void
+InitialI::opByteSeqAsync(Ice::optional<::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>> p1,
+                              ::std::function<void(const Ice::optional<::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>>&, const Ice::optional<::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>>&)> response,
+                              ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(p1, p1);
+}
+
+void
+InitialI::opBoolSeqAsync(Ice::optional<::std::pair<const bool*, const bool*>> p1,
+                              ::std::function<void(const Ice::optional<::std::pair<const bool*, const bool*>>&, const Ice::optional<::std::pair<const bool*, const bool*>>&)> response,
+                              ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(p1, p1);
+}
+
+void
+InitialI::opShortSeqAsync(Ice::optional<::std::pair<const short*, const short*>> p1,
+                               ::std::function<void(const Ice::optional<::std::pair<const short*, const short*>>&, const Ice::optional<::std::pair<const short*, const short*>>&)> response,
+                               ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(p1, p1);
+}
+
+void
+InitialI::opIntSeqAsync(Ice::optional<::std::pair<const int*, const int*>> p1,
+                             ::std::function<void(const Ice::optional<::std::pair<const int*, const int*>>&, const Ice::optional<::std::pair<const int*, const int*>>&)> response,
+                             ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(p1, p1);
+}
+
+void
+InitialI::opLongSeqAsync(Ice::optional<::std::pair<const long long int*, const long long int*>> p1,
+                              ::std::function<void(const Ice::optional<::std::pair<const long long int*, const long long int*>>&, const Ice::optional<::std::pair<const long long int*, const long long int*>>&)> response,
+                              ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(p1, p1);
+}
+
+void
+InitialI::opFloatSeqAsync(Ice::optional<::std::pair<const float*, const float*>> p1,
+                               ::std::function<void(const Ice::optional<::std::pair<const float*, const float*>>&, const Ice::optional<::std::pair<const float*, const float*>>&)> response,
+                               ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(p1, p1);
+}
+
+void
+InitialI::opDoubleSeqAsync(Ice::optional<::std::pair<const double*, const double*>> p1,
+                                ::std::function<void(const Ice::optional<::std::pair<const double*, const double*>>&, const Ice::optional<::std::pair<const double*, const double*>>&)> response,
+                                ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(p1, p1);
+}
+
+void
+InitialI::opStringSeqAsync(Ice::optional<::Test::StringSeq> p1,
+                                ::std::function<void(const Ice::optional<::Test::StringSeq>&, const Ice::optional<::Test::StringSeq>&)> response,
+                                ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(p1, p1);
+}
+
+void
+InitialI::opSmallStructSeqAsync(Ice::optional<::std::pair<const ::Test::SmallStruct*, const ::Test::SmallStruct*>> p1,
+                                     ::std::function<void(const Ice::optional<::std::pair<const ::Test::SmallStruct*, const ::Test::SmallStruct*>>&, const Ice::optional<::std::pair<const ::Test::SmallStruct*, const ::Test::SmallStruct*>>&)> response,
+                                     ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(p1, p1);
+}
+
+void
+InitialI::opSmallStructListAsync(Ice::optional<::std::pair<const ::Test::SmallStruct*, const ::Test::SmallStruct*>> p1,
+                                      ::std::function<void(const Ice::optional<::std::pair<const ::Test::SmallStruct*, const ::Test::SmallStruct*>>&, const Ice::optional<::std::pair<const ::Test::SmallStruct*, const ::Test::SmallStruct*>>&)> response,
+                                      ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(p1, p1);
+}
+
+void
+InitialI::opFixedStructSeqAsync(Ice::optional<::std::pair<const ::Test::FixedStruct*, const ::Test::FixedStruct*>> p1,
+                                     ::std::function<void(const Ice::optional<::std::pair<const ::Test::FixedStruct*, const ::Test::FixedStruct*>>&, const Ice::optional<::std::pair<const ::Test::FixedStruct*, const ::Test::FixedStruct*>>&)> response,
+                                     ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(p1, p1);
+}
+
+void
+InitialI::opFixedStructListAsync(Ice::optional<::std::pair<const ::Test::FixedStruct*, const ::Test::FixedStruct*>> p1,
+                                 ::std::function<void(const Ice::optional<::std::pair<const ::Test::FixedStruct*, const ::Test::FixedStruct*>>&, const Ice::optional<::std::pair<const ::Test::FixedStruct*, const ::Test::FixedStruct*>>&)> response,
+                                 ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(p1, p1);
+}
+
+void
+InitialI::opVarStructSeqAsync(Ice::optional<::Test::VarStructSeq> p1,
+                              ::std::function<void(const Ice::optional<::Test::VarStructSeq>&, const Ice::optional<::Test::VarStructSeq>&)> response,
+                              ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(p1, p1);
+}
+
+void
+InitialI::opSerializableAsync(Ice::optional<::Test::Serializable> p1,
+                              ::std::function<void(const Ice::optional<::Test::Serializable>&, const Ice::optional<::Test::Serializable>&)> response,
+                              ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(p1, p1);
+}
+
+void
+InitialI::opIntIntDictAsync(Ice::optional<::Test::IntIntDict> p1,
+                            ::std::function<void(const Ice::optional<::Test::IntIntDict>&, const Ice::optional<::Test::IntIntDict>&)> response,
+                            ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(p1, p1);
+}
+
+
+void
+InitialI::opStringIntDictAsync(Ice::optional<::Test::StringIntDict> p1,
+                               ::std::function<void(const Ice::optional<::Test::StringIntDict>&, const Ice::optional<::Test::StringIntDict>&)> response,
+                               ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(p1, p1);
+}
+
+void
+InitialI::opIntOneOptionalDictAsync(Ice::optional<::Test::IntOneOptionalDict> p1,
+                                    ::std::function<void(const Ice::optional<::Test::IntOneOptionalDict>&, const Ice::optional<::Test::IntOneOptionalDict>&)> response,
+                                    ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(p1, p1);
+}
+
+void
+InitialI::opCustomIntStringDictAsync(Ice::optional<::std::map< int, ::Util::string_view>> p1,
+                                     ::std::function<void(const Ice::optional<::std::map< int, ::Util::string_view>>&, const Ice::optional<::std::map< int, ::Util::string_view>>&)> response,
+                                     ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(p1, p1);
+}
+
+void
+InitialI::opClassAndUnknownOptionalAsync(::std::shared_ptr<::Test::A>,
+                                         ::std::function<void()> response,
+                                         ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response();
+}
+
+void
+InitialI::sendOptionalClassAsync(bool, Ice::optional<::std::shared_ptr<::Test::OneOptional>>,
+                                 ::std::function<void()> response,
+                                 ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response();
+}
+
+void
+InitialI::returnOptionalClassAsync(bool,
+                                   ::std::function<void(const Ice::optional<::std::shared_ptr<::Test::OneOptional>>&)> response,
+                                   ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(make_shared<OneOptional>(53));
+}
+
+void
+InitialI::opGAsync(::std::shared_ptr<::Test::G> g,
+                   ::std::function<void(const ::std::shared_ptr<::Test::G>&)> response,
+                   ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(g);
+}
+
+void
+InitialI::opVoidAsync(::std::function<void()> response,
+                      ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response();
+}
+
+void
+InitialI::supportsRequiredParamsAsync(::std::function<void(bool)> response,
+                                      ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(false);
+}
+
+void
+InitialI::supportsJavaSerializableAsync(::std::function<void(bool)> response,
+                                        ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(true);
+}
+
+void
+InitialI::supportsCsharpSerializableAsync(::std::function<void(bool)> response,
+                                          ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(true);
+}
+
+void
+InitialI::supportsCppStringViewAsync(::std::function<void(bool)> response,
+                                     ::std::function<void(::std::exception_ptr)>, const Ice::Current&)
+{
+    response(true);
+}
+
+
+#else // C++98 mapping
+
 void
 InitialI::shutdown_async(const ::Test::AMD_Initial_shutdownPtr& cb,
                          const Ice::Current& current)
@@ -426,3 +817,5 @@ InitialI::supportsCppStringView_async(const ::Test::AMD_Initial_supportsCppStrin
 {
     cb->ice_response(true);
 }
+
+#endif
diff --git a/cpp/test/Ice/optional/TestAMDI.h b/cpp/test/Ice/optional/TestAMDI.h
index b689f280a6e..cc0ae8bf9a1 100644
--- a/cpp/test/Ice/optional/TestAMDI.h
+++ b/cpp/test/Ice/optional/TestAMDI.h
@@ -13,12 +13,211 @@
 #include <TestAMD.h>
 
 
-class InitialI : public Test::Initial
+class InitialI :
+#ifdef ICE_CPP11_MAPPING
+    public Test::InitialDisp
+#else
+    public Test::Initial
+#endif
 {
 public:
 
     InitialI();
 
+#ifdef ICE_CPP11_MAPPING
+
+    virtual void shutdownAsync(::std::function<void()>,
+                               ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void pingPongAsync(::std::shared_ptr<::Ice::Value>,
+                               ::std::function<void(const ::std::shared_ptr<::Ice::Value>&)>,
+                               ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void opOptionalExceptionAsync(Ice::optional<int>, Ice::optional<::std::string>, Ice::optional<::std::shared_ptr<::Test::OneOptional>>,
+                                          ::std::function<void()>,
+                                          ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void opDerivedExceptionAsync(Ice::optional<int>, Ice::optional<::std::string>, Ice::optional<::std::shared_ptr<::Test::OneOptional>>,
+                                         ::std::function<void()>,
+                                         ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+
+    virtual void opRequiredExceptionAsync(Ice::optional<int>, Ice::optional<::std::string>, Ice::optional<::std::shared_ptr<::Test::OneOptional>>,
+                                          ::std::function<void()>,
+                                          ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void opByteAsync(Ice::optional<::Ice::Byte>,
+                             ::std::function<void(const Ice::optional<::Ice::Byte>&, const Ice::optional<::Ice::Byte>&)>,
+                             ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+
+    virtual void opBoolAsync(Ice::optional<bool>,
+                             ::std::function<void(const Ice::optional<bool>&, const Ice::optional<bool>&)>,
+                             ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+
+    virtual void opShortAsync(Ice::optional<short>,
+                              ::std::function<void(const Ice::optional<short>&, const Ice::optional<short>&)>,
+                              ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+
+    virtual void opIntAsync(Ice::optional<int>,
+                            ::std::function<void(const Ice::optional<int>&, const Ice::optional<int>&)>,
+                            ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void opLongAsync(Ice::optional<long long int>,
+                             ::std::function<void(const Ice::optional<long long int>&, const Ice::optional<long long int>&)>,
+                             ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void opFloatAsync(Ice::optional<float>,
+                              ::std::function<void(const Ice::optional<float>&, const Ice::optional<float>&)>,
+                              ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void opDoubleAsync(Ice::optional<double>,
+                               ::std::function<void(const Ice::optional<double>&, const Ice::optional<double>&)>,
+                               ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void opStringAsync(Ice::optional<::std::string>,
+                               ::std::function<void(const Ice::optional<::std::string>&, const Ice::optional<::std::string>&)>,
+                               ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void opCustomStringAsync(Ice::optional<Util::string_view>,
+                                     ::std::function<void(const Ice::optional<Util::string_view>&, const Ice::optional<Util::string_view>&)>,
+                                     ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void opMyEnumAsync(Ice::optional<::Test::MyEnum>,
+                               ::std::function<void(const Ice::optional<::Test::MyEnum>&, const Ice::optional<::Test::MyEnum>&)>,
+                               ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void opSmallStructAsync(Ice::optional<::Test::SmallStruct>,
+                                    ::std::function<void(const Ice::optional<::Test::SmallStruct>&, const Ice::optional<::Test::SmallStruct>&)>,
+                                    ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void opFixedStructAsync(Ice::optional<::Test::FixedStruct>,
+                                    ::std::function<void(const Ice::optional<::Test::FixedStruct>&, const Ice::optional<::Test::FixedStruct>&)>,
+                                    ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void opVarStructAsync(Ice::optional<::Test::VarStruct>,
+                                  ::std::function<void(const Ice::optional<::Test::VarStruct>&, const Ice::optional<::Test::VarStruct>&)>,
+                                  ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void opOneOptionalAsync(Ice::optional<::std::shared_ptr<::Test::OneOptional>>,
+                                    ::std::function<void(const Ice::optional<::std::shared_ptr<::Test::OneOptional>>&, const Ice::optional<::std::shared_ptr<::Test::OneOptional>>&)>,
+                                    ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void opOneOptionalProxyAsync(Ice::optional<::std::shared_ptr<::Ice::ObjectPrx>>,
+                                         ::std::function<void(const Ice::optional<::std::shared_ptr<::Ice::ObjectPrx>>&, const Ice::optional<::std::shared_ptr<::Ice::ObjectPrx>>&)>,
+                                         ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void opByteSeqAsync(Ice::optional<::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>>,
+                                ::std::function<void(const Ice::optional<::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>>&, const Ice::optional<::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>>&)>,
+                                ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void opBoolSeqAsync(Ice::optional<::std::pair<const bool*, const bool*>>,
+                                ::std::function<void(const Ice::optional<::std::pair<const bool*, const bool*>>&, const Ice::optional<::std::pair<const bool*, const bool*>>&)>,
+                                ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void opShortSeqAsync(Ice::optional<::std::pair<const short*, const short*>>,
+                                 ::std::function<void(const Ice::optional<::std::pair<const short*, const short*>>&, const Ice::optional<::std::pair<const short*, const short*>>&)>,
+                                 ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void opIntSeqAsync(Ice::optional<::std::pair<const int*, const int*>>,
+                               ::std::function<void(const Ice::optional<::std::pair<const int*, const int*>>&, const Ice::optional<::std::pair<const int*, const int*>>&)>,
+                               ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void opLongSeqAsync(Ice::optional<::std::pair<const long long int*, const long long int*>>,
+                                ::std::function<void(const Ice::optional<::std::pair<const long long int*, const long long int*>>&, const Ice::optional<::std::pair<const long long int*, const long long int*>>&)>,
+                                ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void opFloatSeqAsync(Ice::optional<::std::pair<const float*, const float*>>,
+                                 ::std::function<void(const Ice::optional<::std::pair<const float*, const float*>>&, const Ice::optional<::std::pair<const float*, const float*>>&)>,
+                                 ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void opDoubleSeqAsync(Ice::optional<::std::pair<const double*, const double*>>,
+                                  ::std::function<void(const Ice::optional<::std::pair<const double*, const double*>>&, const Ice::optional<::std::pair<const double*, const double*>>&)>,
+                                  ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void opStringSeqAsync(Ice::optional<::Test::StringSeq>,
+                                  ::std::function<void(const Ice::optional<::Test::StringSeq>&, const Ice::optional<::Test::StringSeq>&)>,
+                                  ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void opSmallStructSeqAsync(Ice::optional<::std::pair<const ::Test::SmallStruct*, const ::Test::SmallStruct*>>,
+                                       ::std::function<void(const Ice::optional<::std::pair<const ::Test::SmallStruct*, const ::Test::SmallStruct*>>&, const Ice::optional<::std::pair<const ::Test::SmallStruct*, const ::Test::SmallStruct*>>&)>,
+                                       ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void opSmallStructListAsync(Ice::optional<::std::pair<const ::Test::SmallStruct*, const ::Test::SmallStruct*>>,
+                                        ::std::function<void(const Ice::optional<::std::pair<const ::Test::SmallStruct*, const ::Test::SmallStruct*>>&, const Ice::optional<::std::pair<const ::Test::SmallStruct*, const ::Test::SmallStruct*>>&)>,
+                                        ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void opFixedStructSeqAsync(Ice::optional<::std::pair<const ::Test::FixedStruct*, const ::Test::FixedStruct*>>,
+                                       ::std::function<void(const Ice::optional<::std::pair<const ::Test::FixedStruct*, const ::Test::FixedStruct*>>&, const Ice::optional<::std::pair<const ::Test::FixedStruct*, const ::Test::FixedStruct*>>&)>,
+                                       ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+
+    virtual void opFixedStructListAsync(Ice::optional<::std::pair<const ::Test::FixedStruct*, const ::Test::FixedStruct*>>,
+                                        ::std::function<void(const Ice::optional<::std::pair<const ::Test::FixedStruct*, const ::Test::FixedStruct*>>&, const Ice::optional<::std::pair<const ::Test::FixedStruct*, const ::Test::FixedStruct*>>&)>,
+                                        ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void opVarStructSeqAsync(Ice::optional<::Test::VarStructSeq>,
+                                     ::std::function<void(const Ice::optional<::Test::VarStructSeq>&, const Ice::optional<::Test::VarStructSeq>&)>,
+                                     ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void opSerializableAsync(Ice::optional<::Test::Serializable>,
+                                     ::std::function<void(const Ice::optional<::Test::Serializable>&, const Ice::optional<::Test::Serializable>&)>,
+                                     ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void opIntIntDictAsync(Ice::optional<::Test::IntIntDict>,
+                                   ::std::function<void(const Ice::optional<::Test::IntIntDict>&, const Ice::optional<::Test::IntIntDict>&)>,
+                                   ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+
+    virtual void opStringIntDictAsync(Ice::optional<::Test::StringIntDict>,
+                                      ::std::function<void(const Ice::optional<::Test::StringIntDict>&, const Ice::optional<::Test::StringIntDict>&)>,
+                                      ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void opIntOneOptionalDictAsync(Ice::optional<::Test::IntOneOptionalDict>,
+                                           ::std::function<void(const Ice::optional<::Test::IntOneOptionalDict>&, const Ice::optional<::Test::IntOneOptionalDict>&)>,
+                                           ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void opCustomIntStringDictAsync(Ice::optional<::std::map< int, ::Util::string_view>>,
+                                            ::std::function<void(const Ice::optional<::std::map< int, ::Util::string_view>>&, const Ice::optional<::std::map< int, ::Util::string_view>>&)>,
+                                            ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void opClassAndUnknownOptionalAsync(::std::shared_ptr<::Test::A>,
+                                                ::std::function<void()>,
+                                                ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void sendOptionalClassAsync(bool, Ice::optional<::std::shared_ptr<::Test::OneOptional>>,
+                                        ::std::function<void()>,
+                                        ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void returnOptionalClassAsync(bool,
+                                          ::std::function<void(const Ice::optional<::std::shared_ptr<::Test::OneOptional>>&)>,
+                                          ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void opGAsync(::std::shared_ptr<::Test::G>,
+                          ::std::function<void(const ::std::shared_ptr<::Test::G>&)>,
+                          ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void opVoidAsync(::std::function<void()>,
+                             ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void supportsRequiredParamsAsync(::std::function<void(bool)>,
+                                             ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void supportsJavaSerializableAsync(::std::function<void(bool)>,
+                                               ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void supportsCsharpSerializableAsync(::std::function<void(bool)>,
+                                                 ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+    virtual void supportsCppStringViewAsync(::std::function<void(bool)>,
+                                            ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
+
+
+
+#else // C++98 mapping
+
     virtual void shutdown_async(const ::Test::AMD_Initial_shutdownPtr&,
                                 const Ice::Current&);
 
@@ -213,6 +412,9 @@ public:
 
     virtual void supportsCppStringView_async(const ::Test::AMD_Initial_supportsCppStringViewPtr&,
                                              const Ice::Current&);
+
+#endif
+
 };
 
 #endif
diff --git a/cpp/test/Ice/optional/TestI.cpp b/cpp/test/Ice/optional/TestI.cpp
index 35207c1dac3..9c68843bdfe 100644
--- a/cpp/test/Ice/optional/TestI.cpp
+++ b/cpp/test/Ice/optional/TestI.cpp
@@ -25,16 +25,16 @@ InitialI::shutdown(const Current& current)
     current.adapter->getCommunicator()->shutdown();
 }
 
-ObjectPtr
-InitialI::pingPong(const ObjectPtr& obj, const Current&)
+ValuePtr
+InitialI::pingPong(ICE_IN(ValuePtr) obj, const Current&)
 {
     return obj;
 }
 
 void
-InitialI::opOptionalException(const Optional<Int>& a,
-                              const Optional<string>& b,
-                              const Optional<OneOptionalPtr>& o,
+InitialI::opOptionalException(ICE_IN(Optional<Int>) a,
+                              ICE_IN(Optional<string>) b,
+                              ICE_IN(Optional<OneOptionalPtr>) o,
                               const Ice::Current&)
 {
     OptionalException ex;
@@ -45,9 +45,9 @@ InitialI::opOptionalException(const Optional<Int>& a,
 }
 
 void
-InitialI::opDerivedException(const Optional<Int>& a,
-                             const Optional<string>& b,
-                             const Optional<OneOptionalPtr>& o,
+InitialI::opDerivedException(ICE_IN(Optional<Int>) a,
+                             ICE_IN(Optional<string>) b,
+                             ICE_IN(Optional<OneOptionalPtr>) o,
                              const Ice::Current&)
 {
     DerivedException ex;
@@ -60,9 +60,9 @@ InitialI::opDerivedException(const Optional<Int>& a,
 }
 
 void
-InitialI::opRequiredException(const Optional<Int>& a,
-                              const Optional<string>& b,
-                              const Optional<OneOptionalPtr>& o,
+InitialI::opRequiredException(ICE_IN(Optional<Int>) a,
+                              ICE_IN(Optional<string>) b,
+                              ICE_IN(Optional<OneOptionalPtr>) o,
                               const Ice::Current&)
 {
     RequiredException ex;
@@ -71,73 +71,73 @@ InitialI::opRequiredException(const Optional<Int>& a,
     ex.o = o;
     if(b)
     {
-        ex.ss = b.get();
+        ex.ss = b.value();
     }
     if(o)
     {
-        ex.o2 = o.get();
+        ex.o2 = o.value();
     }
     throw ex;
 }
 
 Optional<Ice::Byte>
-InitialI::opByte(const Optional<Ice::Byte>& p1, Optional<Ice::Byte>& p3, const Current&)
+InitialI::opByte(ICE_IN(Optional<Ice::Byte>) p1, Optional<Ice::Byte>& p3, const Current&)
 {
     p3 = p1;
     return p1;
 }
 
 Optional<bool>
-InitialI::opBool(const Optional<bool>& p1, Optional<bool>& p3, const Current&)
+InitialI::opBool(ICE_IN(Optional<bool>) p1, Optional<bool>& p3, const Current&)
 {
     p3 = p1;
     return p1;
 }
 
 Optional<Short>
-InitialI::opShort(const Optional<Short>& p1, Optional<Short>& p3, const Current&)
+InitialI::opShort(ICE_IN(Optional<Short>) p1, Optional<Short>& p3, const Current&)
 {
     p3 = p1;
     return p1;
 }
 
 Optional<Int>
-InitialI::opInt(const Optional<Int>& p1, Optional<Int>& p3, const Current&)
+InitialI::opInt(ICE_IN(Optional<Int>) p1, Optional<Int>& p3, const Current&)
 {
     p3 = p1;
     return p1;
 }
 
 Optional<Long>
-InitialI::opLong(const Optional<Long>& p1, Optional<Long>& p3, const Current&)
+InitialI::opLong(ICE_IN(Optional<Long>) p1, Optional<Long>& p3, const Current&)
 {
     p3 = p1;
     return p1;
 }
 
 Optional<Float>
-InitialI::opFloat(const Optional<Float>& p1, Optional<Float>& p3, const Current&)
+InitialI::opFloat(ICE_IN(Optional<Float>) p1, Optional<Float>& p3, const Current&)
 {
     p3 = p1;
     return p1;
 }
 
 Optional<Double>
-InitialI::opDouble(const Optional<Double>& p1, Optional<Double>& p3, const Current&)
+InitialI::opDouble(ICE_IN(Optional<Double>) p1, Optional<Double>& p3, const Current&)
 {
     p3 = p1;
     return p1;
 }
 
 Optional<string>
-InitialI::opString(const Optional<string>& p1, Optional<string>& p3, const Current&)
+InitialI::opString(ICE_IN(Optional<string>) p1, Optional<string>& p3, const Current&)
 {
     p3 = p1;
     return p1;
 }
 
 Optional<string>
-InitialI::opCustomString(const Optional<Util::string_view>& p1, Optional<string>& p3, const Current&)
+InitialI::opCustomString(ICE_IN(Optional<Util::string_view>) p1, Optional<string>& p3, const Current&)
 {
     if(p1)
     {
@@ -148,49 +148,49 @@ InitialI::opCustomString(const Optional<Util::string_view>& p1, Optional<string>
 
 
 Optional<MyEnum>
-InitialI::opMyEnum(const Optional<MyEnum>& p1, Optional<MyEnum>& p3, const Current&)
+InitialI::opMyEnum(ICE_IN(Optional<MyEnum>) p1, Optional<MyEnum>& p3, const Current&)
 {
     p3 = p1;
     return p1;
 }
 
 Optional<SmallStruct>
-InitialI::opSmallStruct(const Optional<SmallStruct>& p1, Optional<SmallStruct>& p3, const Current&)
+InitialI::opSmallStruct(ICE_IN(Optional<SmallStruct>) p1, Optional<SmallStruct>& p3, const Current&)
 {
     p3 = p1;
     return p1;
 }
 
 Optional<FixedStruct>
-InitialI::opFixedStruct(const Optional<FixedStruct>& p1, Optional<FixedStruct>& p3, const Current&)
+InitialI::opFixedStruct(ICE_IN(Optional<FixedStruct>) p1, Optional<FixedStruct>& p3, const Current&)
 {
     p3 = p1;
     return p1;
 }
 
 Optional<VarStruct>
-InitialI::opVarStruct(const Optional<VarStruct>& p1, Optional<VarStruct>& p3, const Current&)
+InitialI::opVarStruct(ICE_IN(Optional<VarStruct>) p1, Optional<VarStruct>& p3, const Current&)
 {
     p3 = p1;
     return p1;
 }
 
 Optional<OneOptionalPtr>
-InitialI::opOneOptional(const Optional<OneOptionalPtr>& p1, Optional<OneOptionalPtr>& p3, const Current&)
+InitialI::opOneOptional(ICE_IN(Optional<OneOptionalPtr>) p1, Optional<OneOptionalPtr>& p3, const Current&)
 {
     p3 = p1;
     return p1;
 }
 
-Optional<OneOptionalPrx>
-InitialI::opOneOptionalProxy(const Optional<OneOptionalPrx>& p1, Optional<OneOptionalPrx>& p3, const Current&)
+Optional<OneOptionalPrxPtr>
+InitialI::opOneOptionalProxy(ICE_IN(Optional<OneOptionalPrxPtr>) p1, Optional<OneOptionalPrxPtr>& p3, const Current&)
 {
     p3 = p1;
     return p1;
 }
 
 Optional<Test::ByteSeq>
-InitialI::opByteSeq(const Optional<pair<const Ice::Byte*, const Ice::Byte*> >& p1, Optional<Test::ByteSeq>& p3,
+InitialI::opByteSeq(ICE_IN(Optional<pair<const Ice::Byte*, const Ice::Byte*> >) p1, Optional<Test::ByteSeq>& p3,
                     const Current&)
 {
     if(p1)
@@ -201,7 +201,7 @@ InitialI::opByteSeq(const Optional<pair<const Ice::Byte*, const Ice::Byte*> >& p
 }
 
 Optional<Test::BoolSeq>
-InitialI::opBoolSeq(const Optional<pair<const bool*, const bool*> >& p1, Optional<Test::BoolSeq>& p3, const Current&)
+InitialI::opBoolSeq(ICE_IN(Optional<pair<const bool*, const bool*> >) p1, Optional<Test::BoolSeq>& p3, const Current&)
 {
     if(p1)
     {
@@ -211,7 +211,7 @@ InitialI::opBoolSeq(const Optional<pair<const bool*, const bool*> >& p1, Optiona
 }
 
 Optional<Test::ShortSeq>
-InitialI::opShortSeq(const Optional<pair<const Short*, const Short*> >& p1, Optional<Test::ShortSeq>& p3,
+InitialI::opShortSeq(ICE_IN(Optional<pair<const Short*, const Short*> >) p1, Optional<Test::ShortSeq>& p3,
                      const Current&)
 {
     if(p1)
@@ -222,7 +222,7 @@ InitialI::opShortSeq(const Optional<pair<const Short*, const Short*> >& p1, Opti
 }
 
 Optional<Test::IntSeq>
-InitialI::opIntSeq(const Optional<pair<const Int*, const Int*> >& p1, Optional<Test::IntSeq>& p3, const Current&)
+InitialI::opIntSeq(ICE_IN(Optional<pair<const Int*, const Int*> >) p1, Optional<Test::IntSeq>& p3, const Current&)
 {
     if(p1)
     {
@@ -232,7 +232,7 @@ InitialI::opIntSeq(const Optional<pair<const Int*, const Int*> >& p1, Optional<T
 }
 
 Optional<Test::LongSeq>
-InitialI::opLongSeq(const Optional<pair<const Long*, const Long*> >& p1, Optional<Test::LongSeq>& p3, const Current&)
+InitialI::opLongSeq(ICE_IN(Optional<pair<const Long*, const Long*> >) p1, Optional<Test::LongSeq>& p3, const Current&)
 {
     if(p1)
     {
@@ -242,7 +242,7 @@ InitialI::opLongSeq(const Optional<pair<const Long*, const Long*> >& p1, Optiona
 }
 
 Optional<Test::FloatSeq>
-InitialI::opFloatSeq(const Optional<pair<const Float*, const Float*> >& p1, Optional<Test::FloatSeq>& p3,
+InitialI::opFloatSeq(ICE_IN(Optional<pair<const Float*, const Float*> >) p1, Optional<Test::FloatSeq>& p3,
                      const Current&)
 {
     if(p1)
@@ -253,7 +253,7 @@ InitialI::opFloatSeq(const Optional<pair<const Float*, const Float*> >& p1, Opti
 }
 
 Optional<Test::DoubleSeq>
-InitialI::opDoubleSeq(const Optional<pair<const Double*, const Double*> >& p1, Optional<Test::DoubleSeq>& p3,
+InitialI::opDoubleSeq(ICE_IN(Optional<pair<const Double*, const Double*> >) p1, Optional<Test::DoubleSeq>& p3,
                       const Current&)
 {
     if(p1)
@@ -263,6 +263,18 @@ InitialI::opDoubleSeq(const Optional<pair<const Double*, const Double*> >& p1, O
     return p3;
 }
 
+#ifdef ICE_CPP11_MAPPING
+optional<Ice::StringSeq>
+InitialI::opStringSeq(optional<Ice::StringSeq> p1,
+                      optional<Ice::StringSeq>& p3, const Current&)
+{
+    if(p1)
+    {
+        p3 = p1;
+    }
+    return p3;
+}
+#else
 Optional<Ice::StringSeq>
 InitialI::opStringSeq(const Optional<pair<Ice::StringSeq::const_iterator, Ice::StringSeq::const_iterator> >& p1,
                       Optional<Ice::StringSeq>& p3, const Current&)
@@ -273,9 +285,10 @@ InitialI::opStringSeq(const Optional<pair<Ice::StringSeq::const_iterator, Ice::S
     }
     return p3;
 }
+#endif
 
 Optional<SmallStructSeq>
-InitialI::opSmallStructSeq(const Optional<pair<const SmallStruct*, const SmallStruct*> >& p1,
+InitialI::opSmallStructSeq(ICE_IN(Optional<pair<const SmallStruct*, const SmallStruct*> >) p1,
                            Optional<SmallStructSeq>& p3, const Current&)
 {
     if(p1)
@@ -286,7 +299,7 @@ InitialI::opSmallStructSeq(const Optional<pair<const SmallStruct*, const SmallSt
 }
 
 Optional<SmallStructList>
-InitialI::opSmallStructList(const Optional<pair<const SmallStruct*, const SmallStruct*> >& p1,
+InitialI::opSmallStructList(ICE_IN(Optional<pair<const SmallStruct*, const SmallStruct*> >) p1,
                             Optional<SmallStructList>& p3, const Current&)
 {
     if(p1)
@@ -297,7 +310,7 @@ InitialI::opSmallStructList(const Optional<pair<const SmallStruct*, const SmallS
 }
 
 Optional<FixedStructSeq>
-InitialI::opFixedStructSeq(const Optional<pair<const FixedStruct*, const FixedStruct*> >& p1,
+InitialI::opFixedStructSeq(ICE_IN(Optional<pair<const FixedStruct*, const FixedStruct*> >) p1,
                            Optional<FixedStructSeq>& p3, const Current&)
 {
     if(p1)
@@ -308,7 +321,7 @@ InitialI::opFixedStructSeq(const Optional<pair<const FixedStruct*, const FixedSt
 }
 
 Optional<FixedStructList>
-InitialI::opFixedStructList(const Optional<pair<const FixedStruct*, const FixedStruct*> >& p1,
+InitialI::opFixedStructList(ICE_IN(Optional<pair<const FixedStruct*, const FixedStruct*> >) p1,
                             Optional<FixedStructList>& p3, const Current&)
 {
     if(p1)
@@ -318,6 +331,18 @@ InitialI::opFixedStructList(const Optional<pair<const FixedStruct*, const FixedS
     return p3;
 }
 
+#ifdef ICE_CPP11_MAPPING
+optional<VarStructSeq>
+InitialI::opVarStructSeq(optional<VarStructSeq> p1,
+                         optional<VarStructSeq>& p3, const Current&)
+{
+    if(p1)
+    {
+        p3 = p1;
+    }
+    return p3;
+}
+#else
 Optional<VarStructSeq>
 InitialI::opVarStructSeq(const Optional<pair<VarStructSeq::const_iterator, VarStructSeq::const_iterator> >& p1,
                          Optional<VarStructSeq>& p3, const Current&)
@@ -328,37 +353,38 @@ InitialI::opVarStructSeq(const Optional<pair<VarStructSeq::const_iterator, VarSt
     }
     return p3;
 }
+#endif
 
 Optional<Serializable>
-InitialI::opSerializable(const Optional<Serializable>& p1, Optional<Serializable>& p3, const Current&)
+InitialI::opSerializable(ICE_IN(Optional<Serializable>) p1, Optional<Serializable>& p3, const Current&)
 {
     p3 = p1;
     return p3;
 }
 
 Optional<IntIntDict>
-InitialI::opIntIntDict(const Optional<IntIntDict>& p1, Optional<IntIntDict>& p3, const Current&)
+InitialI::opIntIntDict(ICE_IN(Optional<IntIntDict>) p1, Optional<IntIntDict>& p3, const Current&)
 {
     p3 = p1;
     return p3;
 }
 
 Optional<StringIntDict>
-InitialI::opStringIntDict(const Optional<StringIntDict>& p1, Optional<StringIntDict>& p3, const Current&)
+InitialI::opStringIntDict(ICE_IN(Optional<StringIntDict>) p1, Optional<StringIntDict>& p3, const Current&)
 {
     p3 = p1;
     return p3;
 }
 
 Optional<IntOneOptionalDict>
-InitialI::opIntOneOptionalDict(const Optional<IntOneOptionalDict>& p1, Optional<IntOneOptionalDict>& p3, const Current&)
+InitialI::opIntOneOptionalDict(ICE_IN(Optional<IntOneOptionalDict>) p1, Optional<IntOneOptionalDict>& p3, const Current&)
 {
     p3 = p1;
     return p3;
 }
 
 Optional<IntStringDict>
-InitialI::opCustomIntStringDict(const Optional<std::map<int, Util::string_view> >& p1,
+InitialI::opCustomIntStringDict(ICE_IN(Optional<std::map<int, Util::string_view> >) p1,
                                 Optional<IntStringDict>& p3, const Current&)
 {
     if(p1)
@@ -375,23 +401,23 @@ InitialI::opCustomIntStringDict(const Optional<std::map<int, Util::string_view>
 
 
 void
-InitialI::opClassAndUnknownOptional(const APtr&, const Ice::Current&)
+InitialI::opClassAndUnknownOptional(ICE_IN(APtr), const Ice::Current&)
 {
 }
 
 void
-InitialI::sendOptionalClass(bool, const Optional<OneOptionalPtr>&, const Ice::Current&)
+InitialI::sendOptionalClass(bool, ICE_IN(Optional<OneOptionalPtr>), const Ice::Current&)
 {
 }
 
 void
 InitialI::returnOptionalClass(bool, Optional<OneOptionalPtr>& o, const Ice::Current&)
 {
-    o = new OneOptional(53);
+    o = ICE_MAKE_SHARED(OneOptional, 53);
 }
 
 GPtr
-InitialI::opG(const GPtr& g, const Ice::Current&)
+InitialI::opG(ICE_IN(GPtr) g, const Ice::Current&)
 {
     return g;
 }
diff --git a/cpp/test/Ice/optional/TestI.h b/cpp/test/Ice/optional/TestI.h
index d2a42cb5acd..2b050b5878e 100644
--- a/cpp/test/Ice/optional/TestI.h
+++ b/cpp/test/Ice/optional/TestI.h
@@ -12,185 +12,209 @@
 
 #include <Test.h>
 
+#ifdef ICE_CPP11_MAPPING
+namespace Test
+{
+using OneOptionalPrxPtr = std::shared_ptr<Ice::ObjectPrx>;
+}
+#endif
 
-class InitialI : public Test::Initial
+
+class InitialI : 
+#ifdef ICE_CPP11_MAPPING
+    public Test::InitialDisp
+#else
+    public Test::Initial
+#endif
 {
 public:
 
-    InitialI();
+   InitialI();
 
     virtual void shutdown(const Ice::Current&);
-    virtual Ice::ObjectPtr pingPong(const Ice::ObjectPtr&, const Ice::Current&);
+    virtual Ice::ValuePtr pingPong(ICE_IN(Ice::ValuePtr), const Ice::Current&);
 
-    virtual void opOptionalException(const IceUtil::Optional< ::Ice::Int>&,
-                                     const IceUtil::Optional< ::std::string>&,
-                                     const IceUtil::Optional<Test::OneOptionalPtr>&,
+    virtual void opOptionalException(ICE_IN(IceUtil::Optional< ::Ice::Int>),
+                                     ICE_IN(IceUtil::Optional< ::std::string>),
+                                     ICE_IN(IceUtil::Optional<Test::OneOptionalPtr>),
                                      const Ice::Current&);
 
-    virtual void opDerivedException(const IceUtil::Optional< ::Ice::Int>&,
-                                    const IceUtil::Optional< ::std::string>&,
-                                    const IceUtil::Optional<Test::OneOptionalPtr>&,
+    virtual void opDerivedException(ICE_IN(IceUtil::Optional< ::Ice::Int>),
+                                    ICE_IN(IceUtil::Optional< ::std::string>),
+                                    ICE_IN(IceUtil::Optional<Test::OneOptionalPtr>),
                                     const Ice::Current&);
 
-    virtual void opRequiredException(const IceUtil::Optional< ::Ice::Int>&,
-                                     const IceUtil::Optional< ::std::string>&,
-                                     const IceUtil::Optional<Test::OneOptionalPtr>&,
+    virtual void opRequiredException(ICE_IN(IceUtil::Optional< ::Ice::Int>),
+                                     ICE_IN(IceUtil::Optional< ::std::string>),
+                                     ICE_IN(IceUtil::Optional<Test::OneOptionalPtr>),
                                      const Ice::Current&);
 
-    virtual IceUtil::Optional< ::Ice::Byte> opByte(const IceUtil::Optional< ::Ice::Byte>&,
+    virtual IceUtil::Optional< ::Ice::Byte> opByte(ICE_IN(IceUtil::Optional< ::Ice::Byte>),
                                                    IceUtil::Optional< ::Ice::Byte>&,
                                                    const ::Ice::Current&);
 
-    virtual IceUtil::Optional< bool> opBool(const IceUtil::Optional< bool>&, IceUtil::Optional< bool>&,
-                                            const ::Ice::Current&);
+    virtual IceUtil::Optional<bool> opBool(ICE_IN(IceUtil::Optional<bool>), IceUtil::Optional<bool>&,
+                                           const ::Ice::Current&);
 
-    virtual IceUtil::Optional< ::Ice::Short> opShort(const IceUtil::Optional< ::Ice::Short>&,
+    virtual IceUtil::Optional< ::Ice::Short> opShort(ICE_IN(IceUtil::Optional< ::Ice::Short>),
                                                      IceUtil::Optional< ::Ice::Short>&,
                                                      const ::Ice::Current&);
 
-    virtual IceUtil::Optional< ::Ice::Int> opInt(const IceUtil::Optional< ::Ice::Int>&,
+    virtual IceUtil::Optional< ::Ice::Int> opInt(ICE_IN(IceUtil::Optional< ::Ice::Int>),
                                                  IceUtil::Optional< ::Ice::Int>&,
                                                  const ::Ice::Current&);
 
-    virtual IceUtil::Optional< ::Ice::Long> opLong(const IceUtil::Optional< ::Ice::Long>&,
+    virtual IceUtil::Optional< ::Ice::Long> opLong(ICE_IN(IceUtil::Optional< ::Ice::Long>),
                                                    IceUtil::Optional< ::Ice::Long>&,
                                                    const ::Ice::Current&);
 
-    virtual IceUtil::Optional< ::Ice::Float> opFloat(const IceUtil::Optional< ::Ice::Float>&,
+    virtual IceUtil::Optional< ::Ice::Float> opFloat(ICE_IN(IceUtil::Optional< ::Ice::Float>),
                                                      IceUtil::Optional< ::Ice::Float>&,
                                                      const ::Ice::Current&);
 
-    virtual IceUtil::Optional< ::Ice::Double> opDouble(const IceUtil::Optional< ::Ice::Double>&,
+    virtual IceUtil::Optional< ::Ice::Double> opDouble(ICE_IN(IceUtil::Optional< ::Ice::Double>),
                                                        IceUtil::Optional< ::Ice::Double>&,
                                                        const ::Ice::Current&);
 
-    virtual IceUtil::Optional< ::std::string> opString(const IceUtil::Optional< ::std::string>&,
+    virtual IceUtil::Optional< ::std::string> opString(ICE_IN(IceUtil::Optional< ::std::string>),
                                                        IceUtil::Optional< ::std::string>&,
                                                        const ::Ice::Current&);
 
-    virtual IceUtil::Optional< ::std::string> opCustomString(const IceUtil::Optional< Util::string_view>&,
+    virtual IceUtil::Optional< ::std::string> opCustomString(ICE_IN(IceUtil::Optional< Util::string_view>),
                                                                IceUtil::Optional< ::std::string>&,
                                                                const ::Ice::Current&);
 
-    virtual IceUtil::Optional< Test::MyEnum> opMyEnum(const IceUtil::Optional<Test::MyEnum>&,
+    virtual IceUtil::Optional< Test::MyEnum> opMyEnum(ICE_IN(IceUtil::Optional<Test::MyEnum>),
                                                       IceUtil::Optional<Test::MyEnum>&,
                                                       const ::Ice::Current&);
 
-    virtual IceUtil::Optional<Test::SmallStruct> opSmallStruct(const IceUtil::Optional<Test::SmallStruct>&,
+    virtual IceUtil::Optional<Test::SmallStruct> opSmallStruct(ICE_IN(IceUtil::Optional<Test::SmallStruct>),
                                                                IceUtil::Optional<Test::SmallStruct>&,
                                                                const ::Ice::Current&);
 
-    virtual IceUtil::Optional<Test::FixedStruct> opFixedStruct(const IceUtil::Optional<Test::FixedStruct>&,
+    virtual IceUtil::Optional<Test::FixedStruct> opFixedStruct(ICE_IN(IceUtil::Optional<Test::FixedStruct>),
                                                                IceUtil::Optional<Test::FixedStruct>&,
                                                                const ::Ice::Current&);
 
-    virtual IceUtil::Optional<Test::VarStruct> opVarStruct(const IceUtil::Optional<Test::VarStruct>&,
+    virtual IceUtil::Optional<Test::VarStruct> opVarStruct(ICE_IN(IceUtil::Optional<Test::VarStruct>),
                                                            IceUtil::Optional<Test::VarStruct>&,
                                                            const ::Ice::Current&);
 
-    virtual IceUtil::Optional<Test::OneOptionalPtr> opOneOptional(const IceUtil::Optional< Test::OneOptionalPtr>&,
+    virtual IceUtil::Optional<Test::OneOptionalPtr> opOneOptional(ICE_IN(IceUtil::Optional< Test::OneOptionalPtr>),
                                                                   IceUtil::Optional< Test::OneOptionalPtr>&,
                                                                   const ::Ice::Current&);
 
-    virtual IceUtil::Optional<Test::OneOptionalPrx> opOneOptionalProxy(const IceUtil::Optional< Test::OneOptionalPrx>&,
-                                                                       IceUtil::Optional< Test::OneOptionalPrx>&,
-                                                                       const ::Ice::Current&);
+    virtual IceUtil::Optional<Test::OneOptionalPrxPtr> opOneOptionalProxy(ICE_IN(IceUtil::Optional< Test::OneOptionalPrxPtr>),
+                                                                          IceUtil::Optional< Test::OneOptionalPrxPtr>&,
+                                                                          const ::Ice::Current&);
 
     virtual IceUtil::Optional< ::Test::ByteSeq> opByteSeq(
-        const IceUtil::Optional< ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*> >&,
+        ICE_IN(IceUtil::Optional< ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*> >),
         IceUtil::Optional< ::Test::ByteSeq>&,
         const ::Ice::Current& = ::Ice::noExplicitCurrent);
 
     virtual IceUtil::Optional< ::Test::BoolSeq> opBoolSeq(
-        const IceUtil::Optional< ::std::pair<const bool*, const bool*> >&,
+        ICE_IN(IceUtil::Optional< ::std::pair<const bool*, const bool*> >),
         IceUtil::Optional< ::Test::BoolSeq>&,
         const ::Ice::Current& = ::Ice::noExplicitCurrent);
 
     virtual IceUtil::Optional< ::Test::ShortSeq> opShortSeq(
-        const IceUtil::Optional< ::std::pair<const ::Ice::Short*, const ::Ice::Short*> >&,
+        ICE_IN(IceUtil::Optional< ::std::pair<const ::Ice::Short*, const ::Ice::Short*> >),
         IceUtil::Optional< ::Test::ShortSeq>&,
         const ::Ice::Current& = ::Ice::noExplicitCurrent);
 
     virtual IceUtil::Optional< ::Test::IntSeq> opIntSeq(
-        const IceUtil::Optional< ::std::pair<const ::Ice::Int*, const ::Ice::Int*> >&,
+        ICE_IN(IceUtil::Optional< ::std::pair<const ::Ice::Int*, const ::Ice::Int*> >),
         IceUtil::Optional< ::Test::IntSeq>&,
         const ::Ice::Current& = ::Ice::noExplicitCurrent);
 
     virtual IceUtil::Optional< ::Test::LongSeq> opLongSeq(
-        const IceUtil::Optional< ::std::pair<const ::Ice::Long*, const ::Ice::Long*> >&,
+        ICE_IN(IceUtil::Optional< ::std::pair<const ::Ice::Long*, const ::Ice::Long*> >),
         IceUtil::Optional< ::Test::LongSeq>&,
         const ::Ice::Current& = ::Ice::noExplicitCurrent);
 
     virtual IceUtil::Optional< ::Test::FloatSeq> opFloatSeq(
-        const IceUtil::Optional< ::std::pair<const ::Ice::Float*, const ::Ice::Float*> >&,
+        ICE_IN(IceUtil::Optional< ::std::pair<const ::Ice::Float*, const ::Ice::Float*> >),
         IceUtil::Optional< ::Test::FloatSeq>&,
         const ::Ice::Current& = ::Ice::noExplicitCurrent);
 
     virtual IceUtil::Optional< ::Test::DoubleSeq> opDoubleSeq(
-        const IceUtil::Optional< ::std::pair<const ::Ice::Double*, const ::Ice::Double*> >&,
+        ICE_IN(IceUtil::Optional< ::std::pair<const ::Ice::Double*, const ::Ice::Double*> >),
         IceUtil::Optional< ::Test::DoubleSeq>&,
         const ::Ice::Current& = ::Ice::noExplicitCurrent);
 
+#ifdef ICE_CPP11_MAPPING
+     virtual Ice::optional<::Test::StringSeq> opStringSeq(
+         Ice::optional<::Test::StringSeq>, 
+         Ice::optional<::Test::StringSeq>&, const ::Ice::Current& = ::Ice::noExplicitCurrent) ;
+#else
     virtual IceUtil::Optional< ::Test::StringSeq> opStringSeq(
         const IceUtil::Optional< ::std::pair< ::Test::StringSeq::const_iterator,
                                               ::Test::StringSeq::const_iterator> >&,
         IceUtil::Optional< ::Test::StringSeq>&,
         const ::Ice::Current& = ::Ice::noExplicitCurrent);
+#endif
 
     virtual IceUtil::Optional< ::Test::SmallStructSeq> opSmallStructSeq(
-        const IceUtil::Optional< ::std::pair<const ::Test::SmallStruct*, const ::Test::SmallStruct*> >&,
+        ICE_IN(IceUtil::Optional< ::std::pair<const ::Test::SmallStruct*, const ::Test::SmallStruct*> >),
         IceUtil::Optional< ::Test::SmallStructSeq>&, const ::Ice::Current& = ::Ice::noExplicitCurrent);
 
     virtual IceUtil::Optional< ::Test::SmallStructList> opSmallStructList(
-        const IceUtil::Optional< ::std::pair<const ::Test::SmallStruct*, const ::Test::SmallStruct*> >&,
+        ICE_IN(IceUtil::Optional< ::std::pair<const ::Test::SmallStruct*, const ::Test::SmallStruct*> >),
         IceUtil::Optional< ::Test::SmallStructList>&, const ::Ice::Current& = ::Ice::noExplicitCurrent);
 
     virtual IceUtil::Optional< ::Test::FixedStructSeq> opFixedStructSeq(
-        const IceUtil::Optional< ::std::pair<const ::Test::FixedStruct*, const ::Test::FixedStruct*> >&,
+        ICE_IN(IceUtil::Optional< ::std::pair<const ::Test::FixedStruct*, const ::Test::FixedStruct*> >),
         IceUtil::Optional< ::Test::FixedStructSeq>&, const ::Ice::Current& = ::Ice::noExplicitCurrent);
 
     virtual IceUtil::Optional< ::Test::FixedStructList> opFixedStructList(
-        const IceUtil::Optional< ::std::pair<const ::Test::FixedStruct*, const ::Test::FixedStruct*> >&,
+        ICE_IN(IceUtil::Optional< ::std::pair<const ::Test::FixedStruct*, const ::Test::FixedStruct*> >),
         IceUtil::Optional< ::Test::FixedStructList>&, const ::Ice::Current& = ::Ice::noExplicitCurrent);
 
+#ifdef ICE_CPP11_MAPPING
+    virtual Ice::optional<::Test::VarStructSeq> opVarStructSeq(
+        Ice::optional<::Test::VarStructSeq>, Ice::optional<::Test::VarStructSeq>&, 
+        const ::Ice::Current& = ::Ice::noExplicitCurrent);
+#else
     virtual IceUtil::Optional< ::Test::VarStructSeq> opVarStructSeq(
         const IceUtil::Optional< ::std::pair< ::Test::VarStructSeq::const_iterator,
                                               ::Test::VarStructSeq::const_iterator> >&,
         IceUtil::Optional< ::Test::VarStructSeq>&,
         const ::Ice::Current& = ::Ice::noExplicitCurrent);
+#endif
 
     virtual IceUtil::Optional< ::Test::Serializable> opSerializable(
-        const IceUtil::Optional< ::Test::Serializable>&,
+        ICE_IN(IceUtil::Optional< ::Test::Serializable>),
         IceUtil::Optional< ::Test::Serializable>&,
         const ::Ice::Current& = ::Ice::noExplicitCurrent);
 
     virtual IceUtil::Optional< ::Test::IntIntDict> opIntIntDict(
-        const IceUtil::Optional< ::Test::IntIntDict>&,
+        ICE_IN(IceUtil::Optional< ::Test::IntIntDict>),
         IceUtil::Optional< ::Test::IntIntDict>&,
         const ::Ice::Current& = ::Ice::noExplicitCurrent);
 
     virtual IceUtil::Optional< ::Test::StringIntDict> opStringIntDict(
-        const IceUtil::Optional< ::Test::StringIntDict>&,
+        ICE_IN(IceUtil::Optional< ::Test::StringIntDict>),
         IceUtil::Optional< ::Test::StringIntDict>&,
         const ::Ice::Current& = ::Ice::noExplicitCurrent);
 
     virtual IceUtil::Optional< ::Test::IntOneOptionalDict> opIntOneOptionalDict(
-        const IceUtil::Optional< ::Test::IntOneOptionalDict>&,
+        ICE_IN(IceUtil::Optional< ::Test::IntOneOptionalDict>),
         IceUtil::Optional< ::Test::IntOneOptionalDict>&,
         const ::Ice::Current& = ::Ice::noExplicitCurrent);
 
     virtual IceUtil::Optional< ::Test::IntStringDict> opCustomIntStringDict(
-        const IceUtil::Optional<std::map<int, Util::string_view> >&,
+        ICE_IN(IceUtil::Optional<std::map<int, Util::string_view> >),
         IceUtil::Optional< ::Test::IntStringDict>&,
         const ::Ice::Current& = ::Ice::noExplicitCurrent);
 
-    virtual void opClassAndUnknownOptional(const Test::APtr&, const Ice::Current&);
+    virtual void opClassAndUnknownOptional(ICE_IN(Test::APtr), const Ice::Current&);
 
-    virtual void sendOptionalClass(bool, const IceUtil::Optional<Test::OneOptionalPtr>&, const Ice::Current&);
+    virtual void sendOptionalClass(bool, ICE_IN(IceUtil::Optional<Test::OneOptionalPtr>), const Ice::Current&);
 
     virtual void returnOptionalClass(bool, IceUtil::Optional<Test::OneOptionalPtr>&, const Ice::Current&);
 
-    virtual ::Test::GPtr opG(const ::Test::GPtr& g, const Ice::Current&);
+    virtual ::Test::GPtr opG(ICE_IN(::Test::GPtr) g, const Ice::Current&);
 
     virtual void opVoid(const Ice::Current&);
 
diff --git a/cpp/test/Ice/optional/msbuild/client/client.vcxproj b/cpp/test/Ice/optional/msbuild/client/client.vcxproj
index 0b0d72d31d2..85f4f806cb7 100644
--- a/cpp/test/Ice/optional/msbuild/client/client.vcxproj
+++ b/cpp/test/Ice/optional/msbuild/client/client.vcxproj
@@ -121,6 +121,7 @@
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Cpp11-Debug|Win32'">
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <DisableSpecificWarnings>4250;4251;4275;4503</DisableSpecificWarnings>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
@@ -131,6 +132,7 @@
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Cpp11-Release|Win32'">
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <DisableSpecificWarnings>4250;4251;4275;4503</DisableSpecificWarnings>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
@@ -141,6 +143,7 @@
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Cpp11-Debug|x64'">
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <DisableSpecificWarnings>4250;4251;4275;4503</DisableSpecificWarnings>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
@@ -151,6 +154,7 @@
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Cpp11-Release|x64'">
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <DisableSpecificWarnings>4250;4251;4275;4503</DisableSpecificWarnings>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemGroup>
diff --git a/cpp/test/Ice/optional/msbuild/server/server.vcxproj b/cpp/test/Ice/optional/msbuild/server/server.vcxproj
index 79b92740c72..95941e4f5fc 100644
--- a/cpp/test/Ice/optional/msbuild/server/server.vcxproj
+++ b/cpp/test/Ice/optional/msbuild/server/server.vcxproj
@@ -120,6 +120,7 @@
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Cpp11-Debug|Win32'">
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <DisableSpecificWarnings>4250;4251;4275;4503</DisableSpecificWarnings>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
@@ -130,6 +131,7 @@
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Cpp11-Release|Win32'">
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <DisableSpecificWarnings>4250;4251;4275;4503</DisableSpecificWarnings>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
@@ -140,6 +142,7 @@
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Cpp11-Debug|x64'">
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <DisableSpecificWarnings>4250;4251;4275;4503</DisableSpecificWarnings>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
@@ -150,6 +153,7 @@
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Cpp11-Release|x64'">
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <DisableSpecificWarnings>4250;4251;4275;4503</DisableSpecificWarnings>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemGroup>
diff --git a/cpp/test/Ice/optional/msbuild/serveramd/serveramd.vcxproj b/cpp/test/Ice/optional/msbuild/serveramd/serveramd.vcxproj
index 9e49d81330b..29eb65cf263 100644
--- a/cpp/test/Ice/optional/msbuild/serveramd/serveramd.vcxproj
+++ b/cpp/test/Ice/optional/msbuild/serveramd/serveramd.vcxproj
@@ -122,6 +122,7 @@
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>ICE_AMD_TEST;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <DisableSpecificWarnings>4250;4251;4275;4503</DisableSpecificWarnings>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
@@ -134,6 +135,7 @@
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>ICE_AMD_TEST;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <DisableSpecificWarnings>4250;4251;4275;4503</DisableSpecificWarnings>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
@@ -146,6 +148,7 @@
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>ICE_AMD_TEST;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <DisableSpecificWarnings>4250;4251;4275;4503</DisableSpecificWarnings>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
@@ -158,6 +161,7 @@
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>ICE_AMD_TEST;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <DisableSpecificWarnings>4250;4251;4275;4503</DisableSpecificWarnings>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemGroup>