isotree 0.2.2 → 0.3.0

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

@@ -1,103 +0,0 @@
-/*! \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

@@ -1,76 +0,0 @@
-/*! \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

@@ -1,61 +0,0 @@
-/*! \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

@@ -1,123 +0,0 @@
-/*! \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_

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

@@ -1,36 +0,0 @@
-/*! \file unordered_map.hpp
-    \brief Support for types found in \<unordered_map\>
-    \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_UNORDERED_MAP_HPP_
-#define CEREAL_TYPES_UNORDERED_MAP_HPP_
-
-#include "cereal/types/concepts/pair_associative_container.hpp"
-#include <unordered_map>
-
-#endif // CEREAL_TYPES_UNORDERED_MAP_HPP_

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

@@ -1,99 +0,0 @@
-/*! \file unordered_set.hpp
-    \brief Support for types found in \<unordered_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_UNORDERED_SET_HPP_
-#define CEREAL_TYPES_UNORDERED_SET_HPP_
-
-#include "cereal/cereal.hpp"
-#include <unordered_set>
-
-namespace cereal
-{
-  namespace unordered_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();
-      set.reserve( static_cast<std::size_t>( size ) );
-
-      for( size_type i = 0; i < size; ++i )
-      {
-        typename SetT::key_type key;
-
-        ar( key );
-        set.emplace( std::move( key ) );
-      }
-    }
-  }
-
-  //! Saving for std::unordered_set
-  template <class Archive, class K, class H, class KE, class A> inline
-  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::unordered_set<K, H, KE, A> const & unordered_set )
-  {
-    unordered_set_detail::save( ar, unordered_set );
-  }
-
-  //! Loading for std::unordered_set
-  template <class Archive, class K, class H, class KE, class A> inline
-  void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::unordered_set<K, H, KE, A> & unordered_set )
-  {
-    unordered_set_detail::load( ar, unordered_set );
-  }
-
-  //! Saving for std::unordered_multiset
-  template <class Archive, class K, class H, class KE, class A> inline
-  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::unordered_multiset<K, H, KE, A> const & unordered_multiset )
-  {
-    unordered_set_detail::save( ar, unordered_multiset );
-  }
-
-  //! Loading for std::unordered_multiset
-  template <class Archive, class K, class H, class KE, class A> inline
-  void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::unordered_multiset<K, H, KE, A> & unordered_multiset )
-  {
-    unordered_set_detail::load( ar, unordered_multiset );
-  }
-} // namespace cereal
-
-#endif // CEREAL_TYPES_UNORDERED_SET_HPP_

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

@@ -1,47 +0,0 @@
-/*! \file utility.hpp
-    \brief Support for types found in \<utility\>
-    \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_UTILITY_HPP_
-#define CEREAL_TYPES_UTILITY_HPP_
-
-#include "cereal/cereal.hpp"
-#include <utility>
-
-namespace cereal
-{
-  //! Serializing for std::pair
-  template <class Archive, class T1, class T2> inline
-  void CEREAL_SERIALIZE_FUNCTION_NAME( Archive & ar, std::pair<T1, T2> & pair )
-  {
-    ar( CEREAL_NVP_("first",  pair.first),
-        CEREAL_NVP_("second", pair.second) );
-  }
-} // namespace cereal
-
-#endif // CEREAL_TYPES_UTILITY_HPP_

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

@@ -1,89 +0,0 @@
-/*! \file valarray.hpp
-\brief Support for types found in \<valarray\>
-\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_VALARRAY_HPP_
-#define CEREAL_TYPES_VALARRAY_HPP_
-
-#include "cereal/cereal.hpp"
-#include <valarray>
-
-namespace cereal
-{
-  //! Saving for std::valarray arithmetic types, using binary serialization, if supported
-  template <class Archive, class T> inline
-  typename std::enable_if<traits::is_output_serializable<BinaryData<T>, Archive>::value
-                          && std::is_arithmetic<T>::value, void>::type
-  CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::valarray<T> const & valarray )
-  {
-    ar( make_size_tag( static_cast<size_type>(valarray.size()) ) ); // number of elements
-    ar( binary_data( &valarray[0], valarray.size() * sizeof(T) ) ); // &valarray[0] ok since guaranteed contiguous
-  }
-
-  //! Loading for std::valarray arithmetic types, using binary serialization, if supported
-  template <class Archive, class T> inline
-  typename std::enable_if<traits::is_input_serializable<BinaryData<T>, Archive>::value
-                          && std::is_arithmetic<T>::value, void>::type
-  CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::valarray<T> & valarray )
-  {
-    size_type valarraySize;
-    ar( make_size_tag( valarraySize ) );
-
-    valarray.resize( static_cast<std::size_t>( valarraySize ) );
-    ar( binary_data( &valarray[0], static_cast<std::size_t>( valarraySize ) * sizeof(T) ) );
-  }
-
-  //! Saving for std::valarray all other types
-  template <class Archive, class T> inline
-  typename std::enable_if<!traits::is_output_serializable<BinaryData<T>, Archive>::value
-                          || !std::is_arithmetic<T>::value, void>::type
-  CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::valarray<T> const & valarray )
-  {
-    ar( make_size_tag( static_cast<size_type>(valarray.size()) ) ); // number of elements
-    for(auto && v : valarray)
-      ar(v);
-  }
-
-  //! Loading for std::valarray all other types
-  template <class Archive, class T> inline
-  typename std::enable_if<!traits::is_input_serializable<BinaryData<T>, Archive>::value
-                          || !std::is_arithmetic<T>::value, void>::type
-  CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::valarray<T> & valarray )
-  {
-    size_type valarraySize;
-    ar( make_size_tag( valarraySize ) );
-
-    valarray.resize( static_cast<size_t>( valarraySize ) );
-    for(auto && v : valarray)
-      ar(v);
-  }
-} // namespace cereal
-
-#endif // CEREAL_TYPES_VALARRAY_HPP_