isotree 0.2.2 → 0.3.0

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

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

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

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

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

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