Disable rvalue references

[Bug]           Boost any rvalue support is optional
[Cause]         rvalues is provided in 1.54 and can be disabled
[Solution]      Disable rvalue references
[Verification]  N/A

Change-Id: I395adec94bbd07e33aa8bf703c0732ffa3b69ea6

diff --git a/src/config/fields-union.hpp b/src/config/fields-union.hpp
index 57e54a0..53620ca 100644 (file)
--- a/src/config/fields-union.hpp
+++ b/src/config/fields-union.hpp
@@ -79,15 +79,27 @@
  *     // Config is not set
  *     Foo foo({"some string"});
  *     config.set(foo);
- *     config.set(std::move(foo));
+ *     config.set(std::move(foo));         //< copy sic!
  *     config.set(Foo({"some string"}));
  *   }
  */
 
+class DisbaleMoveAnyWrapper : public boost::any
+{
+    public:
+        DisbaleMoveAnyWrapper() {}
+        DisbaleMoveAnyWrapper(const DisbaleMoveAnyWrapper& any)
+            : boost::any(static_cast<const boost::any&>(any)) {};
+        DisbaleMoveAnyWrapper& operator=(DisbaleMoveAnyWrapper&& any) = delete;
+        DisbaleMoveAnyWrapper& operator=(const DisbaleMoveAnyWrapper& any) {
+            static_cast<boost::any&>(*this) = static_cast<const boost::any&>(any);
+            return *this;
+        }
+};
 
 #define CONFIG_DECLARE_UNION(...)                                                               \
 private:                                                                                        \
-    boost::any mConfigDeclareField__;                                                           \
+    DisbaleMoveAnyWrapper mConfigDeclareField;                                                  \
                                                                                                 \
     template<typename Visitor>                                                                  \
     void visitOption(Visitor& v, const std::string& name) {                                     \
@@ -101,6 +113,12 @@ private:
         GENERATE_CODE(GENERATE_UNION_NAME__, __VA_ARGS__)                                       \
         return std::string();                                                                   \
     }                                                                                           \
+    boost::any& getHolder() {                                                                   \
+        return static_cast<boost::any&>(mConfigDeclareField);                                   \
+    }                                                                                           \
+    const boost::any& getHolder() const {                                                       \
+        return static_cast<const boost::any&>(mConfigDeclareField);                             \
+    }                                                                                           \
 public:                                                                                         \
                                                                                                 \
     template<typename Visitor>                                                                  \
@@ -123,24 +141,24 @@ public:
                                                                                                 \
     template<typename Type>                                                                     \
     bool is() const {                                                                           \
-        return boost::any_cast<Type>(&mConfigDeclareField__) != NULL;                           \
+        return boost::any_cast<Type>(&getHolder()) != NULL;                                     \
     }                                                                                           \
     template<typename Type>                                                                     \
-    Type& as() {                                                                                \
-        assert(!mConfigDeclareField__.empty());                                                 \
-        return boost::any_cast<Type&>(mConfigDeclareField__);                                   \
+    typename std::enable_if<!std::is_const<Type>::value, Type>::type& as() {                    \
+        assert(!getHolder().empty());                                                           \
+        return boost::any_cast<Type&>(getHolder());                                             \
     }                                                                                           \
     template<typename Type>                                                                     \
     const Type& as() const {                                                                    \
-        assert(!mConfigDeclareField__.empty());                                                 \
-        return boost::any_cast<const Type&>(mConfigDeclareField__);                             \
+        assert(!getHolder().empty());                                                           \
+        return boost::any_cast<const Type&>(getHolder());                                       \
     }                                                                                           \
     bool isSet() {                                                                              \
         return !getOptionName().empty();                                                        \
     }                                                                                           \
     template<typename Type>                                                                     \
-    Type& set(Type&& src) {                                                                     \
-        mConfigDeclareField__ = std::forward<Type>(src);                                        \
+    Type& set(const Type& src) {                                                                \
+        getHolder() = std::forward<const Type>(src);                                            \
         return as<Type>();                                                                      \
     }                                                                                           \
 
@@ -154,7 +172,7 @@ public:
 
 #define GENERATE_UNION_VISIT_CONST__(r, _, TYPE_)                                               \
     if (#TYPE_ == name) {                                                                       \
-        v.visit("value", as<TYPE_>());                                                          \
+        v.visit("value", as<const TYPE_>());                                                    \
     }
 
 #define GENERATE_UNION_NAME__(r, _, TYPE_)                                                      \