isotree 0.1.4 → 0.1.5

data/vendor/cereal/include/cereal/external/rapidxml/rapidxml_utils.hpp

@@ -0,0 +1,123 @@
+#ifndef CEREAL_RAPIDXML_UTILS_HPP_INCLUDED
+#define CEREAL_RAPIDXML_UTILS_HPP_INCLUDED
+
+// Copyright (C) 2006, 2009 Marcin Kalicinski
+// Version 1.13
+// Revision $DateTime: 2009/05/13 01:46:17 $
+//! in certain simple scenarios. They should probably not be used if maximizing performance is the main objective.
+
+#include "rapidxml.hpp"
+#include <vector>
+#include <string>
+#include <fstream>
+#include <stdexcept>
+
+namespace cereal {
+namespace rapidxml
+{
+
+    //! Represents data loaded from a file
+    template<class Ch = char>
+    class file
+    {
+
+    public:
+
+        //! Loads file into the memory. Data will be automatically destroyed by the destructor.
+        //! \param filename Filename to load.
+        file(const char *filename)
+        {
+            using namespace std;
+
+            // Open stream
+            basic_ifstream<Ch> stream(filename, ios::binary);
+            if (!stream)
+                throw runtime_error(string("cannot open file ") + filename);
+            stream.unsetf(ios::skipws);
+
+            // Determine stream size
+            stream.seekg(0, ios::end);
+            size_t size = stream.tellg();
+            stream.seekg(0);
+
+            // Load data and add terminating 0
+            m_data.resize(size + 1);
+            stream.read(&m_data.front(), static_cast<streamsize>(size));
+            m_data[size] = 0;
+        }
+
+        //! Loads file into the memory. Data will be automatically destroyed by the destructor
+        //! \param stream Stream to load from
+        file(std::basic_istream<Ch> &stream)
+        {
+            using namespace std;
+
+            // Load data and add terminating 0
+            stream.unsetf(ios::skipws);
+            m_data.assign(istreambuf_iterator<Ch>(stream), istreambuf_iterator<Ch>());
+            if (stream.fail() || stream.bad())
+                throw runtime_error("error reading stream");
+            m_data.push_back(0);
+        }
+
+        //! Gets file data.
+        //! \return Pointer to data of file.
+        Ch *data()
+        {
+            return &m_data.front();
+        }
+
+        //! Gets file data.
+        //! \return Pointer to data of file.
+        const Ch *data() const
+        {
+            return &m_data.front();
+        }
+
+        //! Gets file data size.
+        //! \return Size of file data, in characters.
+        std::size_t size() const
+        {
+            return m_data.size();
+        }
+
+    private:
+
+        std::vector<Ch> m_data;   // File data
+
+    };
+
+    //! Counts children of node. Time complexity is O(n).
+    //! \return Number of children of node
+    template<class Ch>
+    inline std::size_t count_children(xml_node<Ch> *node)
+    {
+        xml_node<Ch> *child = node->first_node();
+        std::size_t count = 0;
+        while (child)
+        {
+            ++count;
+            child = child->next_sibling();
+        }
+        return count;
+    }
+
+    //! Counts attributes of node. Time complexity is O(n).
+    //! \return Number of attributes of node
+    template<class Ch>
+    inline std::size_t count_attributes(xml_node<Ch> *node)
+    {
+        xml_attribute<Ch> *attr = node->first_attribute();
+        std::size_t count = 0;
+        while (attr)
+        {
+            ++count;
+            attr = attr->next_attribute();
+        }
+        return count;
+    }
+
+}
+} // namespace cereal
+
+#endif

data/vendor/cereal/include/cereal/macros.hpp

@@ -0,0 +1,154 @@
+/*! \file macros.hpp
+    \brief Preprocessor macros that can customise the cereal library
+
+    By default, cereal looks for serialization functions with very
+    specific names, that is: serialize, load, save, load_minimal,
+    or save_minimal.
+
+    This file allows an advanced user to change these names to conform
+    to some other style or preference.  This is implemented using
+    preprocessor macros.
+
+    As a result of this, in internal cereal code you will see macros
+    used for these function names.  In user code, you should name
+    the functions like you normally would and not use the macros
+    to improve readability.
+    \ingroup utility */
+/*
+  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_MACROS_HPP_
+#define CEREAL_MACROS_HPP_
+
+#ifndef CEREAL_THREAD_SAFE
+//! Whether cereal should be compiled for a threaded environment
+/*! This macro causes cereal to use mutexes to control access to
+    global internal state in a thread safe manner.
+
+    Note that even with this enabled you must still ensure that
+    archives are accessed by only one thread at a time; it is safe
+    to use multiple archives in paralel, but not to access one archive
+    from many places simultaneously. */
+#define CEREAL_THREAD_SAFE 0
+#endif // CEREAL_THREAD_SAFE
+
+#ifndef CEREAL_SIZE_TYPE
+//! Determines the data type used for size_type
+/*! cereal uses size_type to ensure that the serialized size of
+    dynamic containers is compatible across different architectures
+    (e.g. 32 vs 64 bit), which may use different underlying types for
+    std::size_t.
+
+    More information can be found in cereal/details/helpers.hpp.
+
+    If you choose to modify this type, ensure that you use a fixed
+    size type (e.g. uint32_t). */
+#define CEREAL_SIZE_TYPE uint64_t
+#endif // CEREAL_SIZE_TYPE
+
+// ######################################################################
+#ifndef CEREAL_SERIALIZE_FUNCTION_NAME
+//! The serialization/deserialization function name to search for.
+/*! You can define @c CEREAL_SERIALIZE_FUNCTION_NAME to be different assuming
+    you do so before this file is included. */
+#define CEREAL_SERIALIZE_FUNCTION_NAME serialize
+#endif // CEREAL_SERIALIZE_FUNCTION_NAME
+
+#ifndef CEREAL_LOAD_FUNCTION_NAME
+//! The deserialization (load) function name to search for.
+/*! You can define @c CEREAL_LOAD_FUNCTION_NAME to be different assuming you do so
+    before this file is included. */
+#define CEREAL_LOAD_FUNCTION_NAME load
+#endif // CEREAL_LOAD_FUNCTION_NAME
+
+#ifndef CEREAL_SAVE_FUNCTION_NAME
+//! The serialization (save) function name to search for.
+/*! You can define @c CEREAL_SAVE_FUNCTION_NAME to be different assuming you do so
+    before this file is included. */
+#define CEREAL_SAVE_FUNCTION_NAME save
+#endif // CEREAL_SAVE_FUNCTION_NAME
+
+#ifndef CEREAL_LOAD_MINIMAL_FUNCTION_NAME
+//! The deserialization (load_minimal) function name to search for.
+/*! You can define @c CEREAL_LOAD_MINIMAL_FUNCTION_NAME to be different assuming you do so
+    before this file is included. */
+#define CEREAL_LOAD_MINIMAL_FUNCTION_NAME load_minimal
+#endif // CEREAL_LOAD_MINIMAL_FUNCTION_NAME
+
+#ifndef CEREAL_SAVE_MINIMAL_FUNCTION_NAME
+//! The serialization (save_minimal) function name to search for.
+/*! You can define @c CEREAL_SAVE_MINIMAL_FUNCTION_NAME to be different assuming you do so
+    before this file is included. */
+#define CEREAL_SAVE_MINIMAL_FUNCTION_NAME save_minimal
+#endif // CEREAL_SAVE_MINIMAL_FUNCTION_NAME
+
+// ######################################################################
+//! Defines the CEREAL_NOEXCEPT macro to use instead of noexcept
+/*! If a compiler we support does not support noexcept, this macro
+    will detect this and define CEREAL_NOEXCEPT as a no-op
+    @internal */
+#if !defined(CEREAL_HAS_NOEXCEPT)
+  #if defined(__clang__)
+    #if __has_feature(cxx_noexcept)
+      #define CEREAL_HAS_NOEXCEPT
+    #endif
+  #else // NOT clang
+    #if defined(__GXX_EXPERIMENTAL_CXX0X__) && __GNUC__ * 10 + __GNUC_MINOR__ >= 46 || \
+        defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023026
+      #define CEREAL_HAS_NOEXCEPT
+    #endif // end GCC/MSVC check
+  #endif // end NOT clang block
+
+  #ifndef CEREAL_NOEXCEPT
+    #ifdef CEREAL_HAS_NOEXCEPT
+      #define CEREAL_NOEXCEPT noexcept
+    #else
+      #define CEREAL_NOEXCEPT
+    #endif // end CEREAL_HAS_NOEXCEPT
+  #endif // end !defined(CEREAL_HAS_NOEXCEPT)
+#endif // ifndef CEREAL_NOEXCEPT
+
+// ######################################################################
+//! Checks if C++17 is available
+#if __cplusplus >= 201703L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
+#define CEREAL_HAS_CPP17
+#endif
+
+//! Checks if C++14 is available
+#if __cplusplus >= 201402L
+#define CEREAL_HAS_CPP14
+#endif
+
+// ######################################################################
+//! Defines the CEREAL_ALIGNOF macro to use instead of alignof
+#if defined(_MSC_VER) && _MSC_VER < 1900
+#define CEREAL_ALIGNOF __alignof
+#else // not MSVC 2013 or older
+#define CEREAL_ALIGNOF alignof
+#endif // end MSVC check
+
+#endif // CEREAL_MACROS_HPP_

data/vendor/cereal/include/cereal/specialize.hpp

@@ -0,0 +1,139 @@
+/*! \file specialize.hpp
+    \brief Serialization disambiguation */
+/*
+  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_SPECIALIZE_HPP_
+#define CEREAL_SPECIALIZE_HPP_
+
+namespace cereal
+{
+  // Forward declaration of access class that users can become friends with
+  class access;
+
+  // ######################################################################
+  //! A specifier used in conjunction with cereal::specialize to disambiguate
+  //! serialization in special cases
+  /*! @relates specialize
+      @ingroup Access */
+  enum class specialization
+  {
+    member_serialize,            //!< Force the use of a member serialize function
+    member_load_save,            //!< Force the use of a member load/save pair
+    member_load_save_minimal,    //!< Force the use of a member minimal load/save pair
+    non_member_serialize,        //!< Force the use of a non-member serialize function
+    non_member_load_save,        //!< Force the use of a non-member load/save pair
+    non_member_load_save_minimal //!< Force the use of a non-member minimal load/save pair
+  };
+
+  //! A class used to disambiguate cases where cereal cannot detect a unique way of serializing a class
+  /*! cereal attempts to figure out which method of serialization (member vs. non-member serialize
+      or load/save pair) at compile time.  If for some reason cereal cannot find a non-ambiguous way
+      of serializing a type, it will produce a static assertion complaining about this.
+
+      This can happen because you have both a serialize and load/save pair, or even because a base
+      class has a serialize (public or private with friend access) and a derived class does not
+      overwrite this due to choosing some other serialization type.
+
+      Specializing this class will tell cereal to explicitly use the serialization type you specify
+      and it will not complain about ambiguity in its compile time selection.  However, if cereal detects
+      an ambiguity in specializations, it will continue to issue a static assertion.
+
+      @code{.cpp}
+      class MyParent
+      {
+        friend class cereal::access;
+        template <class Archive>
+        void serialize( Archive & ar ) {}
+      };
+
+      // Although serialize is private in MyParent, to cereal::access it will look public,
+      // even through MyDerived
+      class MyDerived : public MyParent
+      {
+        public:
+          template <class Archive>
+          void load( Archive & ar ) {}
+
+          template <class Archive>
+          void save( Archive & ar ) {}
+      };
+
+      // The load/save pair in MyDerived is ambiguous because serialize in MyParent can
+      // be accessed from cereal::access.  This looks the same as making serialize public
+      // in MyParent, making it seem as though MyDerived has both a serialize and a load/save pair.
+      // cereal will complain about this at compile time unless we disambiguate:
+
+      namespace cereal
+      {
+        // This struct specialization will tell cereal which is the right way to serialize the ambiguity
+        template <class Archive> struct specialize<Archive, MyDerived, cereal::specialization::member_load_save> {};
+
+        // If we only had a disambiguation for a specific archive type, it would look something like this
+        template <> struct specialize<cereal::BinaryOutputArchive, MyDerived, cereal::specialization::member_load_save> {};
+      }
+      @endcode
+
+      You can also choose to use the macros CEREAL_SPECIALIZE_FOR_ALL_ARCHIVES or
+      CEREAL_SPECIALIZE_FOR_ARCHIVE if you want to type a little bit less.
+
+      @tparam T The type to specialize the serialization for
+      @tparam S The specialization type to use for T
+      @ingroup Access */
+  template <class Archive, class T, specialization S>
+  struct specialize : public std::false_type {};
+
+  //! Convenient macro for performing specialization for all archive types
+  /*! This performs specialization for the specific type for all types of archives.
+      This macro should be placed at the global namespace.
+
+      @code{cpp}
+      struct MyType {};
+      CEREAL_SPECIALIZE_FOR_ALL_ARCHIVES( MyType, cereal::specialization::member_load_save );
+      @endcode
+
+      @relates specialize
+      @ingroup Access */
+  #define CEREAL_SPECIALIZE_FOR_ALL_ARCHIVES( Type, Specialization )                                \
+  namespace cereal { template <class Archive> struct specialize<Archive, Type, Specialization> {}; }
+
+  //! Convenient macro for performing specialization for a single archive type
+  /*! This performs specialization for the specific type for a single type of archive.
+      This macro should be placed at the global namespace.
+
+      @code{cpp}
+      struct MyType {};
+      CEREAL_SPECIALIZE_FOR_ARCHIVE( cereal::XMLInputArchive, MyType, cereal::specialization::member_load_save );
+      @endcode
+
+      @relates specialize
+      @ingroup Access */
+  #define CEREAL_SPECIALIZE_FOR_ARCHIVE( Archive, Type, Specialization )               \
+  namespace cereal { template <> struct specialize<Archive, Type, Specialization> {}; }
+}
+
+#endif

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

@@ -0,0 +1,79 @@
+/*! \file array.hpp
+    \brief Support for types found in \<array\>
+    \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_ARRAY_HPP_
+#define CEREAL_TYPES_ARRAY_HPP_
+
+#include "cereal/cereal.hpp"
+#include <array>
+
+namespace cereal
+{
+  //! Saving for std::array primitive types
+  //! using binary serialization, if supported
+  template <class Archive, class T, size_t N> 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::array<T, N> const & array )
+  {
+    ar( binary_data( array.data(), sizeof(array) ) );
+  }
+
+  //! Loading for std::array primitive types
+  //! using binary serialization, if supported
+  template <class Archive, class T, size_t N> 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::array<T, N> & array )
+  {
+    ar( binary_data( array.data(), sizeof(array) ) );
+  }
+
+  //! Saving for std::array all other types
+  template <class Archive, class T, size_t N> 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::array<T, N> const & array )
+  {
+    for( auto const & i : array )
+      ar( i );
+  }
+
+  //! Loading for std::array all other types
+  template <class Archive, class T, size_t N> 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::array<T, N> & array )
+  {
+    for( auto & i : array )
+      ar( i );
+  }
+} // namespace cereal
+
+#endif // CEREAL_TYPES_ARRAY_HPP_