isotree 0.1.4 → 0.1.5

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

@@ -0,0 +1,72 @@
+/*! \file chrono.hpp
+    \brief Support for types found in \<chrono\>
+    \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_CHRONO_HPP_
+#define CEREAL_TYPES_CHRONO_HPP_
+
+#include <chrono>
+
+namespace cereal
+{
+  //! Saving std::chrono::duration
+  template <class Archive, class R, class P> inline
+  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::chrono::duration<R, P> const & dur )
+  {
+    ar( CEREAL_NVP_("count", dur.count()) );
+  }
+
+  //! Loading std::chrono::duration
+  template <class Archive, class R, class P> inline
+  void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::chrono::duration<R, P> & dur )
+  {
+    R count;
+    ar( CEREAL_NVP_("count", count) );
+
+    dur = std::chrono::duration<R, P>{count};
+  }
+
+  //! Saving std::chrono::time_point
+  template <class Archive, class C, class D> inline
+  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::chrono::time_point<C, D> const & dur )
+  {
+    ar( CEREAL_NVP_("time_since_epoch", dur.time_since_epoch()) );
+  }
+
+  //! Loading std::chrono::time_point
+  template <class Archive, class C, class D> inline
+  void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::chrono::time_point<C, D> & dur )
+  {
+    D elapsed;
+    ar( CEREAL_NVP_("time_since_epoch", elapsed) );
+
+    dur = std::chrono::time_point<C, D>{elapsed};
+  }
+} // namespace cereal
+
+#endif // CEREAL_TYPES_CHRONO_HPP_

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

@@ -0,0 +1,129 @@
+/*! \file common.hpp
+    \brief Support common types - always included automatically
+    \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_COMMON_HPP_
+#define CEREAL_TYPES_COMMON_HPP_
+
+#include "cereal/cereal.hpp"
+
+namespace cereal
+{
+  namespace common_detail
+  {
+    //! Serialization for arrays if BinaryData is supported and we are arithmetic
+    /*! @internal */
+    template <class Archive, class T> inline
+    void serializeArray( Archive & ar, T & array, std::true_type /* binary_supported */ )
+    {
+      ar( binary_data( array, sizeof(array) ) );
+    }
+
+    //! Serialization for arrays if BinaryData is not supported or we are not arithmetic
+    /*! @internal */
+    template <class Archive, class T> inline
+    void serializeArray( Archive & ar, T & array, std::false_type /* binary_supported */ )
+    {
+      for( auto & i : array )
+        ar( i );
+    }
+
+    namespace
+    {
+      //! Gets the underlying type of an enum
+      /*! @internal */
+      template <class T, bool IsEnum>
+      struct enum_underlying_type : std::false_type {};
+
+      //! Gets the underlying type of an enum
+      /*! Specialization for when we actually have an enum
+          @internal */
+      template <class T>
+      struct enum_underlying_type<T, true> { using type = typename std::underlying_type<T>::type; };
+    } // anon namespace
+
+    //! Checks if a type is an enum
+    /*! This is needed over simply calling std::is_enum because the type
+        traits checking at compile time will attempt to call something like
+        load_minimal with a special NoConvertRef struct that wraps up the true type.
+
+        This will strip away any of that and also expose the true underlying type.
+        @internal */
+    template <class T>
+    class is_enum
+    {
+      private:
+        using DecayedT  = typename std::decay<T>::type;
+        using StrippedT = typename ::cereal::traits::strip_minimal<DecayedT>::type;
+
+      public:
+        static const bool value = std::is_enum<StrippedT>::value;
+        using type = StrippedT;
+        using base_type = typename enum_underlying_type<StrippedT, value>::type;
+    };
+  }
+
+  //! Saving for enum types
+  template <class Archive, class T> inline
+  typename std::enable_if<common_detail::is_enum<T>::value,
+                          typename common_detail::is_enum<T>::base_type>::type
+  CEREAL_SAVE_MINIMAL_FUNCTION_NAME( Archive const &, T const & t )
+  {
+    return static_cast<typename common_detail::is_enum<T>::base_type>(t);
+  }
+
+  //! Loading for enum types
+  template <class Archive, class T> inline
+  typename std::enable_if<common_detail::is_enum<T>::value, void>::type
+  CEREAL_LOAD_MINIMAL_FUNCTION_NAME( Archive const &, T && t,
+                                     typename common_detail::is_enum<T>::base_type const & value )
+  {
+    t = reinterpret_cast<typename common_detail::is_enum<T>::type const &>( value );
+  }
+
+  //! Serialization for raw pointers
+  /*! This exists only to throw a static_assert to let users know we don't support raw pointers. */
+  template <class Archive, class T> inline
+  void CEREAL_SERIALIZE_FUNCTION_NAME( Archive &, T * & )
+  {
+    static_assert(cereal::traits::detail::delay_static_assert<T>::value,
+      "Cereal does not support serializing raw pointers - please use a smart pointer");
+  }
+
+  //! Serialization for C style arrays
+  template <class Archive, class T> inline
+  typename std::enable_if<std::is_array<T>::value, void>::type
+  CEREAL_SERIALIZE_FUNCTION_NAME(Archive & ar, T & array)
+  {
+    common_detail::serializeArray( ar, array,
+        std::integral_constant<bool, traits::is_output_serializable<BinaryData<T>, Archive>::value &&
+                                     std::is_arithmetic<typename std::remove_all_extents<T>::type>::value>() );
+  }
+} // namespace cereal
+
+#endif // CEREAL_TYPES_COMMON_HPP_

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

@@ -0,0 +1,56 @@
+/*! \file complex.hpp
+    \brief Support for types found in \<complex\>
+    \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_COMPLEX_HPP_
+#define CEREAL_TYPES_COMPLEX_HPP_
+
+#include <complex>
+
+namespace cereal
+{
+  //! Serializing (save) for std::complex
+  template <class Archive, class T> inline
+  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::complex<T> const & comp )
+  {
+    ar( CEREAL_NVP_("real", comp.real()),
+        CEREAL_NVP_("imag", comp.imag()) );
+  }
+
+  //! Serializing (load) for std::complex
+  template <class Archive, class T> inline
+  void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::complex<T> & bits )
+  {
+    T real, imag;
+    ar( CEREAL_NVP_("real", real),
+        CEREAL_NVP_("imag", imag) );
+    bits = {real, imag};
+  }
+} // namespace cereal
+
+#endif // CEREAL_TYPES_COMPLEX_HPP_

data/vendor/cereal/include/cereal/types/concepts/pair_associative_container.hpp

@@ -0,0 +1,73 @@
+/*! \file pair_associative_container.hpp
+    \brief Support for the PairAssociativeContainer refinement of the
+    AssociativeContainer concept.
+    \ingroup TypeConcepts */
+/*
+  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_CONCEPTS_PAIR_ASSOCIATIVE_CONTAINER_HPP_
+#define CEREAL_CONCEPTS_PAIR_ASSOCIATIVE_CONTAINER_HPP_
+
+#include "cereal/cereal.hpp"
+
+namespace cereal
+{
+  //! Saving for std-like pair associative containers
+  template <class Archive, template <typename...> class Map, typename... Args, typename = typename Map<Args...>::mapped_type> inline
+  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, Map<Args...> const & map )
+  {
+    ar( make_size_tag( static_cast<size_type>(map.size()) ) );
+
+    for( const auto & i : map )
+      ar( make_map_item(i.first, i.second) );
+  }
+
+  //! Loading for std-like pair associative containers
+  template <class Archive, template <typename...> class Map, typename... Args, typename = typename Map<Args...>::mapped_type> inline
+  void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, Map<Args...> & map )
+  {
+    size_type size;
+    ar( make_size_tag( size ) );
+
+    map.clear();
+
+    auto hint = map.begin();
+    for( size_t i = 0; i < size; ++i )
+    {
+      typename Map<Args...>::key_type key;
+      typename Map<Args...>::mapped_type value;
+
+      ar( make_map_item(key, value) );
+      #ifdef CEREAL_OLDER_GCC
+      hint = map.insert( hint, std::make_pair(std::move(key), std::move(value)) );
+      #else // NOT CEREAL_OLDER_GCC
+      hint = map.emplace_hint( hint, std::move( key ), std::move( value ) );
+      #endif // NOT CEREAL_OLDER_GCC
+    }
+  }
+} // namespace cereal
+
+#endif // CEREAL_CONCEPTS_PAIR_ASSOCIATIVE_CONTAINER_HPP_

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

@@ -0,0 +1,62 @@
+/*! \file deque.hpp
+    \brief Support for types found in \<deque\>
+    \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_DEQUE_HPP_
+#define CEREAL_TYPES_DEQUE_HPP_
+
+#include "cereal/cereal.hpp"
+#include <deque>
+
+namespace cereal
+{
+  //! Saving for std::deque
+  template <class Archive, class T, class A> inline
+  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::deque<T, A> const & deque )
+  {
+    ar( make_size_tag( static_cast<size_type>(deque.size()) ) );
+
+    for( auto const & i : deque )
+      ar( i );
+  }
+
+  //! Loading for std::deque
+  template <class Archive, class T, class A> inline
+  void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::deque<T, A> & deque )
+  {
+    size_type size;
+    ar( make_size_tag( size ) );
+
+    deque.resize( static_cast<size_t>( size ) );
+
+    for( auto & i : deque )
+      ar( i );
+  }
+} // namespace cereal
+
+#endif // CEREAL_TYPES_DEQUE_HPP_

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

@@ -0,0 +1,68 @@
+/*! \file forward_list.hpp
+    \brief Support for types found in \<forward_list\>
+    \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_FORWARD_LIST_HPP_
+#define CEREAL_TYPES_FORWARD_LIST_HPP_
+
+#include "cereal/cereal.hpp"
+#include <forward_list>
+
+namespace cereal
+{
+  //! Saving for std::forward_list all other types
+  template <class Archive, class T, class A> inline
+  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::forward_list<T, A> const & forward_list )
+  {
+    // write the size - note that this is slow because we need to traverse
+    // the entire list. there are ways we could avoid this but this was chosen
+    // since it works in the most general fashion with any archive type
+    size_type const size = std::distance( forward_list.begin(), forward_list.end() );
+
+    ar( make_size_tag( size ) );
+
+    // write the list
+    for( const auto & i : forward_list )
+      ar( i );
+  }
+
+  //! Loading for std::forward_list all other types from
+  template <class Archive, class T, class A>
+  void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::forward_list<T, A> & forward_list )
+  {
+    size_type size;
+    ar( make_size_tag( size ) );
+
+    forward_list.resize( static_cast<size_t>( size ) );
+
+    for( auto & i : forward_list )
+      ar( i );
+  }
+} // namespace cereal
+
+#endif // CEREAL_TYPES_FORWARD_LIST_HPP_