bump variant dependency

ThirdParty/variant/optional.hpp

@@ -33,15 +33,6 @@ template <typename T> class optional
 
     optional(T const &v) { variant_ = v; }
 
-    optional &operator=(optional other)
-    { // note: argument passed by value!
-        if (this != &other)
-        {
-            swap(other);
-        }
-        return *this;
-    }
-
     explicit operator bool() const noexcept { return variant_.template is<T>(); }
 
     T const &get() const { return variant_.template get<T>(); }

ThirdParty/variant/recursive_wrapper.hpp

@@ -1,127 +1,127 @@
-#ifndef MAPBOX_UTIL_VARIANT_RECURSIVE_WRAPPER_HPP
+#ifndef MAPBOX_UTIL_VARIANT_RECURSIVE_WRAPPER_HPP
-#define MAPBOX_UTIL_VARIANT_RECURSIVE_WRAPPER_HPP
+#define MAPBOX_UTIL_VARIANT_RECURSIVE_WRAPPER_HPP
-
+
-#include <utility>
+#include <utility>
-
+
-namespace mapbox { namespace util {
+namespace mapbox { namespace util {
-
+
-template <typename T>
+template <typename T>
-class recursive_wrapper
+class recursive_wrapper
-{
+{
-public:
+public:
-    using type = T;
+    using type = T;
-private:
+private:
-
+
-    T* p_;
+    T* p_;
-
+
-public:
+public:
-
+
-    ~recursive_wrapper();
+    ~recursive_wrapper();
-    recursive_wrapper();
+    recursive_wrapper();
-
+
-    recursive_wrapper(recursive_wrapper const& operand);
+    recursive_wrapper(recursive_wrapper const& operand);
-    recursive_wrapper(T const& operand);
+    recursive_wrapper(T const& operand);
-    recursive_wrapper(recursive_wrapper&& operand);
+    recursive_wrapper(recursive_wrapper&& operand);
-    recursive_wrapper(T&& operand);
+    recursive_wrapper(T&& operand);
-
+
-private:
+private:
-
+
-    void assign(const T& rhs);
+    void assign(const T& rhs);
-
+
-public:
+public:
-
+
-    inline recursive_wrapper& operator=(recursive_wrapper const& rhs)
+    inline recursive_wrapper& operator=(recursive_wrapper const& rhs)
-    {
+    {
-        assign( rhs.get() );
+        assign( rhs.get() );
-        return *this;
+        return *this;
-    }
+    }
-
+
-    inline recursive_wrapper& operator=(T const& rhs)
+    inline recursive_wrapper& operator=(T const& rhs)
-    {
+    {
-        assign( rhs );
+        assign( rhs );
-        return *this;
+        return *this;
-    }
+    }
-
+
-    inline void swap(recursive_wrapper& operand) noexcept
+    inline void swap(recursive_wrapper& operand) noexcept
-    {
+    {
-        T* temp = operand.p_;
+        T* temp = operand.p_;
-        operand.p_ = p_;
+        operand.p_ = p_;
-        p_ = temp;
+        p_ = temp;
-    }
+    }
-
+
-
+
-    recursive_wrapper& operator=(recursive_wrapper&& rhs) noexcept
+    recursive_wrapper& operator=(recursive_wrapper&& rhs) noexcept
-    {
+    {
-        swap(rhs);
+        swap(rhs);
-        return *this;
+        return *this;
-    }
+    }
-
+
-    recursive_wrapper& operator=(T&& rhs)
+    recursive_wrapper& operator=(T&& rhs)
-    {
+    {
-        get() = std::move(rhs);
+        get() = std::move(rhs);
-        return *this;
+        return *this;
-    }
+    }
-
+
-
+
-public:
+public:
-
+
-    T& get() { return *get_pointer(); }
+    T& get() { return *get_pointer(); }
-    const T& get() const { return *get_pointer(); }
+    const T& get() const { return *get_pointer(); }
-    T* get_pointer() { return p_; }
+    T* get_pointer() { return p_; }
-    const T* get_pointer() const { return p_; }
+    const T* get_pointer() const { return p_; }
-    operator T const&() const { return this->get(); }
+    operator T const&() const { return this->get(); }
-    operator T&() { return this->get(); }
+    operator T&() { return this->get(); }
-};
+};
-
+
-template <typename T>
+template <typename T>
-recursive_wrapper<T>::~recursive_wrapper()
+recursive_wrapper<T>::~recursive_wrapper()
-{
+{
-    delete p_;
+    delete p_;
-}
+}
-
+
-template <typename T>
+template <typename T>
-recursive_wrapper<T>::recursive_wrapper()
+recursive_wrapper<T>::recursive_wrapper()
-    : p_(new T)
+    : p_(new T)
-{
+{
-}
+}
-
+
-template <typename T>
+template <typename T>
-recursive_wrapper<T>::recursive_wrapper(recursive_wrapper const& operand)
+recursive_wrapper<T>::recursive_wrapper(recursive_wrapper const& operand)
-    : p_(new T( operand.get() ))
+    : p_(new T( operand.get() ))
-{
+{
-}
+}
-
+
-template <typename T>
+template <typename T>
-recursive_wrapper<T>::recursive_wrapper(T const& operand)
+recursive_wrapper<T>::recursive_wrapper(T const& operand)
-    : p_(new T(operand))
+    : p_(new T(operand))
-{
+{
-}
+}
-
+
-template <typename T>
+template <typename T>
-recursive_wrapper<T>::recursive_wrapper(recursive_wrapper&& operand)
+recursive_wrapper<T>::recursive_wrapper(recursive_wrapper&& operand)
-    : p_(operand.p_)
+    : p_(operand.p_)
-{
+{
-    operand.p_ = nullptr;
+    operand.p_ = nullptr;
-}
+}
-
+
-template <typename T>
+template <typename T>
-recursive_wrapper<T>::recursive_wrapper(T&& operand)
+recursive_wrapper<T>::recursive_wrapper(T&& operand)
-    : p_(new T( std::move(operand) ))
+    : p_(new T( std::move(operand) ))
-{
+{
-}
+}
-
+
-template <typename T>
+template <typename T>
-void recursive_wrapper<T>::assign(const T& rhs)
+void recursive_wrapper<T>::assign(const T& rhs)
-{
+{
-    this->get() = rhs;
+    this->get() = rhs;
-}
+}
-
+
-template <typename T>
+template <typename T>
-inline void swap(recursive_wrapper<T>& lhs, recursive_wrapper<T>& rhs) noexcept
+inline void swap(recursive_wrapper<T>& lhs, recursive_wrapper<T>& rhs) noexcept
-{
+{
-    lhs.swap(rhs);
+    lhs.swap(rhs);
-}
+}
-
+
-}}
+}}
-
+
-#endif // MAPBOX_UTIL_VARIANT_RECURSIVE_WRAPPER_HPP
+#endif // MAPBOX_UTIL_VARIANT_RECURSIVE_WRAPPER_HPP