Copy boost optional to Paddle (#34780)

* copy boost optional.hpp to paddle

* copy boost optional.hpp to paddle

* move directions

* del fluid/utils

* modify .hpp to .h

* move directions

* modify to paddle::optional

* add modification description

* format code stype for the files in paddle/utils

* format code stype

paddle/fluid/framework/details/build_strategy.cc

@@ -36,8 +36,8 @@ static inline bool SeqOnlyAllReduceOps(const BuildStrategy &strategy) {
          !strategy.enable_parallel_graph_;
 }
 
-static inline void ConvertDefaultValue(boost::optional<bool> *default_value) {
-  if (*default_value == boost::none) {
+static inline void ConvertDefaultValue(paddle::optional<bool> *default_value) {
+  if (*default_value == paddle::none) {
     *default_value = true;
   }
 }
@@ -247,7 +247,7 @@ class ParallelExecutorPassBuilder : public ir::PassBuilder {
     }
   }
 
-  void AppendPassWithCheck(const boost::optional<bool> &append_pass,
+  void AppendPassWithCheck(const paddle::optional<bool> &append_pass,
                            const std::string &pass_name) {
     AppendPassWithCheck(append_pass == true, pass_name);
   }

paddle/fluid/framework/details/build_strategy.h

@@ -112,8 +112,8 @@ struct BuildStrategy {
   bool enable_auto_fusion_{false};
   // Fuse_all_optimizer_ops and fuse_all_reduce_ops require that gradients
   // should not be sparse types
-  boost::optional<bool> fuse_all_optimizer_ops_{false};
-  boost::optional<bool> fuse_all_reduce_ops_{boost::none};
+  paddle::optional<bool> fuse_all_optimizer_ops_{false};
+  paddle::optional<bool> fuse_all_reduce_ops_{boost::none};
   // fuse_relu_depthwise_conv can fuse the `relu ->
   // depthwise_conv`
   bool fuse_relu_depthwise_conv_{false};
@@ -121,7 +121,7 @@ struct BuildStrategy {
   // faster. Because fusing broadcast OP equals delaying the execution of all
   // broadcast Ops, in this case, all nccl streams are used only for reduce
   // operations for a period of time.
-  boost::optional<bool> fuse_broadcast_ops_{boost::none};
+  paddle::optional<bool> fuse_broadcast_ops_{boost::none};
   // replace batch_norm with sync_batch_norm.
   bool sync_batch_norm_{false};
 
@@ -135,7 +135,7 @@ struct BuildStrategy {
   // By default, memory_optimize would be opened if gc is disabled, and
   // be closed if gc is enabled.
   // Users can forcely enable/disable memory_optimize by setting True/False.
-  boost::optional<bool> memory_optimize_{boost::none};
+  paddle::optional<bool> memory_optimize_{boost::none};
 
   // Turn on inplace by default.
   bool enable_inplace_{true};

paddle/fluid/framework/ir/mkldnn/conv_elementwise_add_mkldnn_fuse_pass.cc

@@ -74,11 +74,11 @@ bool IsReachable(ir::Graph* graph, Node* from, Node* to) {
 }
 
 template <typename T>
-boost::optional<T> HasAttribute(const Node& op, const std::string& attr) {
+paddle::optional<T> HasAttribute(const Node& op, const std::string& attr) {
   if (op.Op()->HasAttr(attr))
     return BOOST_GET_CONST(T, op.Op()->GetAttr(attr));
   else
-    return boost::none;
+    return paddle::none;
 }
 
 ResidualConnectionMKLDNNFusePass::ResidualConnectionMKLDNNFusePass() {

paddle/fluid/framework/ir/mkldnn/conv_elementwise_add_mkldnn_fuse_pass.h

@@ -40,7 +40,7 @@ using GraphWithStats = std::pair<ir::Graph*, int>;
 
 void CorrectGraphEdges(Graph* graph, Node* from, Node* to);
 bool IsReachable(ir::Graph* graph, Node* from, Node* to);
-boost::optional<Node*> HasBias(const Node& op, const std::string& bias_name);
+paddle::optional<Node*> HasBias(const Node& op, const std::string& bias_name);
 
 class ResidualConnectionMKLDNNFusePass : public FusePassBase {
  private:

paddle/fluid/framework/mixed_vector.h

@@ -27,6 +27,8 @@ limitations under the License. */
 #include "paddle/fluid/framework/tensor_util.h"
 #include "paddle/fluid/memory/malloc.h"
 #include "paddle/fluid/memory/memcpy.h"
+#include "paddle/utils/none.h"
+#include "paddle/utils/optional.h"
 
 namespace paddle {
 namespace framework {
@@ -195,10 +197,10 @@ class Vector {
 
     std::mutex &Mutex() const { return mtx_; }
 
-    boost::optional<platform::CUDAPlace> CUDAPlace() const {
+    paddle::optional<platform::CUDAPlace> CUDAPlace() const {
       return gpu_ == nullptr
-                 ? boost::none
-                 : boost::optional<platform::CUDAPlace>(
+                 ? paddle::none
+                 : paddle::optional<platform::CUDAPlace>(
                        BOOST_GET_CONST(platform::CUDAPlace, gpu_->place()));
     }
 
@@ -389,7 +391,7 @@ class Vector {
       auto &mtx = m_.Data().Mutex();
       std::lock_guard<std::mutex> guard(mtx);
       auto cuda_place = m_.Data().CUDAPlace();
-      if (cuda_place == boost::none ||
+      if (cuda_place == paddle::none ||
           cuda_place == BOOST_GET(platform::CUDAPlace, place)) {
         return m_.Data().CUDAData(place);
       }
@@ -405,7 +407,7 @@ class Vector {
       auto &mtx = m_.Data().Mutex();
       std::lock_guard<std::mutex> guard(mtx);
       auto cuda_place = m_.Data().CUDAPlace();
-      if (cuda_place == boost::none ||
+      if (cuda_place == paddle::none ||
           cuda_place == BOOST_GET(platform::CUDAPlace, place)) {
         return m_.MutableData()->CUDAMutableData(place);
       }

paddle/fluid/framework/op_version_registry.h

@@ -22,6 +22,7 @@ limitations under the License. */
 
 #include "paddle/fluid/framework/op_version_proto.h"
 #include "paddle/fluid/platform/enforce.h"
+#include "paddle/utils/none.h"
 
 namespace paddle {
 namespace framework {
@@ -42,7 +43,7 @@ using OpAttrVariantT =
                    std::vector<int32_t>,     /* AttrType::INTS */
                    std::vector<int64_t>,     /* AttrType::LONGS */
                    std::vector<std::string>, /* AttrType::STRINGS */
-                   boost::none_t             /* None */
+                   paddle::none_t            /* None */
                    >;
 
 struct OpUpdateInfo {
@@ -51,7 +52,7 @@ struct OpUpdateInfo {
 
 struct OpAttrInfo : OpUpdateInfo {
   OpAttrInfo(const std::string& name, const std::string& remark,
-             const OpAttrVariantT& default_value = boost::none)
+             const OpAttrVariantT& default_value = paddle::none)
       : name_{name}, default_value_{default_value}, remark_{remark} {}
 
   const std::string& name() const { return name_; }

paddle/fluid/operators/flip_op.cc

@@ -161,5 +161,5 @@ REGISTER_OP_VERSION(flip)
         R"ROC(Upgrade flip, add new attr [axis] and delete attr [dims].)ROC",
         paddle::framework::compatible::OpVersionDesc()
             .NewAttr("axis", "The added attr 'axis' doesn't set default value.",
-                     boost::none)
+                     paddle::none)
             .DeleteAttr("dims", "The attr 'dims' is deleted."));

paddle/fluid/operators/mkldnn/concat_mkldnn_op.cc

@@ -137,7 +137,7 @@ class ConcatPrimitiveFactory {
  private:
   std::vector<memory::desc> srcs_d;
   std::vector<mkldnn::memory> srcs;
-  boost::optional<mkldnn::memory> dst_mem;
+  paddle::optional<mkldnn::memory> dst_mem;
 };
 
 template <typename T>

paddle/fluid/operators/mkldnn/conv_mkldnn_op.cc

@@ -893,7 +893,7 @@ class ConvMKLDNNOpKernel : public paddle::framework::OpKernel<T> {
             fuse_residual_conn, propagation, output_shift_scale, sum_scale);
       } else {
         conv_pd = handler->AcquireConvolutionPrimitiveDescriptor(
-            src_md, weights_md, boost::none, dst_md, strides, dilations,
+            src_md, weights_md, paddle::none, dst_md, strides, dilations,
             paddings, mkldnn_engine, fuse_activation, fuse_alpha, fuse_beta,
             fuse_residual_conn, propagation, output_shift_scale, sum_scale);
       }

paddle/fluid/operators/mkldnn/fc_mkldnn_op.cc

@@ -89,7 +89,8 @@ class FCPrimitiveFactory {
     // descriptor has been divided into separate cases, based on the number
     // of input dimensions.
     size_t input_dim_num = input->dims().size();
-    boost::optional<mkldnn::inner_product_forward::primitive_desc> fc_prim_desc;
+    paddle::optional<mkldnn::inner_product_forward::primitive_desc>
+        fc_prim_desc;
     memory::desc usr_weights_desc = {};
     switch (input_dim_num) {
       case 2:
@@ -545,11 +546,11 @@ class FCPrimitiveFactory {
 
  private:
   const mkldnn::engine& engine_;
-  boost::optional<memory> input_;
-  boost::optional<memory> output_;
+  paddle::optional<memory> input_;
+  paddle::optional<memory> output_;
   std::shared_ptr<memory> bias_;
   std::shared_ptr<memory> weights_;
-  boost::optional<inner_product_forward> fc_;
+  paddle::optional<inner_product_forward> fc_;
 };
 
 // Attempt to fetch cached primitive factory based on provided parameters

paddle/fluid/operators/mkldnn/mul_mkldnn_op.cc

@@ -290,10 +290,10 @@ class MulPrimitiveFactory {
   }
 
   const mkldnn::engine &engine_;
-  boost::optional<memory> x_input_;
-  boost::optional<memory> y_input_;
-  boost::optional<memory> output_;
-  boost::optional<inner_product_forward> mul_;
+  paddle::optional<memory> x_input_;
+  paddle::optional<memory> y_input_;
+  paddle::optional<memory> output_;
+  paddle::optional<inner_product_forward> mul_;
   static constexpr bool is_int8_ =
       std::is_same<XT, int8_t>::value || std::is_same<XT, uint8_t>::value;
 };

paddle/fluid/operators/sequence_ops/sequence_concat_op.h

@@ -123,7 +123,7 @@ class SeqConcatGradKernel : public framework::OpKernel<T> {
     }
 
     std::vector<framework::Tensor> sliced_x;
-    std::vector<boost::optional<framework::Tensor>> sliced_dx;
+    std::vector<paddle::optional<framework::Tensor>> sliced_dx;
 
     for (size_t i = 1; i < xs[0]->lod()[0].size(); ++i) {
       for (size_t j = 0; j < xs.size(); ++j) {
@@ -145,7 +145,7 @@ class SeqConcatGradKernel : public framework::OpKernel<T> {
         if (dx) {
           sliced_dx.emplace_back(dx->Slice(prev_lod, next_lod));
         } else {
-          sliced_dx.emplace_back(boost::none);
+          sliced_dx.emplace_back(paddle::none);
         }
       }
     }

paddle/fluid/platform/mkldnn_reuse.h

@@ -1426,7 +1426,7 @@ class ConvMKLDNNTemplateHandler : public MKLDNNHandler {
   std::shared_ptr<typename forward_t::primitive_desc>
   AcquireConvolutionPrimitiveDescriptor(
       const mkldnn::memory::desc& src, const mkldnn::memory::desc& weights,
-      boost::optional<const mkldnn::memory::desc&> bias,
+      paddle::optional<const mkldnn::memory::desc&> bias,
       const mkldnn::memory::desc& dst, const std::vector<int64_t>& strides,
       const std::vector<int64_t>& dilations,
       const std::vector<int64_t>& paddings, const mkldnn::engine& engine,

paddle/fluid/pybind/pybind.cc

@@ -73,6 +73,7 @@ limitations under the License. */
 #include "paddle/fluid/platform/profiler.h"
 #include "paddle/fluid/pybind/cuda_streams_py.h"
 #include "paddle/fluid/pybind/io.h"
+#include "paddle/utils/none.h"
 #ifdef PADDLE_WITH_ASCEND
 #include "paddle/fluid/pybind/ascend_wrapper_py.h"
 #endif
@@ -2910,7 +2911,7 @@ All parameter, weight, gradient are variables in Paddle.
       .def_property("fuse_broadcast_ops",
                     [](const BuildStrategy &self) {
                       return self.fuse_broadcast_ops_ == true ||
-                             self.fuse_broadcast_ops_ == boost::none;
+                             self.fuse_broadcast_ops_ == paddle::none;
                     },
                     [](BuildStrategy &self, bool b) {
                       PADDLE_ENFORCE_NE(self.IsFinalized(), true,
@@ -2940,7 +2941,7 @@ All parameter, weight, gradient are variables in Paddle.
       .def_property("fuse_all_optimizer_ops",
                     [](const BuildStrategy &self) {
                       return self.fuse_all_optimizer_ops_ == true ||
-                             self.fuse_all_optimizer_ops_ == boost::none;
+                             self.fuse_all_optimizer_ops_ == paddle::none;
                     },
                     [](BuildStrategy &self, bool b) {
                       PADDLE_ENFORCE_NE(self.IsFinalized(), true,
@@ -2989,7 +2990,7 @@ All parameter, weight, gradient are variables in Paddle.
           [](BuildStrategy &self, const py::handle &value) {
             auto *py_obj = value.ptr();
             if (py_obj == nullptr || py_obj == Py_None) {
-              self.memory_optimize_ = boost::none;
+              self.memory_optimize_ = paddle::none;
             } else if (PyBool_Check(py_obj)) {
               self.memory_optimize_ = (py_obj == Py_True);
             } else {
@@ -3046,7 +3047,7 @@ All parameter, weight, gradient are variables in Paddle.
           "fuse_all_reduce_ops",
           [](const BuildStrategy &self) {
             return self.fuse_all_reduce_ops_ == true ||
-                   self.fuse_all_reduce_ops_ == boost::none;
+                   self.fuse_all_reduce_ops_ == paddle::none;
           },
           [](BuildStrategy &self, bool b) { self.fuse_all_reduce_ops_ = b; })
       .def_property("enable_backward_optimizer_op_deps",

paddle/fluid/pybind/reader_py.cc

@@ -44,7 +44,7 @@ namespace reader = operators::reader;
 
 // Check whether the tensor shape matches the VarDesc shape
 // Return the different shape if exists
-static boost::optional<std::vector<int64_t>> DiffTensorShapeWithVarDesc(
+static paddle::optional<std::vector<int64_t>> DiffTensorShapeWithVarDesc(
     const framework::LoDTensor &tensor, const framework::VarDesc &var_desc,
     size_t num_places) {
   auto tensor_shape = tensor.dims();
@@ -56,7 +56,7 @@ static boost::optional<std::vector<int64_t>> DiffTensorShapeWithVarDesc(
     if (desc_shape.size() != 0) {  // Tensor rank = 0 but desc does not match
       return framework::vectorize<int64_t>(tensor_shape);
     } else {
-      return boost::none;
+      return paddle::none;
     }
   }
 
@@ -92,7 +92,7 @@ static boost::optional<std::vector<int64_t>> DiffTensorShapeWithVarDesc(
     }
   }
 
-  return boost::none;
+  return paddle::none;
 }
 
 static const std::shared_ptr<reader::LoDTensorBlockingQueue> &GetQueue(

paddle/utils/any.h

-//This file copy from boost/any.hpp and boost version: 1.41.0
-//Modified the following points:
-//1. modify namespace from boost::any to paddle::any
-//2. remove the depending boost header files
-//3. remove/modify some macro
+// This file copy from boost/any.hpp and boost version: 1.41.0
+// Modified the following points:
+// 1. modify namespace from boost::any to paddle::any
+// 2. remove the depending boost header files
+// 3. remove/modify some macro
 
 // See http://www.boost.org/libs/any for Documentation.
 
@@ -17,210 +17,157 @@
 // where: tested with BCC 5.5, MSVC 6.0, and g++ 2.95
 
 #include <algorithm>
-#include <typeinfo>
 #include <type_traits>
+#include <typeinfo>
 
 // See boost/python/type_id.hpp
 // TODO: add BOOST_TYPEID_COMPARE_BY_NAME to config.hpp
-# if (defined(__GNUC__) && __GNUC__ >= 3) \
- || defined(_AIX) \
- || (   defined(__sgi) && defined(__host_mips)) \
- || (defined(__hpux) && defined(__HP_aCC)) \
- || (defined(linux) && defined(__INTEL_COMPILER) && defined(__ICC))
-#  define BOOST_AUX_ANY_TYPE_ID_NAME
+#if (defined(__GNUC__) && __GNUC__ >= 3) || defined(_AIX) || \
+    (defined(__sgi) && defined(__host_mips)) ||              \
+    (defined(__hpux) && defined(__HP_aCC)) ||                \
+    (defined(linux) && defined(__INTEL_COMPILER) && defined(__ICC))
+#define BOOST_AUX_ANY_TYPE_ID_NAME
 #include <cstring>
-# endif 
-
-namespace paddle
-{
-    class any
-    {
-    public: // structors
-
-        any()
-          : content(0)
-        {
-        }
+#endif
 
-        template<typename ValueType>
-        any(const ValueType & value)
-          : content(new holder<ValueType>(value))
-        {
-        }
+namespace paddle {
+class any {
+ public:  // structors
+  any() : content(0) {}
 
-        any(const any & other)
-          : content(other.content ? other.content->clone() : 0)
-        {
-        }
+  template <typename ValueType>
+  any(const ValueType &value) : content(new holder<ValueType>(value)) {}
 
-        ~any()
-        {
-            delete content;
-        }
+  any(const any &other) : content(other.content ? other.content->clone() : 0) {}
 
-    public: // modifiers
+  ~any() { delete content; }
 
-        any & swap(any & rhs)
-        {
-            std::swap(content, rhs.content);
-            return *this;
-        }
+ public:  // modifiers
+  any &swap(any &rhs) {
+    std::swap(content, rhs.content);
+    return *this;
+  }
 
-        template<typename ValueType>
-        any & operator=(const ValueType & rhs)
-        {
-            any(rhs).swap(*this);
-            return *this;
-        }
+  template <typename ValueType>
+  any &operator=(const ValueType &rhs) {
+    any(rhs).swap(*this);
+    return *this;
+  }
 
-        any & operator=(any rhs)
-        {
-            rhs.swap(*this);
-            return *this;
-        }
+  any &operator=(any rhs) {
+    rhs.swap(*this);
+    return *this;
+  }
 
-    public: // queries
+ public:  // queries
+  bool empty() const { return !content; }
 
-        bool empty() const
-        {
-            return !content;
-        }
+  const std::type_info &type() const {
+    return content ? content->type() : typeid(void);
+  }
 
-        const std::type_info & type() const
-        {
-            return content ? content->type() : typeid(void);
-        }
+ public:  // types (public so any_cast can be non-friend)
+  class placeholder {
+   public:  // structors
+    virtual ~placeholder() {}
 
-    public: // types (public so any_cast can be non-friend)
+   public:  // queries
+    virtual const std::type_info &type() const = 0;
 
-        class placeholder
-        {
-        public: // structors
+    virtual placeholder *clone() const = 0;
+  };
 
-            virtual ~placeholder()
-            {
-            }
+  template <typename ValueType>
+  class holder : public placeholder {
+   public:  // structors
+    holder(const ValueType &value) : held(value) {}
 
-        public: // queries
+   public:  // queries
+    virtual const std::type_info &type() const { return typeid(ValueType); }
 
-            virtual const std::type_info & type() const = 0;
+    virtual placeholder *clone() const { return new holder(held); }
 
-            virtual placeholder * clone() const = 0;
+   public:  // representation
+    ValueType held;
 
-        };
+   private:  // intentionally left unimplemented
+    holder &operator=(const holder &);
+  };
 
-        template<typename ValueType>
-        class holder : public placeholder
-        {
-        public: // structors
+ public:  // representation (public so any_cast can be non-friend)
+  placeholder *content;
+};
 
-            holder(const ValueType & value)
-              : held(value)
-            {
-            }
+class bad_any_cast : public std::bad_cast {
+ public:
+  virtual const char *what() const throw() {
+    return "paddle::bad_any_cast: "
+           "failed conversion using paddle::any_cast";
+  }
+};
 
-        public: // queries
+template <typename ValueType>
+ValueType *any_cast(any *operand) {
+  return operand &&
+#ifdef BOOST_AUX_ANY_TYPE_ID_NAME
+                 std::strcmp(operand->type().name(),
+                             typeid(ValueType).name()) == 0
+#else
+                 operand->type() == typeid(ValueType)
+#endif
+             ? &static_cast<any::holder<ValueType> *>(operand->content)->held
+             : 0;
+}
 
-            virtual const std::type_info & type() const
-            {
-                return typeid(ValueType);
-            }
+template <typename ValueType>
+inline const ValueType *any_cast(const any *operand) {
+  return any_cast<ValueType>(const_cast<any *>(operand));
+}
 
-            virtual placeholder * clone() const
-            {
-                return new holder(held);
-            }
+template <typename ValueType>
+ValueType any_cast(any &operand) {
+  typedef typename std::remove_reference<ValueType>::type nonref;
 
-        public: // representation
+  // If 'nonref' is still reference type, it means the user has not
+  // specialized 'remove_reference'.
 
-            ValueType held;
+  // Please use BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION macro
+  // to generate specialization of remove_reference for your class
+  // See type traits library documentation for details
+  static_assert(!std::is_reference<nonref>::value,
+                "!std::is_reference<nonref>::value");
 
-        private: // intentionally left unimplemented
-            holder & operator=(const holder &);
-        };
+  nonref *result = any_cast<nonref>(&operand);
+  if (!result) throw bad_any_cast();
+  return *result;
+}
 
-    public: // representation (public so any_cast can be non-friend)
+template <typename ValueType>
+inline ValueType any_cast(const any &operand) {
+  typedef typename std::remove_reference<ValueType>::type nonref;
 
-        placeholder * content;
+  // The comment in the above version of 'any_cast' explains when this
+  // assert is fired and what to do.
+  static_assert(!std::is_reference<nonref>::value,
+                "!std::is_reference<nonref>::value");
 
-    };
+  return any_cast<const nonref &>(const_cast<any &>(operand));
+}
 
-    class bad_any_cast : public std::bad_cast
-    {
-    public:
-        virtual const char * what() const throw()
-        {
-            return "paddle::bad_any_cast: "
-                   "failed conversion using paddle::any_cast";
-        }
-    };
+// Note: The "unsafe" versions of any_cast are not part of the
+// public interface and may be removed at any time. They are
+// required where we know what type is stored in the any and can't
+// use typeid() comparison, e.g., when our types may travel across
+// different shared libraries.
+template <typename ValueType>
+inline ValueType *unsafe_any_cast(any *operand) {
+  return &static_cast<any::holder<ValueType> *>(operand->content)->held;
+}
 
-    template<typename ValueType>
-    ValueType * any_cast(any * operand)
-    {
-        return operand && 
-#ifdef BOOST_AUX_ANY_TYPE_ID_NAME
-            std::strcmp(operand->type().name(), typeid(ValueType).name()) == 0
-#else
-            operand->type() == typeid(ValueType)
-#endif
-            ? &static_cast<any::holder<ValueType> *>(operand->content)->held
-            : 0;
-    }
-
-    template<typename ValueType>
-    inline const ValueType * any_cast(const any * operand)
-    {
-        return any_cast<ValueType>(const_cast<any *>(operand));
-    }
-
-    template<typename ValueType>
-    ValueType any_cast(any & operand)
-    {
-        typedef typename std::remove_reference<ValueType>::type nonref;
-
-        // If 'nonref' is still reference type, it means the user has not
-        // specialized 'remove_reference'.
-
-        // Please use BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION macro
-        // to generate specialization of remove_reference for your class
-        // See type traits library documentation for details
-        static_assert(!std::is_reference<nonref>::value, "!std::is_reference<nonref>::value");
-
-        nonref * result = any_cast<nonref>(&operand);
-        if(!result)
-            throw bad_any_cast();
-        return *result;
-    }
-
-    template<typename ValueType>
-    inline ValueType any_cast(const any & operand)
-    {
-        typedef typename std::remove_reference<ValueType>::type nonref;
-
-        // The comment in the above version of 'any_cast' explains when this
-        // assert is fired and what to do.
-        static_assert(!std::is_reference<nonref>::value, "!std::is_reference<nonref>::value");
-
-        return any_cast<const nonref &>(const_cast<any &>(operand));
-    }
-
-    // Note: The "unsafe" versions of any_cast are not part of the
-    // public interface and may be removed at any time. They are
-    // required where we know what type is stored in the any and can't
-    // use typeid() comparison, e.g., when our types may travel across
-    // different shared libraries.
-    template<typename ValueType>
-    inline ValueType * unsafe_any_cast(any * operand)
-    {
-        return &static_cast<any::holder<ValueType> *>(operand->content)->held;
-    }
-
-    template<typename ValueType>
-    inline const ValueType * unsafe_any_cast(const any * operand)
-    {
-        return unsafe_any_cast<ValueType>(const_cast<any *>(operand));
-    }
+template <typename ValueType>
+inline const ValueType *unsafe_any_cast(const any *operand) {
+  return unsafe_any_cast<ValueType>(const_cast<any *>(operand));
+}
 }
 
 // Copyright Kevlin Henney, 2000, 2001, 2002. All rights reserved.

paddle/utils/none.h

+// This file copy from boost/none_t.hpp and boost/none.hpp and boost version:
+// 1.41.0
+// Modified the following points:
+// 1. modify namespace from boost::none to paddle::none
+// 2. modify namespace from boost::none_t to paddle::none_t
+
+// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
+//
+// Distributed under 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)
+//
+// See http://www.boost.org/libs/optional for documentation.
+//
+// You are welcome to contact the author at:
+//  fernando_cacciola@hotmail.com
+//
+#ifndef PADDLE_NONE_17SEP2003_HPP
+#define PADDLE_NONE_17SEP2003_HPP
+
+namespace paddle {
+
+namespace detail {
+struct none_helper {};
+}
+
+typedef int detail::none_helper::*none_t;
+
+}  // namespace boost
+
+// NOTE: Borland users have to include this header outside any precompiled
+// headers
+// (bcc<=5.64 cannot include instance data in a precompiled header)
+//  -- * To be verified, now that there's no unnamed namespace
+
+namespace paddle {
+
+none_t const none = ((none_t)0);
+
+}  // namespace boost
+
+#endif

paddle/utils/optional.h

+// This file copy from boost/optional/optional.hpp and boost version: 1.41.0
+// Modified the following points:
+// 1. modify namespace from boost::optional to paddle::optional
+// 2. remove the depending boost header files
+// 3. remove/modify some macro
+// 4. copy some necessary data structures which are the depended by optional
+// 5. replace type_with_alignment with std::aligned_storage
+
+// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
+//
+// 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)
+//
+// See http://www.boost.org/lib/optional for documentation.
+//
+// You are welcome to contact the author at:
+//  fernando_cacciola@hotmail.com
+//
+#ifndef PADDLE_OPTIONAL_OPTIONAL_FLC_19NOV2002_HPP
+#define PADDLE_OPTIONAL_OPTIONAL_FLC_19NOV2002_HPP
+
+#include <algorithm>
+#include <functional>
+#include <new>
+#include <type_traits>
+
+#include "none.h"
+
+// Daniel Wallin discovered that bind/apply.hpp badly interacts with the apply<>
+// member template of a factory as used in the optional<> implementation.
+// He proposed this simple fix which is to move the call to apply<> outside
+// namespace boost.
+namespace paddle_optional_detail {
+template <class T, class Factory>
+void construct(Factory const& factory, void* address) {
+  factory.template apply<T>(address);
+}
+}
+
+namespace paddle {
+template <typename T>
+class optional;
+
+class in_place_factory_base {};
+class typed_in_place_factory_base {};
+
+// template<class OP> bool equal_pointees(OP const& x, OP const& y);
+// template<class OP> struct equal_pointees_t;
+//
+// Being OP a model of OptionalPointee (either a pointer or an optional):
+//
+// If both x and y have valid pointees, returns the result of (*x == *y)
+// If only one has a valid pointee, returns false.
+// If none have valid pointees, returns true.
+// No-throw
+template <class OptionalPointee>
+inline bool equal_pointees(OptionalPointee const& x, OptionalPointee const& y) {
+  return (!x) != (!y) ? false : (!x ? true : (*x) == (*y));
+}
+
+template <class OptionalPointee>
+struct equal_pointees_t
+    : std::binary_function<OptionalPointee, OptionalPointee, bool> {
+  bool operator()(OptionalPointee const& x, OptionalPointee const& y) const {
+    return equal_pointees(x, y);
+  }
+};
+
+// template<class OP> bool less_pointees(OP const& x, OP const& y);
+// template<class OP> struct less_pointees_t;
+//
+// Being OP a model of OptionalPointee (either a pointer or an optional):
+//
+// If y has not a valid pointee, returns false.
+// ElseIf x has not a valid pointee, returns true.
+// ElseIf both x and y have valid pointees, returns the result of (*x < *y)
+// No-throw
+template <class OptionalPointee>
+inline bool less_pointees(OptionalPointee const& x, OptionalPointee const& y) {
+  return !y ? false : (!x ? true : (*x) < (*y));
+}
+
+template <class OptionalPointee>
+struct less_pointees_t
+    : std::binary_function<OptionalPointee, OptionalPointee, bool> {
+  bool operator()(OptionalPointee const& x, OptionalPointee const& y) const {
+    return less_pointees(x, y);
+  }
+};
+
+namespace detail {
+
+template <typename RefT>
+class reference_content {
+ private:  // representation
+  RefT content_;
+
+ public:  // structors
+  ~reference_content() {}
+
+  reference_content(RefT r) : content_(r) {}
+
+  reference_content(const reference_content& operand)
+      : content_(operand.content_) {}
+
+ private:  // non-Assignable
+  reference_content& operator=(const reference_content&);
+
+ public:  // queries
+  RefT get() const { return content_; }
+};
+
+template <typename T>
+struct make_reference_content {
+  typedef T type;
+};
+
+template <typename T>
+struct make_reference_content<T&> {
+  typedef reference_content<T&> type;
+};
+
+}  // namespace detail
+
+namespace optional_detail {
+
+// This local class is used instead of that in "aligned_storage.hpp"
+// because I've found the 'official' class to ICE BCB5.5
+// when some types are used with optional<>
+// (due to sizeof() passed down as a non-type template parameter)
+template <class T>
+class aligned_storage {
+  // Borland ICEs if unnamed unions are used for this!
+  union dummy_u {
+    char data[sizeof(T)];
+    typename std::aligned_storage<::std::alignment_of<T>::value>::type aligner_;
+  } dummy_;
+
+ public:
+  void const* address() const { return &dummy_.data[0]; }
+  void* address() { return &dummy_.data[0]; }
+};
+
+template <class T>
+struct types_when_isnt_ref {
+  typedef T const& reference_const_type;
+  typedef T& reference_type;
+  typedef T const* pointer_const_type;
+  typedef T* pointer_type;
+  typedef T const& argument_type;
+};
+template <class T>
+struct types_when_is_ref {
+  typedef typename std::remove_reference<T>::type raw_type;
+
+  typedef raw_type& reference_const_type;
+  typedef raw_type& reference_type;
+  typedef raw_type* pointer_const_type;
+  typedef raw_type* pointer_type;
+  typedef raw_type& argument_type;
+};
+
+struct optional_tag {};
+
+template <class T>
+class optional_base : public optional_tag {
+ private:
+  typedef
+      typename ::paddle::detail::make_reference_content<T>::type internal_type;
+
+  typedef aligned_storage<internal_type> storage_type;
+
+  typedef types_when_isnt_ref<T> types_when_not_ref;
+  typedef types_when_is_ref<T> types_when_ref;
+
+  typedef optional_base<T> this_type;
+
+ protected:
+  typedef T value_type;
+
+  typedef std::true_type is_reference_tag;
+  typedef std::false_type is_not_reference_tag;
+
+  typedef typename std::is_reference<T>::type is_reference_predicate;
+
+  typedef typename std::conditional<is_reference_predicate::value,
+                                    types_when_ref,
+                                    types_when_not_ref>::type types;
+
+  typedef bool (this_type::*unspecified_bool_type)() const;
+
+  typedef typename types::reference_type reference_type;
+  typedef typename types::reference_const_type reference_const_type;
+  typedef typename types::pointer_type pointer_type;
+  typedef typename types::pointer_const_type pointer_const_type;
+  typedef typename types::argument_type argument_type;
+
+  // Creates an optional<T> uninitialized.
+  // No-throw
+  optional_base() : m_initialized(false) {}
+
+  // Creates an optional<T> uninitialized.
+  // No-throw
+  optional_base(none_t) : m_initialized(false) {}
+
+  // Creates an optional<T> initialized with 'val'.
+  // Can throw if T::T(T const&) does
+  optional_base(argument_type val) : m_initialized(false) { construct(val); }
+
+  // Creates an optional<T> initialized with 'val' IFF cond is true, otherwise
+  // creates an uninitialzed optional<T>.
+  // Can throw if T::T(T const&) does
+  optional_base(bool cond, argument_type val) : m_initialized(false) {
+    if (cond) construct(val);
+  }
+
+  // Creates a deep copy of another optional<T>
+  // Can throw if T::T(T const&) does
+  optional_base(optional_base const& rhs) : m_initialized(false) {
+    if (rhs.is_initialized()) construct(rhs.get_impl());
+  }
+
+  // This is used for both converting and in-place constructions.
+  // Derived classes use the 'tag' to select the appropriate
+  // implementation (the correct 'construct()' overload)
+  template <class Expr>
+  explicit optional_base(Expr const& expr, Expr const* tag)
+      : m_initialized(false) {
+    construct(expr, tag);
+  }
+
+  // No-throw (assuming T::~T() doesn't)
+  ~optional_base() { destroy(); }
+
+  // Assigns from another optional<T> (deep-copies the rhs value)
+  void assign(optional_base const& rhs) {
+    if (is_initialized()) {
+      if (rhs.is_initialized())
+        assign_value(rhs.get_impl(), is_reference_predicate());
+      else
+        destroy();
+    } else {
+      if (rhs.is_initialized()) construct(rhs.get_impl());
+    }
+  }
+
+  // Assigns from another _convertible_ optional<U> (deep-copies the rhs value)
+  template <class U>
+  void assign(optional<U> const& rhs) {
+    if (is_initialized()) {
+      if (rhs.is_initialized())
+        assign_value(static_cast<value_type>(rhs.get()),
+                     is_reference_predicate());
+      else
+        destroy();
+    } else {
+      if (rhs.is_initialized()) construct(static_cast<value_type>(rhs.get()));
+    }
+  }
+
+  // Assigns from a T (deep-copies the rhs value)
+  void assign(argument_type val) {
+    if (is_initialized())
+      assign_value(val, is_reference_predicate());
+    else
+      construct(val);
+  }
+
+  // Assigns from "none", destroying the current value, if any, leaving this
+  // UNINITIALIZED
+  // No-throw (assuming T::~T() doesn't)
+  void assign(none_t) { destroy(); }
+
+  template <class Expr>
+  void assign_expr(Expr const& expr, Expr const* tag) {
+    if (is_initialized())
+      assign_expr_to_initialized(expr, tag);
+    else
+      construct(expr, tag);
+  }
+
+ public:
+  // Destroys the current value, if any, leaving this UNINITIALIZED
+  // No-throw (assuming T::~T() doesn't)
+  void reset() { destroy(); }
+
+  // Replaces the current value -if any- with 'val'
+  void reset(argument_type val) { assign(val); }
+
+  // Returns a pointer to the value if this is initialized, otherwise,
+  // returns NULL.
+  // No-throw
+  pointer_const_type get_ptr() const {
+    return m_initialized ? get_ptr_impl() : 0;
+  }
+  pointer_type get_ptr() { return m_initialized ? get_ptr_impl() : 0; }
+
+  bool is_initialized() const { return m_initialized; }
+
+ protected:
+  void construct(argument_type val) {
+    new (m_storage.address()) internal_type(val);
+    m_initialized = true;
+  }
+
+  // Constructs in-place using the given factory
+  template <class Expr>
+  void construct(Expr const& factory, in_place_factory_base const*) {
+    static_assert(!is_reference_predicate::value,
+                  "!is_reference_predicate::value");
+    paddle_optional_detail::construct<value_type>(factory, m_storage.address());
+    m_initialized = true;
+  }
+
+  // Constructs in-place using the given typed factory
+  template <class Expr>
+  void construct(Expr const& factory, typed_in_place_factory_base const*) {
+    static_assert(!is_reference_predicate::value,
+                  "!is_reference_predicate::value");
+    factory.apply(m_storage.address());
+    m_initialized = true;
+  }
+
+  template <class Expr>
+  void assign_expr_to_initialized(Expr const& factory,
+                                  in_place_factory_base const* tag) {
+    destroy();
+    construct(factory, tag);
+  }
+
+  // Constructs in-place using the given typed factory
+  template <class Expr>
+  void assign_expr_to_initialized(Expr const& factory,
+                                  typed_in_place_factory_base const* tag) {
+    destroy();
+    construct(factory, tag);
+  }
+
+  // Constructs using any expression implicitely convertible to the single
+  // argument
+  // of a one-argument T constructor.
+  // Converting constructions of optional<T> from optional<U> uses this function
+  // with
+  // 'Expr' being of type 'U' and relying on a converting constructor of T from
+  // U.
+  template <class Expr>
+  void construct(Expr const& expr, void const*) {
+    new (m_storage.address()) internal_type(expr);
+    m_initialized = true;
+  }
+
+  // Assigns using a form any expression implicitely convertible to the single
+  // argument
+  // of a T's assignment operator.
+  // Converting assignments of optional<T> from optional<U> uses this function
+  // with
+  // 'Expr' being of type 'U' and relying on a converting assignment of T from
+  // U.
+  template <class Expr>
+  void assign_expr_to_initialized(Expr const& expr, void const*) {
+    assign_value(expr, is_reference_predicate());
+  }
+
+  void assign_value(argument_type val, is_not_reference_tag) {
+    get_impl() = val;
+  }
+  void assign_value(argument_type val, is_reference_tag) { construct(val); }
+
+  void destroy() {
+    if (m_initialized) destroy_impl(is_reference_predicate());
+  }
+
+  unspecified_bool_type safe_bool() const {
+    return m_initialized ? &this_type::is_initialized : 0;
+  }
+
+  reference_const_type get_impl() const {
+    return dereference(get_object(), is_reference_predicate());
+  }
+  reference_type get_impl() {
+    return dereference(get_object(), is_reference_predicate());
+  }
+
+  pointer_const_type get_ptr_impl() const {
+    return cast_ptr(get_object(), is_reference_predicate());
+  }
+  pointer_type get_ptr_impl() {
+    return cast_ptr(get_object(), is_reference_predicate());
+  }
+
+ private:
+  // internal_type can be either T or reference_content<T>
+  internal_type const* get_object() const {
+    return static_cast<internal_type const*>(m_storage.address());
+  }
+  internal_type* get_object() {
+    return static_cast<internal_type*>(m_storage.address());
+  }
+
+  // reference_content<T> lacks an implicit conversion to T&, so the following
+  // is needed to obtain a proper reference.
+  reference_const_type dereference(internal_type const* p,
+                                   is_not_reference_tag) const {
+    return *p;
+  }
+  reference_type dereference(internal_type* p, is_not_reference_tag) {
+    return *p;
+  }
+  reference_const_type dereference(internal_type const* p,
+                                   is_reference_tag) const {
+    return p->get();
+  }
+  reference_type dereference(internal_type* p, is_reference_tag) {
+    return p->get();
+  }
+
+  void destroy_impl(is_not_reference_tag) {
+    get_ptr_impl()->T::~T();
+    m_initialized = false;
+  }
+
+  void destroy_impl(is_reference_tag) { m_initialized = false; }
+
+  // If T is of reference type, trying to get a pointer to the held value must
+  // result in a compile-time error.
+  // Decent compilers should disallow conversions from reference_content<T>* to
+  // T*, but just in case,
+  // the following olverloads are used to filter out the case and guarantee an
+  // error in case of T being a reference.
+  pointer_const_type cast_ptr(internal_type const* p,
+                              is_not_reference_tag) const {
+    return p;
+  }
+  pointer_type cast_ptr(internal_type* p, is_not_reference_tag) { return p; }
+  pointer_const_type cast_ptr(internal_type const* p, is_reference_tag) const {
+    return &p->get();
+  }
+  pointer_type cast_ptr(internal_type* p, is_reference_tag) {
+    return &p->get();
+  }
+
+  bool m_initialized;
+  storage_type m_storage;
+};
+
+}  // namespace optional_detail
+
+template <class T>
+class optional : public optional_detail::optional_base<T> {
+  typedef optional_detail::optional_base<T> base;
+
+  typedef typename base::unspecified_bool_type unspecified_bool_type;
+
+ public:
+  typedef optional<T> this_type;
+
+  typedef typename base::value_type value_type;
+  typedef typename base::reference_type reference_type;
+  typedef typename base::reference_const_type reference_const_type;
+  typedef typename base::pointer_type pointer_type;
+  typedef typename base::pointer_const_type pointer_const_type;
+  typedef typename base::argument_type argument_type;
+
+  // Creates an optional<T> uninitialized.
+  // No-throw
+  optional() : base() {}
+
+  // Creates an optional<T> uninitialized.
+  // No-throw
+  optional(none_t none_) : base(none_) {}
+
+  // Creates an optional<T> initialized with 'val'.
+  // Can throw if T::T(T const&) does
+  optional(argument_type val) : base(val) {}
+
+  // Creates an optional<T> initialized with 'val' IFF cond is true, otherwise
+  // creates an uninitialized optional.
+  // Can throw if T::T(T const&) does
+  optional(bool cond, argument_type val) : base(cond, val) {}
+
+  // Creates a deep copy of another convertible optional<U>
+  // Requires a valid conversion from U to T.
+  // Can throw if T::T(U const&) does
+  template <class U>
+  explicit optional(optional<U> const& rhs) : base() {
+    if (rhs.is_initialized()) this->construct(rhs.get());
+  }
+
+  // Creates an optional<T> with an expression which can be either
+  //  (a) An instance of InPlaceFactory (i.e. in_place(a,b,...,n);
+  //  (b) An instance of TypedInPlaceFactory ( i.e. in_place<T>(a,b,...,n);
+  //  (c) Any expression implicitely convertible to the single type
+  //      of a one-argument T's constructor.
+  //  (d*) Weak compilers (BCB) might also resolved Expr as optional<T> and
+  //  optional<U>
+  //       even though explicit overloads are present for these.
+  // Depending on the above some T ctor is called.
+  // Can throw is the resolved T ctor throws.
+  template <class Expr>
+  explicit optional(Expr const& expr) : base(expr, &expr) {}
+
+  // Creates a deep copy of another optional<T>
+  // Can throw if T::T(T const&) does
+  optional(optional const& rhs) : base(rhs) {}
+
+  // No-throw (assuming T::~T() doesn't)
+  ~optional() {}
+
+  // Assigns from an expression. See corresponding constructor.
+  // Basic Guarantee: If the resolved T ctor throws, this is left UNINITIALIZED
+  template <class Expr>
+  optional& operator=(Expr expr) {
+    this->assign_expr(expr, &expr);
+    return *this;
+  }
+
+  // Assigns from another convertible optional<U> (converts && deep-copies the
+  // rhs value)
+  // Requires a valid conversion from U to T.
+  // Basic Guarantee: If T::T( U const& ) throws, this is left UNINITIALIZED
+  template <class U>
+  optional& operator=(optional<U> const& rhs) {
+    this->assign(rhs);
+    return *this;
+  }
+
+  // Assigns from another optional<T> (deep-copies the rhs value)
+  // Basic Guarantee: If T::T( T const& ) throws, this is left UNINITIALIZED
+  //  (NOTE: On BCB, this operator is not actually called and left is left
+  //  UNMODIFIED in case of a throw)
+  optional& operator=(optional const& rhs) {
+    this->assign(rhs);
+    return *this;
+  }
+
+  // Assigns from a T (deep-copies the rhs value)
+  // Basic Guarantee: If T::( T const& ) throws, this is left UNINITIALIZED
+  optional& operator=(argument_type val) {
+    this->assign(val);
+    return *this;
+  }
+
+  // Assigns from a "none"
+  // Which destroys the current value, if any, leaving this UNINITIALIZED
+  // No-throw (assuming T::~T() doesn't)
+  optional& operator=(none_t none_) {
+    this->assign(none_);
+    return *this;
+  }
+
+  // Returns a reference to the value if this is initialized, otherwise,
+  // the behaviour is UNDEFINED
+  // No-throw
+  reference_const_type get() const {
+    assert(this->is_initialized());
+    return this->get_impl();
+  }
+  reference_type get() {
+    assert(this->is_initialized());
+    return this->get_impl();
+  }
+
+  // Returns a copy of the value if this is initialized, 'v' otherwise
+  reference_const_type get_value_or(reference_const_type v) const {
+    return this->is_initialized() ? get() : v;
+  }
+  reference_type get_value_or(reference_type v) {
+    return this->is_initialized() ? get() : v;
+  }
+
+  // Returns a pointer to the value if this is initialized, otherwise,
+  // the behaviour is UNDEFINED
+  // No-throw
+  pointer_const_type operator->() const {
+    assert(this->is_initialized());
+    return this->get_ptr_impl();
+  }
+  pointer_type operator->() {
+    assert(this->is_initialized());
+    return this->get_ptr_impl();
+  }
+
+  // Returns a reference to the value if this is initialized, otherwise,
+  // the behaviour is UNDEFINED
+  // No-throw
+  reference_const_type operator*() const { return this->get(); }
+  reference_type operator*() { return this->get(); }
+
+  // implicit conversion to "bool"
+  // No-throw
+  operator unspecified_bool_type() const { return this->safe_bool(); }
+
+  // This is provided for those compilers which don't like the conversion to
+  // bool
+  // on some contexts.
+  bool operator!() const { return !this->is_initialized(); }
+};
+
+// Returns optional<T>(v)
+template <class T>
+inline optional<T> make_optional(T const& v) {
+  return optional<T>(v);
+}
+
+// Returns optional<T>(cond,v)
+template <class T>
+inline optional<T> make_optional(bool cond, T const& v) {
+  return optional<T>(cond, v);
+}
+
+// Returns a reference to the value if this is initialized, otherwise, the
+// behaviour is UNDEFINED.
+// No-throw
+template <class T>
+inline typename optional<T>::reference_const_type get(optional<T> const& opt) {
+  return opt.get();
+}
+
+template <class T>
+inline typename optional<T>::reference_type get(optional<T>& opt) {
+  return opt.get();
+}
+
+// Returns a pointer to the value if this is initialized, otherwise, returns
+// NULL.
+// No-throw
+template <class T>
+inline typename optional<T>::pointer_const_type get(optional<T> const* opt) {
+  return opt->get_ptr();
+}
+
+template <class T>
+inline typename optional<T>::pointer_type get(optional<T>* opt) {
+  return opt->get_ptr();
+}
+
+// Returns a reference to the value if this is initialized, otherwise, the
+// behaviour is UNDEFINED.
+// No-throw
+template <class T>
+inline typename optional<T>::reference_const_type get_optional_value_or(
+    optional<T> const& opt, typename optional<T>::reference_const_type v) {
+  return opt.get_value_or(v);
+}
+
+template <class T>
+inline typename optional<T>::reference_type get_optional_value_or(
+    optional<T>& opt, typename optional<T>::reference_type v) {
+  return opt.get_value_or(v);
+}
+
+// Returns a pointer to the value if this is initialized, otherwise, returns
+// NULL.
+// No-throw
+template <class T>
+inline typename optional<T>::pointer_const_type get_pointer(
+    optional<T> const& opt) {
+  return opt.get_ptr();
+}
+
+template <class T>
+inline typename optional<T>::pointer_type get_pointer(optional<T>& opt) {
+  return opt.get_ptr();
+}
+
+// optional's relational operators ( ==, !=, <, >, <=, >= ) have deep-semantics
+// (compare values).
+// WARNING: This is UNLIKE pointers. Use equal_pointees()/less_pointess() in
+// generic code instead.
+
+//
+// optional<T> vs optional<T> cases
+//
+
+template <class T>
+inline bool operator==(optional<T> const& x, optional<T> const& y) {
+  return equal_pointees(x, y);
+}
+
+template <class T>
+inline bool operator<(optional<T> const& x, optional<T> const& y) {
+  return less_pointees(x, y);
+}
+
+template <class T>
+inline bool operator!=(optional<T> const& x, optional<T> const& y) {
+  return !(x == y);
+}
+
+template <class T>
+inline bool operator>(optional<T> const& x, optional<T> const& y) {
+  return y < x;
+}
+
+template <class T>
+inline bool operator<=(optional<T> const& x, optional<T> const& y) {
+  return !(y < x);
+}
+
+template <class T>
+inline bool operator>=(optional<T> const& x, optional<T> const& y) {
+  return !(x < y);
+}
+
+//
+// optional<T> vs T cases
+//
+template <class T>
+inline bool operator==(optional<T> const& x, T const& y) {
+  return equal_pointees(x, optional<T>(y));
+}
+
+template <class T>
+inline bool operator<(optional<T> const& x, T const& y) {
+  return less_pointees(x, optional<T>(y));
+}
+
+template <class T>
+inline bool operator!=(optional<T> const& x, T const& y) {
+  return !(x == y);
+}
+
+template <class T>
+inline bool operator>(optional<T> const& x, T const& y) {
+  return y < x;
+}
+
+template <class T>
+inline bool operator<=(optional<T> const& x, T const& y) {
+  return !(y < x);
+}
+
+template <class T>
+inline bool operator>=(optional<T> const& x, T const& y) {
+  return !(x < y);
+}
+
+//
+// T vs optional<T> cases
+//
+
+template <class T>
+inline bool operator==(T const& x, optional<T> const& y) {
+  return equal_pointees(optional<T>(x), y);
+}
+
+template <class T>
+inline bool operator<(T const& x, optional<T> const& y) {
+  return less_pointees(optional<T>(x), y);
+}
+
+template <class T>
+inline bool operator!=(T const& x, optional<T> const& y) {
+  return !(x == y);
+}
+
+template <class T>
+inline bool operator>(T const& x, optional<T> const& y) {
+  return y < x;
+}
+
+template <class T>
+inline bool operator<=(T const& x, optional<T> const& y) {
+  return !(y < x);
+}
+
+template <class T>
+inline bool operator>=(T const& x, optional<T> const& y) {
+  return !(x < y);
+}
+
+//
+// optional<T> vs none cases
+//
+
+template <class T>
+inline bool operator==(optional<T> const& x, none_t) {
+  return equal_pointees(x, optional<T>());
+}
+
+template <class T>
+inline bool operator<(optional<T> const& x, none_t) {
+  return less_pointees(x, optional<T>());
+}
+
+template <class T>
+inline bool operator!=(optional<T> const& x, none_t y) {
+  return !(x == y);
+}
+
+template <class T>
+inline bool operator>(optional<T> const& x, none_t y) {
+  return y < x;
+}
+
+template <class T>
+inline bool operator<=(optional<T> const& x, none_t y) {
+  return !(y < x);
+}
+
+template <class T>
+inline bool operator>=(optional<T> const& x, none_t y) {
+  return !(x < y);
+}
+
+//
+// none vs optional<T> cases
+//
+
+template <class T>
+inline bool operator==(none_t x, optional<T> const& y) {
+  return equal_pointees(optional<T>(), y);
+}
+
+template <class T>
+inline bool operator<(none_t x, optional<T> const& y) {
+  return less_pointees(optional<T>(), y);
+}
+
+template <class T>
+inline bool operator!=(none_t x, optional<T> const& y) {
+  return !(x == y);
+}
+
+template <class T>
+inline bool operator>(none_t x, optional<T> const& y) {
+  return y < x;
+}
+
+template <class T>
+inline bool operator<=(none_t x, optional<T> const& y) {
+  return !(y < x);
+}
+
+template <class T>
+inline bool operator>=(none_t x, optional<T> const& y) {
+  return !(x < y);
+}
+
+namespace optional_detail {
+
+// optional's swap:
+// If both are initialized, calls swap(T&, T&). If this swap throws, both will
+// remain initialized but their values are now unspecified.
+// If only one is initialized, calls U.reset(*I), THEN I.reset().
+// If U.reset(*I) throws, both are left UNCHANGED (U is kept uinitialized and I
+// is never reset)
+// If both are uninitialized, do nothing (no-throw)
+template <class T>
+inline void optional_swap(optional<T>& x, optional<T>& y) {
+  if (!x && !!y) {
+    x.reset(*y);
+    y.reset();
+  } else if (!!x && !y) {
+    y.reset(*x);
+    x.reset();
+  } else if (!!x && !!y) {
+    // allow for Koenig lookup
+    using std::swap;
+    swap(*x, *y);
+  }
+}
+
+}  // namespace optional_detail
+
+}  // namespace paddle
+
+#endif