isotree 0.1.4 → 0.1.5

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

@@ -0,0 +1,132 @@
+/*! \file queue.hpp
+    \brief Support for types found in \<queue\>
+    \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_QUEUE_HPP_
+#define CEREAL_TYPES_QUEUE_HPP_
+
+#include "cereal/details/helpers.hpp"
+#include <queue>
+
+// The default container for queue is deque, so let's include that too
+#include "cereal/types/deque.hpp"
+// The default comparator for queue is less
+#include "cereal/types/functional.hpp"
+
+namespace cereal
+{
+  namespace queue_detail
+  {
+    //! Allows access to the protected container in queue
+    /*! @internal */
+    template <class T, class C> inline
+    C const & container( std::queue<T, C> const & queue )
+    {
+      struct H : public std::queue<T, C>
+      {
+        static C const & get( std::queue<T, C> const & q )
+        {
+          return q.*(&H::c);
+        }
+      };
+
+      return H::get( queue );
+    }
+
+    //! Allows access to the protected container in priority queue
+    /*! @internal */
+    template <class T, class C, class Comp> inline
+    C const & container( std::priority_queue<T, C, Comp> const & priority_queue )
+    {
+      struct H : public std::priority_queue<T, C, Comp>
+      {
+        static C const & get( std::priority_queue<T, C, Comp> const & pq )
+        {
+          return pq.*(&H::c);
+        }
+      };
+
+      return H::get( priority_queue );
+    }
+
+    //! Allows access to the protected comparator in priority queue
+    /*! @internal */
+    template <class T, class C, class Comp> inline
+    Comp const & comparator( std::priority_queue<T, C, Comp> const & priority_queue )
+    {
+      struct H : public std::priority_queue<T, C, Comp>
+      {
+        static Comp const & get( std::priority_queue<T, C, Comp> const & pq )
+        {
+          return pq.*(&H::comp);
+        }
+      };
+
+      return H::get( priority_queue );
+    }
+  }
+
+  //! Saving for std::queue
+  template <class Archive, class T, class C> inline
+  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::queue<T, C> const & queue )
+  {
+    ar( CEREAL_NVP_("container", queue_detail::container( queue )) );
+  }
+
+  //! Loading for std::queue
+  template <class Archive, class T, class C> inline
+  void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::queue<T, C> & queue )
+  {
+    C container;
+    ar( CEREAL_NVP_("container", container) );
+    queue = std::queue<T, C>( std::move( container ) );
+  }
+
+  //! Saving for std::priority_queue
+  template <class Archive, class T, class C, class Comp> inline
+  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::priority_queue<T, C, Comp> const & priority_queue )
+  {
+    ar( CEREAL_NVP_("comparator", queue_detail::comparator( priority_queue )) );
+    ar( CEREAL_NVP_("container", queue_detail::container( priority_queue )) );
+  }
+
+  //! Loading for std::priority_queue
+  template <class Archive, class T, class C, class Comp> inline
+  void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::priority_queue<T, C, Comp> & priority_queue )
+  {
+    Comp comparator;
+    ar( CEREAL_NVP_("comparator", comparator) );
+
+    C container;
+    ar( CEREAL_NVP_("container", container) );
+
+    priority_queue = std::priority_queue<T, C, Comp>( comparator, std::move( container ) );
+  }
+} // namespace cereal
+
+#endif // CEREAL_TYPES_QUEUE_HPP_

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

@@ -0,0 +1,103 @@
+/*! \file set.hpp
+    \brief Support for types found in \<set\>
+    \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_SET_HPP_
+#define CEREAL_TYPES_SET_HPP_
+
+#include "cereal/cereal.hpp"
+#include <set>
+
+namespace cereal
+{
+  namespace set_detail
+  {
+    //! @internal
+    template <class Archive, class SetT> inline
+    void save( Archive & ar, SetT const & set )
+    {
+      ar( make_size_tag( static_cast<size_type>(set.size()) ) );
+
+      for( const auto & i : set )
+        ar( i );
+    }
+
+    //! @internal
+    template <class Archive, class SetT> inline
+    void load( Archive & ar, SetT & set )
+    {
+      size_type size;
+      ar( make_size_tag( size ) );
+
+      set.clear();
+
+      auto hint = set.begin();
+      for( size_type i = 0; i < size; ++i )
+      {
+        typename SetT::key_type key;
+
+        ar( key );
+        #ifdef CEREAL_OLDER_GCC
+        hint = set.insert( hint, std::move( key ) );
+        #else // NOT CEREAL_OLDER_GCC
+        hint = set.emplace_hint( hint, std::move( key ) );
+        #endif // NOT CEREAL_OLDER_GCC
+      }
+    }
+  }
+
+  //! Saving for std::set
+  template <class Archive, class K, class C, class A> inline
+  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::set<K, C, A> const & set )
+  {
+    set_detail::save( ar, set );
+  }
+
+  //! Loading for std::set
+  template <class Archive, class K, class C, class A> inline
+  void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::set<K, C, A> & set )
+  {
+    set_detail::load( ar, set );
+  }
+
+  //! Saving for std::multiset
+  template <class Archive, class K, class C, class A> inline
+  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::multiset<K, C, A> const & multiset )
+  {
+    set_detail::save( ar, multiset );
+  }
+
+  //! Loading for std::multiset
+  template <class Archive, class K, class C, class A> inline
+  void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::multiset<K, C, A> & multiset )
+  {
+    set_detail::load( ar, multiset );
+  }
+} // namespace cereal
+
+#endif // CEREAL_TYPES_SET_HPP_

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

@@ -0,0 +1,76 @@
+/*! \file stack.hpp
+    \brief Support for types found in \<stack\>
+    \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_STACK_HPP_
+#define CEREAL_TYPES_STACK_HPP_
+
+#include "cereal/cereal.hpp"
+#include <stack>
+
+// The default container for stack is deque, so let's include that too
+#include "cereal/types/deque.hpp"
+
+namespace cereal
+{
+  namespace stack_detail
+  {
+    //! Allows access to the protected container in stack
+    template <class T, class C> inline
+    C const & container( std::stack<T, C> const & stack )
+    {
+      struct H : public std::stack<T, C>
+      {
+        static C const & get( std::stack<T, C> const & s )
+        {
+          return s.*(&H::c);
+        }
+      };
+
+      return H::get( stack );
+    }
+  }
+
+  //! Saving for std::stack
+  template <class Archive, class T, class C> inline
+  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::stack<T, C> const & stack )
+  {
+    ar( CEREAL_NVP_("container", stack_detail::container( stack )) );
+  }
+
+  //! Loading for std::stack
+  template <class Archive, class T, class C> inline
+  void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::stack<T, C> & stack )
+  {
+    C container;
+    ar( CEREAL_NVP_("container", container) );
+    stack = std::stack<T, C>( std::move( container ) );
+  }
+} // namespace cereal
+
+#endif // CEREAL_TYPES_STACK_HPP_

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

@@ -0,0 +1,61 @@
+/*! \file string.hpp
+    \brief Support for types found in \<string\>
+    \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_STRING_HPP_
+#define CEREAL_TYPES_STRING_HPP_
+
+#include "cereal/cereal.hpp"
+#include <string>
+
+namespace cereal
+{
+  //! Serialization for basic_string types, if binary data is supported
+  template<class Archive, class CharT, class Traits, class Alloc> inline
+  typename std::enable_if<traits::is_output_serializable<BinaryData<CharT>, Archive>::value, void>::type
+  CEREAL_SAVE_FUNCTION_NAME(Archive & ar, std::basic_string<CharT, Traits, Alloc> const & str)
+  {
+    // Save number of chars + the data
+    ar( make_size_tag( static_cast<size_type>(str.size()) ) );
+    ar( binary_data( str.data(), str.size() * sizeof(CharT) ) );
+  }
+
+  //! Serialization for basic_string types, if binary data is supported
+  template<class Archive, class CharT, class Traits, class Alloc> inline
+  typename std::enable_if<traits::is_input_serializable<BinaryData<CharT>, Archive>::value, void>::type
+  CEREAL_LOAD_FUNCTION_NAME(Archive & ar, std::basic_string<CharT, Traits, Alloc> & str)
+  {
+    size_type size;
+    ar( make_size_tag( size ) );
+    str.resize(static_cast<std::size_t>(size));
+    ar( binary_data( const_cast<CharT *>( str.data() ), static_cast<std::size_t>(size) * sizeof(CharT) ) );
+  }
+} // namespace cereal
+
+#endif // CEREAL_TYPES_STRING_HPP_
+

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

@@ -0,0 +1,123 @@
+/*! \file tuple.hpp
+    \brief Support for types found in \<tuple\>
+    \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_TUPLE_HPP_
+#define CEREAL_TYPES_TUPLE_HPP_
+
+#include "cereal/cereal.hpp"
+#include <tuple>
+
+namespace cereal
+{
+  namespace tuple_detail
+  {
+    //! Creates a c string from a sequence of characters
+    /*! The c string created will always be prefixed by "tuple_element"
+        Based on code from: http://stackoverflow/a/20973438/710791
+        @internal */
+    template<char...Cs>
+    struct char_seq_to_c_str
+    {
+      static const int size = 14;// Size of array for the word: tuple_element
+      typedef const char (&arr_type)[sizeof...(Cs) + size];
+      static const char str[sizeof...(Cs) + size];
+    };
+
+    // the word tuple_element plus a number
+    //! @internal
+    template<char...Cs>
+    const char char_seq_to_c_str<Cs...>::str[sizeof...(Cs) + size] =
+      {'t','u','p','l','e','_','e','l','e','m','e','n','t', Cs..., '\0'};
+
+    //! Converts a number into a sequence of characters
+    /*! @tparam Q The quotient of dividing the original number by 10
+        @tparam R The remainder of dividing the original number by 10
+        @tparam C The sequence built so far
+        @internal */
+    template <size_t Q, size_t R, char ... C>
+    struct to_string_impl
+    {
+      using type = typename to_string_impl<Q/10, Q%10, static_cast<char>(R+std::size_t{'0'}), C...>::type;
+    };
+
+    //! Base case with no quotient
+    /*! @internal */
+    template <size_t R, char ... C>
+    struct to_string_impl<0, R, C...>
+    {
+      using type = char_seq_to_c_str<static_cast<char>(R+std::size_t{'0'}), C...>;
+    };
+
+    //! Generates a c string for a given index of a tuple
+    /*! Example use:
+        @code{cpp}
+        tuple_element_name<3>::c_str();// returns "tuple_element3"
+        @endcode
+        @internal */
+    template<size_t T>
+    struct tuple_element_name
+    {
+      using type = typename to_string_impl<T/10, T%10>::type;
+      static const typename type::arr_type c_str(){ return type::str; }
+    };
+
+    // unwinds a tuple to save it
+    //! @internal
+    template <size_t Height>
+    struct serialize
+    {
+      template <class Archive, class ... Types> inline
+      static void apply( Archive & ar, std::tuple<Types...> & tuple )
+      {
+        serialize<Height - 1>::template apply( ar, tuple );
+        ar( CEREAL_NVP_(tuple_element_name<Height - 1>::c_str(),
+            std::get<Height - 1>( tuple )) );
+      }
+    };
+
+    // Zero height specialization - nothing to do here
+    //! @internal
+    template <>
+    struct serialize<0>
+    {
+      template <class Archive, class ... Types> inline
+      static void apply( Archive &, std::tuple<Types...> & )
+      { }
+    };
+  }
+
+  //! Serializing for std::tuple
+  template <class Archive, class ... Types> inline
+  void CEREAL_SERIALIZE_FUNCTION_NAME( Archive & ar, std::tuple<Types...> & tuple )
+  {
+    tuple_detail::serialize<std::tuple_size<std::tuple<Types...>>::value>::template apply( ar, tuple );
+  }
+} // namespace cereal
+
+#endif // CEREAL_TYPES_TUPLE_HPP_