isotree 0.1.4 → 0.1.5

data/vendor/cereal/include/cereal/types/atomic.hpp

@@ -0,0 +1,55 @@
+/*! \file atomic.hpp
+    \brief Support for types found in \<atomic\>
+    \ingroup STLSupport */
+/*
+  Copyright (c) 2014, Randolph Voorhies, Shane Grant
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+      * Redistributions of source code must retain the above copyright
+        notice, this list of conditions and the following disclaimer.
+      * Redistributions in binary form must reproduce the above copyright
+        notice, this list of conditions and the following disclaimer in the
+        documentation and/or other materials provided with the distribution.
+      * Neither the name of cereal nor the
+        names of its contributors may be used to endorse or promote products
+        derived from this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef CEREAL_TYPES_ATOMIC_HPP_
+#define CEREAL_TYPES_ATOMIC_HPP_
+
+#include <cereal/cereal.hpp>
+#include <atomic>
+
+namespace cereal
+{
+  //! Serializing (save) for std::atomic
+  template <class Archive, class T> inline
+  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::atomic<T> const & a )
+  {
+    ar( CEREAL_NVP_("atomic_data", a.load()) );
+  }
+
+  //! Serializing (load) for std::atomic
+  template <class Archive, class T> inline
+  void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::atomic<T> & a )
+  {
+    T tmp;
+    ar( CEREAL_NVP_("atomic_data", tmp) );
+    a.store( tmp );
+  }
+} // namespace cereal
+
+#endif // CEREAL_TYPES_ATOMIC_HPP_

data/vendor/cereal/include/cereal/types/base_class.hpp

@@ -0,0 +1,203 @@
+/*! \file base_class.hpp
+    \brief Support for base classes (virtual and non-virtual)
+    \ingroup OtherTypes */
+/*
+  Copyright (c) 2014, Randolph Voorhies, Shane Grant
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+      * Redistributions of source code must retain the above copyright
+        notice, this list of conditions and the following disclaimer.
+      * Redistributions in binary form must reproduce the above copyright
+        notice, this list of conditions and the following disclaimer in the
+        documentation and/or other materials provided with the distribution.
+      * Neither the name of cereal nor the
+        names of its contributors may be used to endorse or promote products
+        derived from this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef CEREAL_TYPES_BASE_CLASS_HPP_
+#define CEREAL_TYPES_BASE_CLASS_HPP_
+
+#include "cereal/details/traits.hpp"
+#include "cereal/details/polymorphic_impl_fwd.hpp"
+
+namespace cereal
+{
+  namespace base_class_detail
+  {
+    //! Used to register polymorphic relations and avoid the need to include
+    //! polymorphic.hpp when no polymorphism is used
+    /*! @internal */
+    template <class Base, class Derived, bool IsPolymorphic = std::is_polymorphic<Base>::value>
+    struct RegisterPolymorphicBaseClass
+    {
+      static void bind()
+      { }
+    };
+
+    //! Polymorphic version
+    /*! @internal */
+    template <class Base, class Derived>
+    struct RegisterPolymorphicBaseClass<Base, Derived, true>
+    {
+      static void bind()
+      { detail::RegisterPolymorphicCaster<Base, Derived>::bind(); }
+    };
+  }
+
+  //! Casts a derived class to its non-virtual base class in a way that safely supports abstract classes
+  /*! This should be used in cases when a derived type needs to serialize its base type. This is better than directly
+      using static_cast, as it allows for serialization of pure virtual (abstract) base classes.
+
+      This also automatically registers polymorphic relation between the base and derived class, assuming they
+      are indeed polymorphic. Note this is not the same as polymorphic type registration. For more information
+      see the documentation on polymorphism. If using a polymorphic class, be sure to include support for
+      polymorphism (cereal/types/polymorphic.hpp).
+
+      \sa virtual_base_class
+
+      @code{.cpp}
+      struct MyBase
+      {
+        int x;
+
+        virtual void foo() = 0;
+
+        template <class Archive>
+        void serialize( Archive & ar )
+        {
+          ar( x );
+        }
+      };
+
+      struct MyDerived : public MyBase //<-- Note non-virtual inheritance
+      {
+        int y;
+
+        virtual void foo() {};
+
+        template <class Archive>
+        void serialize( Archive & ar )
+        {
+          ar( cereal::base_class<MyBase>(this) );
+          ar( y );
+        }
+      };
+      @endcode */
+  template<class Base>
+    struct base_class : private traits::detail::BaseCastBase
+    {
+      template<class Derived>
+        base_class(Derived const * derived) :
+          base_ptr(const_cast<Base*>(static_cast<Base const *>(derived)))
+      {
+        static_assert( std::is_base_of<Base, Derived>::value, "Can only use base_class on a valid base class" );
+        base_class_detail::RegisterPolymorphicBaseClass<Base, Derived>::bind();
+      }
+
+        Base * base_ptr;
+    };
+
+  //! Casts a derived class to its virtual base class in a way that allows cereal to track inheritance
+  /*! This should be used in cases when a derived type features virtual inheritance from some
+      base type.  This allows cereal to track the inheritance and to avoid making duplicate copies
+      during serialization.
+
+      It is safe to use virtual_base_class in all circumstances for serializing base classes, even in cases
+      where virtual inheritance does not take place, though it may be slightly faster to utilize
+      cereal::base_class<> if you do not need to worry about virtual inheritance.
+
+      This also automatically registers polymorphic relation between the base and derived class, assuming they
+      are indeed polymorphic. Note this is not the same as polymorphic type registration. For more information
+      see the documentation on polymorphism. If using a polymorphic class, be sure to include support for
+      polymorphism (cereal/types/polymorphic.hpp).
+
+      \sa base_class
+
+      @code{.cpp}
+      struct MyBase
+      {
+        int x;
+
+        template <class Archive>
+        void serialize( Archive & ar )
+        {
+          ar( x );
+        }
+      };
+
+      struct MyLeft : virtual MyBase //<-- Note the virtual inheritance
+      {
+        int y;
+
+        template <class Archive>
+        void serialize( Archive & ar )
+        {
+          ar( cereal::virtual_base_class<MyBase>( this ) );
+          ar( y );
+        }
+      };
+
+      struct MyRight : virtual MyBase
+      {
+        int z;
+
+        template <class Archive>
+        void serialize( Archive & ar )
+        {
+          ar( cereal::virtual_base_clas<MyBase>( this ) );
+          ar( z );
+        }
+      };
+
+      // diamond virtual inheritance; contains one copy of each base class
+      struct MyDerived : virtual MyLeft, virtual MyRight
+      {
+        int a;
+
+        template <class Archive>
+        void serialize( Archive & ar )
+        {
+          ar( cereal::virtual_base_class<MyLeft>( this ) );  // safely serialize data members in MyLeft
+          ar( cereal::virtual_base_class<MyRight>( this ) ); // safely serialize data members in MyRight
+          ar( a );
+
+          // Because we used virtual_base_class, cereal will ensure that only one instance of MyBase is
+          // serialized as we traverse the inheritance heirarchy. This means that there will be one copy
+          // each of the variables x, y, z, and a
+
+          // If we had chosen to use static_cast<> instead, cereal would perform no tracking and
+          // assume that every base class should be serialized (in this case leading to a duplicate
+          // serialization of MyBase due to diamond inheritance
+      };
+     }
+     @endcode */
+  template<class Base>
+    struct virtual_base_class : private traits::detail::BaseCastBase
+    {
+      template<class Derived>
+        virtual_base_class(Derived const * derived) :
+          base_ptr(const_cast<Base*>(static_cast<Base const *>(derived)))
+      {
+        static_assert( std::is_base_of<Base, Derived>::value, "Can only use virtual_base_class on a valid base class" );
+        base_class_detail::RegisterPolymorphicBaseClass<Base, Derived>::bind();
+      }
+
+        Base * base_ptr;
+    };
+
+} // namespace cereal
+
+#endif // CEREAL_TYPES_BASE_CLASS_HPP_

data/vendor/cereal/include/cereal/types/bitset.hpp

@@ -0,0 +1,176 @@
+/*! \file bitset.hpp
+    \brief Support for types found in \<bitset\>
+    \ingroup STLSupport */
+/*
+  Copyright (c) 2014, Randolph Voorhies, Shane Grant
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+      * Redistributions of source code must retain the above copyright
+        notice, this list of conditions and the following disclaimer.
+      * Redistributions in binary form must reproduce the above copyright
+        notice, this list of conditions and the following disclaimer in the
+        documentation and/or other materials provided with the distribution.
+      * Neither the name of cereal nor the
+        names of its contributors may be used to endorse or promote products
+        derived from this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef CEREAL_TYPES_BITSET_HPP_
+#define CEREAL_TYPES_BITSET_HPP_
+
+#include "cereal/cereal.hpp"
+#include "cereal/types/string.hpp"
+#include <bitset>
+
+namespace cereal
+{
+  namespace bitset_detail
+  {
+    //! The type the bitset is encoded with
+    /*! @internal */
+    enum class type : uint8_t
+    {
+      ulong,
+      ullong,
+      string,
+      bits
+    };
+  }
+
+  //! Serializing (save) for std::bitset when BinaryData optimization supported
+  template <class Archive, size_t N,
+            traits::EnableIf<traits::is_output_serializable<BinaryData<std::uint32_t>, Archive>::value>
+            = traits::sfinae> inline
+  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::bitset<N> const & bits )
+  {
+    ar( CEREAL_NVP_("type", bitset_detail::type::bits) );
+
+    // Serialize 8 bit chunks
+    std::uint8_t chunk = 0;
+    std::uint8_t mask = 0x80;
+
+    // Set each chunk using a rotating mask for the current bit
+    for( std::size_t i = 0; i < N; ++i )
+    {
+      if( bits[i] )
+        chunk |= mask;
+
+      mask = static_cast<std::uint8_t>(mask >> 1);
+
+      // output current chunk when mask is empty (8 bits)
+      if( mask == 0 )
+      {
+        ar( chunk );
+        chunk = 0;
+        mask = 0x80;
+      }
+    }
+
+    // serialize remainder, if it exists
+    if( mask != 0x80 )
+      ar( chunk );
+  }
+
+  //! Serializing (save) for std::bitset when BinaryData is not supported
+  template <class Archive, size_t N,
+            traits::DisableIf<traits::is_output_serializable<BinaryData<std::uint32_t>, Archive>::value>
+            = traits::sfinae> inline
+  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::bitset<N> const & bits )
+  {
+    try
+    {
+      auto const b = bits.to_ulong();
+      ar( CEREAL_NVP_("type", bitset_detail::type::ulong) );
+      ar( CEREAL_NVP_("data", b) );
+    }
+    catch( std::overflow_error const & )
+    {
+      try
+      {
+        auto const b = bits.to_ullong();
+        ar( CEREAL_NVP_("type", bitset_detail::type::ullong) );
+        ar( CEREAL_NVP_("data", b) );
+      }
+      catch( std::overflow_error const & )
+      {
+        ar( CEREAL_NVP_("type", bitset_detail::type::string) );
+        ar( CEREAL_NVP_("data", bits.to_string()) );
+      }
+    }
+  }
+
+  //! Serializing (load) for std::bitset
+  template <class Archive, size_t N> inline
+  void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::bitset<N> & bits )
+  {
+    bitset_detail::type t;
+    ar( CEREAL_NVP_("type", t) );
+
+    switch( t )
+    {
+      case bitset_detail::type::ulong:
+      {
+        unsigned long b;
+        ar( CEREAL_NVP_("data", b) );
+        bits = std::bitset<N>( b );
+        break;
+      }
+      case bitset_detail::type::ullong:
+      {
+        unsigned long long b;
+        ar( CEREAL_NVP_("data", b) );
+        bits = std::bitset<N>( b );
+        break;
+      }
+      case bitset_detail::type::string:
+      {
+        std::string b;
+        ar( CEREAL_NVP_("data", b) );
+        bits = std::bitset<N>( b );
+        break;
+      }
+      case bitset_detail::type::bits:
+      {
+        // Normally we would use BinaryData to route this at compile time,
+        // but doing this at runtime doesn't break any old serialization
+        std::uint8_t chunk = 0;
+        std::uint8_t mask  = 0;
+
+        bits.reset();
+
+        // Load one chunk at a time, rotating through the chunk
+        // to set bits in the bitset
+        for( std::size_t i = 0; i < N; ++i )
+        {
+          if( mask == 0 )
+          {
+            ar( chunk );
+            mask = 0x80;
+          }
+
+          if( chunk & mask )
+            bits[i] = 1;
+
+          mask = static_cast<std::uint8_t>(mask >> 1);
+        }
+        break;
+      }
+      default:
+        throw Exception("Invalid bitset data representation");
+    }
+  }
+} // namespace cereal
+
+#endif // CEREAL_TYPES_BITSET_HPP_

data/vendor/cereal/include/cereal/types/boost_variant.hpp

@@ -0,0 +1,164 @@
+/*! \file boost_variant.hpp
+    \brief Support for boost::variant
+    \ingroup OtherTypes */
+/*
+  Copyright (c) 2014, Randolph Voorhies, Shane Grant
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+      * Redistributions of source code must retain the above copyright
+        notice, this list of conditions and the following disclaimer.
+      * Redistributions in binary form must reproduce the above copyright
+        notice, this list of conditions and the following disclaimer in the
+        documentation and/or other materials provided with the distribution.
+      * Neither the name of cereal nor the
+        names of its contributors may be used to endorse or promote products
+        derived from this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef CEREAL_TYPES_BOOST_VARIANT_HPP_
+#define CEREAL_TYPES_BOOST_VARIANT_HPP_
+
+//! @internal
+#if defined(_MSC_VER) && _MSC_VER < 1911
+#define CEREAL_CONSTEXPR_LAMBDA
+#else // MSVC 2017 or newer, all other compilers
+#define CEREAL_CONSTEXPR_LAMBDA constexpr
+#endif
+
+#include "cereal/cereal.hpp"
+#include <boost/variant/variant_fwd.hpp>
+#include <boost/variant/static_visitor.hpp>
+
+namespace cereal
+{
+  namespace boost_variant_detail
+  {
+    //! @internal
+    template <class Archive>
+    struct variant_save_visitor : boost::static_visitor<>
+    {
+      variant_save_visitor(Archive & ar_) : ar(ar_) {}
+
+      template<class T>
+      void operator()(T const & value) const
+      {
+        ar( CEREAL_NVP_("data", value) );
+      }
+
+      Archive & ar;
+    };
+
+    //! @internal
+    template <class Archive, class T>
+    struct LoadAndConstructLoadWrapper
+    {
+      using ST = typename std::aligned_storage<sizeof(T), CEREAL_ALIGNOF(T)>::type;
+
+      LoadAndConstructLoadWrapper() :
+        construct( reinterpret_cast<T *>( &st ) )
+      { }
+
+      ~LoadAndConstructLoadWrapper()
+      {
+        if (construct.itsValid)
+        {
+          construct->~T();
+        }
+      }
+
+      void CEREAL_SERIALIZE_FUNCTION_NAME( Archive & ar )
+      {
+        ::cereal::detail::Construct<T, Archive>::load_andor_construct( ar, construct );
+      }
+
+      ST st;
+      ::cereal::construct<T> construct;
+    };
+
+    //! @internal
+    template <class T> struct load_variant_wrapper;
+
+    //! Avoid serializing variant void_ type
+    /*! @internal */
+    template <>
+    struct load_variant_wrapper<boost::detail::variant::void_>
+    {
+      template <class Variant, class Archive>
+      static void load_variant( Archive &, Variant & )
+      { }
+    };
+
+    //! @internal
+    template <class T>
+    struct load_variant_wrapper
+    {
+      // default constructible
+      template <class Archive, class Variant>
+      static void load_variant_impl( Archive & ar, Variant & variant, std::true_type )
+      {
+        T value;
+        ar( CEREAL_NVP_("data", value) );
+        variant = std::move(value);
+      }
+
+      // not default constructible
+      template<class Variant, class Archive>
+      static void load_variant_impl(Archive & ar, Variant & variant, std::false_type )
+      {
+        LoadAndConstructLoadWrapper<Archive, T> loadWrapper;
+
+        ar( CEREAL_NVP_("data", loadWrapper) );
+        variant = std::move(*loadWrapper.construct.ptr());
+      }
+
+      //! @internal
+      template<class Variant, class Archive>
+      static void load_variant(Archive & ar, Variant & variant)
+      {
+        load_variant_impl( ar, variant, typename std::is_default_constructible<T>::type() );
+      }
+    };
+  } // namespace boost_variant_detail
+
+  //! Saving for boost::variant
+  template <class Archive, typename ... VariantTypes> inline
+  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, boost::variant<VariantTypes...> const & variant )
+  {
+    int32_t which = variant.which();
+    ar( CEREAL_NVP_("which", which) );
+    boost_variant_detail::variant_save_visitor<Archive> visitor(ar);
+    variant.apply_visitor(visitor);
+  }
+
+  //! Loading for boost::variant
+  template <class Archive, typename ... VariantTypes> inline
+  void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, boost::variant<VariantTypes...> & variant )
+  {
+    int32_t which;
+    ar( CEREAL_NVP_("which", which) );
+
+    using LoadFuncType = void(*)(Archive &, boost::variant<VariantTypes...> &);
+    CEREAL_CONSTEXPR_LAMBDA LoadFuncType loadFuncArray[] = {&boost_variant_detail::load_variant_wrapper<VariantTypes>::load_variant...};
+
+    if(which >= int32_t(sizeof(loadFuncArray)/sizeof(loadFuncArray[0])))
+      throw Exception("Invalid 'which' selector when deserializing boost::variant");
+
+    loadFuncArray[which](ar, variant);
+  }
+} // namespace cereal
+
+#undef CEREAL_CONSTEXPR_LAMBDA
+
+#endif // CEREAL_TYPES_BOOST_VARIANT_HPP_