commit 8f94a7f5
Updated Cereal to 1.3.0
Changed files
diff --git a/source/code/Libs/include/cereal/ABOUT b/source/code/Libs/include/cereal/ABOUT
index 5a41a69..fe2459c 100644
--- a/source/code/Libs/include/cereal/ABOUT
+++ b/source/code/Libs/include/cereal/ABOUT
@@ -6,4 +6,4 @@ http://USCiLab.github.com/cereal
See LICENSE for more information
-Version 1.2.2
+Version 1.3.0
diff --git a/source/code/Libs/include/cereal/access.hpp b/source/code/Libs/include/cereal/access.hpp
index 63c1f74..d7917bd 100644
--- a/source/code/Libs/include/cereal/access.hpp
+++ b/source/code/Libs/include/cereal/access.hpp
@@ -1,5 +1,5 @@
/*! \file access.hpp
- \brief Access control, default construction, and serialization disambiguation */
+ \brief Access control and default construction */
/*
Copyright (c) 2014, Randolph Voorhies, Shane Grant
All rights reserved.
@@ -35,6 +35,7 @@
#include <functional>
#include "cereal/macros.hpp"
+#include "cereal/specialize.hpp"
#include "cereal/details/helpers.hpp"
namespace cereal
@@ -110,6 +111,7 @@ namespace cereal
// forward decl for construct
//! @cond PRIVATE_NEVERDEFINED
namespace memory_detail{ template <class Ar, class T> struct LoadAndConstructLoadWrapper; }
+ namespace boost_variant_detail{ template <class Ar, class T> struct LoadAndConstructLoadWrapper; }
//! @endcond
//! Used to construct types with no default constructor
@@ -202,7 +204,8 @@ namespace cereal
}
private:
- template <class A, class B> friend struct ::cereal::memory_detail::LoadAndConstructLoadWrapper;
+ template <class Ar, class TT> friend struct ::cereal::memory_detail::LoadAndConstructLoadWrapper;
+ template <class Ar, class TT> friend struct ::cereal::boost_variant_detail::LoadAndConstructLoadWrapper;
construct( T * p ) : itsPtr( p ), itsEnableSharedRestoreFunction( [](){} ), itsValid( false ) {}
construct( T * p, std::function<void()> enableSharedFunc ) : // g++4.7 ice with default lambda to std func
@@ -332,106 +335,6 @@ namespace cereal
}; // end 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> {}; }
-
- // ######################################################################
// Deferred Implementation, see construct for more information
template <class T> template <class ... Args> inline
void construct<T>::operator()( Args && ... args )
diff --git a/source/code/Libs/include/cereal/archives/binary.hpp b/source/code/Libs/include/cereal/archives/binary.hpp
index 7e00322..d8c5318 100644
--- a/source/code/Libs/include/cereal/archives/binary.hpp
+++ b/source/code/Libs/include/cereal/archives/binary.hpp
@@ -62,9 +62,9 @@ namespace cereal
~BinaryOutputArchive() CEREAL_NOEXCEPT = default;
//! Writes size bytes of data to the output stream
- void saveBinary( const void * data, std::size_t size )
+ void saveBinary( const void * data, std::streamsize size )
{
- auto const writtenSize = static_cast<std::size_t>( itsStream.rdbuf()->sputn( reinterpret_cast<const char*>( data ), size ) );
+ auto const writtenSize = itsStream.rdbuf()->sputn( reinterpret_cast<const char*>( data ), size );
if(writtenSize != size)
throw Exception("Failed to write " + std::to_string(size) + " bytes to output stream! Wrote " + std::to_string(writtenSize));
@@ -97,9 +97,9 @@ namespace cereal
~BinaryInputArchive() CEREAL_NOEXCEPT = default;
//! Reads size bytes of data from the input stream
- void loadBinary( void * const data, std::size_t size )
+ void loadBinary( void * const data, std::streamsize size )
{
- auto const readSize = static_cast<std::size_t>( itsStream.rdbuf()->sgetn( reinterpret_cast<char*>( data ), size ) );
+ auto const readSize = itsStream.rdbuf()->sgetn( reinterpret_cast<char*>( data ), size );
if(readSize != size)
throw Exception("Failed to read " + std::to_string(size) + " bytes from input stream! Read " + std::to_string(readSize));
@@ -148,14 +148,14 @@ namespace cereal
template <class T> inline
void CEREAL_SAVE_FUNCTION_NAME(BinaryOutputArchive & ar, BinaryData<T> const & bd)
{
- ar.saveBinary( bd.data, static_cast<std::size_t>( bd.size ) );
+ ar.saveBinary( bd.data, static_cast<std::streamsize>( bd.size ) );
}
//! Loading binary data
template <class T> inline
void CEREAL_LOAD_FUNCTION_NAME(BinaryInputArchive & ar, BinaryData<T> & bd)
{
- ar.loadBinary(bd.data, static_cast<std::size_t>(bd.size));
+ ar.loadBinary(bd.data, static_cast<std::streamsize>( bd.size ) );
}
} // namespace cereal
diff --git a/source/code/Libs/include/cereal/archives/json.hpp b/source/code/Libs/include/cereal/archives/json.hpp
index 9d57434..82312e3 100644
--- a/source/code/Libs/include/cereal/archives/json.hpp
+++ b/source/code/Libs/include/cereal/archives/json.hpp
@@ -40,6 +40,11 @@ namespace cereal
{ RapidJSONException( const char * what_ ) : Exception( what_ ) {} };
}
+// Inform rapidjson that assert will throw
+#ifndef CEREAL_RAPIDJSON_ASSERT_THROWS
+#define CEREAL_RAPIDJSON_ASSERT_THROWS
+#endif // CEREAL_RAPIDJSON_ASSERT_THROWS
+
// Override rapidjson assertions to throw exceptions by default
#ifndef CEREAL_RAPIDJSON_ASSERT
#define CEREAL_RAPIDJSON_ASSERT(x) if(!(x)){ \
@@ -47,8 +52,14 @@ namespace cereal
#endif // RAPIDJSON_ASSERT
// Enable support for parsing of nan, inf, -inf
+#ifndef CEREAL_RAPIDJSON_WRITE_DEFAULT_FLAGS
#define CEREAL_RAPIDJSON_WRITE_DEFAULT_FLAGS kWriteNanAndInfFlag
+#endif
+
+// Enable support for parsing of nan, inf, -inf
+#ifndef CEREAL_RAPIDJSON_PARSE_DEFAULT_FLAGS
#define CEREAL_RAPIDJSON_PARSE_DEFAULT_FLAGS kParseFullPrecisionFlag | kParseNanAndInfFlag
+#endif
#include "cereal/external/rapidjson/prettywriter.h"
#include "cereal/external/rapidjson/ostreamwrapper.h"
@@ -209,11 +220,13 @@ namespace cereal
{
case NodeType::StartArray:
itsWriter.StartArray();
+ // fall through
case NodeType::InArray:
itsWriter.EndArray();
break;
case NodeType::StartObject:
itsWriter.StartObject();
+ // fall through
case NodeType::InObject:
itsWriter.EndObject();
break;
@@ -477,7 +490,7 @@ namespace cereal
}
Iterator(ValueIterator begin, ValueIterator end) :
- itsValueItBegin(begin), itsValueItEnd(end), itsIndex(0), itsType(Value)
+ itsValueItBegin(begin), itsIndex(0), itsType(Value)
{
if( std::distance( begin, end ) == 0 )
itsType = Null_;
@@ -532,7 +545,7 @@ namespace cereal
private:
MemberIterator itsMemberItBegin, itsMemberItEnd; //!< The member iterator (object)
- ValueIterator itsValueItBegin, itsValueItEnd; //!< The value iterator (array)
+ ValueIterator itsValueItBegin; //!< The value iterator (array)
size_t itsIndex; //!< The current index of this iterator
enum Type {Value, Member, Null_} itsType; //!< Whether this holds values (array) or members (objects) or nothing
};
@@ -752,6 +765,31 @@ namespace cereal
{ }
// ######################################################################
+ //! Prologue for deferred data for JSON archives
+ /*! Do nothing for the defer wrapper */
+ template <class T> inline
+ void prologue( JSONOutputArchive &, DeferredData<T> const & )
+ { }
+
+ //! Prologue for deferred data for JSON archives
+ template <class T> inline
+ void prologue( JSONInputArchive &, DeferredData<T> const & )
+ { }
+
+ // ######################################################################
+ //! Epilogue for deferred for JSON archives
+ /*! NVPs do not start or finish nodes - they just set up the names */
+ template <class T> inline
+ void epilogue( JSONOutputArchive &, DeferredData<T> const & )
+ { }
+
+ //! Epilogue for deferred for JSON archives
+ /*! Do nothing for the defer wrapper */
+ template <class T> inline
+ void epilogue( JSONInputArchive &, DeferredData<T> const & )
+ { }
+
+ // ######################################################################
//! Prologue for SizeTags for JSON archives
/*! SizeTags are strictly ignored for JSON, they just indicate
that the current node should be made into an array */
diff --git a/source/code/Libs/include/cereal/archives/portable_binary.hpp b/source/code/Libs/include/cereal/archives/portable_binary.hpp
index 76e634b..59b72a6 100644
--- a/source/code/Libs/include/cereal/archives/portable_binary.hpp
+++ b/source/code/Libs/include/cereal/archives/portable_binary.hpp
@@ -128,19 +128,19 @@ namespace cereal
~PortableBinaryOutputArchive() CEREAL_NOEXCEPT = default;
//! Writes size bytes of data to the output stream
- template <std::size_t DataSize> inline
- void saveBinary( const void * data, std::size_t size )
+ template <std::streamsize DataSize> inline
+ void saveBinary( const void * data, std::streamsize size )
{
- std::size_t writtenSize = 0;
+ std::streamsize writtenSize = 0;
if( itsConvertEndianness )
{
- for( std::size_t i = 0; i < size; i += DataSize )
- for( std::size_t j = 0; j < DataSize; ++j )
- writtenSize += static_cast<std::size_t>( itsStream.rdbuf()->sputn( reinterpret_cast<const char*>( data ) + DataSize - j - 1 + i, 1 ) );
+ for( std::streamsize i = 0; i < size; i += DataSize )
+ for( std::streamsize j = 0; j < DataSize; ++j )
+ writtenSize += itsStream.rdbuf()->sputn( reinterpret_cast<const char*>( data ) + DataSize - j - 1 + i, 1 );
}
else
- writtenSize = static_cast<std::size_t>( itsStream.rdbuf()->sputn( reinterpret_cast<const char*>( data ), size ) );
+ writtenSize = itsStream.rdbuf()->sputn( reinterpret_cast<const char*>( data ), size );
if(writtenSize != size)
throw Exception("Failed to write " + std::to_string(size) + " bytes to output stream! Wrote " + std::to_string(writtenSize));
@@ -235,11 +235,11 @@ namespace cereal
/*! @param data The data to save
@param size The number of bytes in the data
@tparam DataSize T The size of the actual type of the data elements being loaded */
- template <std::size_t DataSize> inline
- void loadBinary( void * const data, std::size_t size )
+ template <std::streamsize DataSize> inline
+ void loadBinary( void * const data, std::streamsize size )
{
// load data
- auto const readSize = static_cast<std::size_t>( itsStream.rdbuf()->sgetn( reinterpret_cast<char*>( data ), size ) );
+ auto const readSize = itsStream.rdbuf()->sgetn( reinterpret_cast<char*>( data ), size );
if(readSize != size)
throw Exception("Failed to read " + std::to_string(size) + " bytes from input stream! Read " + std::to_string(readSize));
@@ -248,7 +248,7 @@ namespace cereal
if( itsConvertEndianness )
{
std::uint8_t * ptr = reinterpret_cast<std::uint8_t*>( data );
- for( std::size_t i = 0; i < size; i += DataSize )
+ for( std::streamsize i = 0; i < size; i += DataSize )
portable_binary_detail::swap_bytes<DataSize>( ptr + i );
}
}
@@ -308,7 +308,7 @@ namespace cereal
(std::is_floating_point<TT>::value && std::numeric_limits<TT>::is_iec559),
"Portable binary only supports IEEE 754 standardized floating point" );
- ar.template saveBinary<sizeof(TT)>( bd.data, static_cast<std::size_t>( bd.size ) );
+ ar.template saveBinary<sizeof(TT)>( bd.data, static_cast<std::streamsize>( bd.size ) );
}
//! Loading binary data from portable binary
@@ -320,7 +320,7 @@ namespace cereal
(std::is_floating_point<TT>::value && std::numeric_limits<TT>::is_iec559),
"Portable binary only supports IEEE 754 standardized floating point" );
- ar.template loadBinary<sizeof(TT)>( bd.data, static_cast<std::size_t>( bd.size ) );
+ ar.template loadBinary<sizeof(TT)>( bd.data, static_cast<std::streamsize>( bd.size ) );
}
} // namespace cereal
diff --git a/source/code/Libs/include/cereal/archives/xml.hpp b/source/code/Libs/include/cereal/archives/xml.hpp
index c520f02..23b4126 100644
--- a/source/code/Libs/include/cereal/archives/xml.hpp
+++ b/source/code/Libs/include/cereal/archives/xml.hpp
@@ -101,31 +101,58 @@ namespace cereal
//! @{
//! A class containing various advanced options for the XML archive
+ /*! Options can either be directly passed to the constructor, or chained using the
+ modifier functions for an interface analogous to named parameters */
class Options
{
public:
//! Default options
static Options Default(){ return Options(); }
- //! Default options with no indentation
- static Options NoIndent(){ return Options( std::numeric_limits<double>::max_digits10, false ); }
-
//! Specify specific options for the XMLOutputArchive
- /*! @param precision The precision used for floating point numbers
- @param indent Whether to indent each line of XML
- @param outputType Whether to output the type of each serialized object as an attribute */
- explicit Options( int precision = std::numeric_limits<double>::max_digits10,
- bool indent = true,
- bool outputType = false ) :
- itsPrecision( precision ),
- itsIndent( indent ),
- itsOutputType( outputType ) { }
+ /*! @param precision_ The precision used for floating point numbers
+ @param indent_ Whether to indent each line of XML
+ @param outputType_ Whether to output the type of each serialized object as an attribute
+ @param sizeAttributes_ Whether dynamically sized containers output the size=dynamic attribute */
+ explicit Options( int precision_ = std::numeric_limits<double>::max_digits10,
+ bool indent_ = true,
+ bool outputType_ = false,
+ bool sizeAttributes_ = true ) :
+ itsPrecision( precision_ ),
+ itsIndent( indent_ ),
+ itsOutputType( outputType_ ),
+ itsSizeAttributes( sizeAttributes_ )
+ { }
+
+ /*! @name Option Modifiers
+ An interface for setting option settings analogous to named parameters.
+
+ @code{cpp}
+ cereal::XMLOutputArchive ar( myStream,
+ cereal::XMLOutputArchive::Options()
+ .indent(true)
+ .sizeAttributes(false) );
+ @endcode
+ */
+ //! @{
+
+ //! Sets the precision used for floaing point numbers
+ Options & precision( int value ){ itsPrecision = value; return * this; }
+ //! Whether to indent each line of XML
+ Options & indent( bool enable ){ itsIndent = enable; return *this; }
+ //! Whether to output the type of each serialized object as an attribute
+ Options & outputType( bool enable ){ itsOutputType = enable; return *this; }
+ //! Whether dynamically sized containers (e.g. vector) output the size=dynamic attribute
+ Options & sizeAttributes( bool enable ){ itsSizeAttributes = enable; return *this; }
+
+ //! @}
private:
friend class XMLOutputArchive;
int itsPrecision;
bool itsIndent;
bool itsOutputType;
+ bool itsSizeAttributes;
};
//! Construct, outputting to the provided stream upon destruction
@@ -137,7 +164,8 @@ namespace cereal
OutputArchive<XMLOutputArchive>(this),
itsStream(stream),
itsOutputType( options.itsOutputType ),
- itsIndent( options.itsIndent )
+ itsIndent( options.itsIndent ),
+ itsSizeAttributes(options.itsSizeAttributes)
{
// rapidxml will delete all allocations when xml_document is cleared
auto node = itsXML.allocate_node( rapidxml::node_declaration );
@@ -182,7 +210,7 @@ namespace cereal
itsNodes.top().node->append_attribute( itsXML.allocate_attribute( "type", "cereal binary data" ) );
finishNode();
- };
+ }
//! @}
/*! @name Internal Functionality
@@ -289,6 +317,8 @@ namespace cereal
itsNodes.top().node->append_attribute( itsXML.allocate_attribute( namePtr, valuePtr ) );
}
+ bool hasSizeAttributes() const { return itsSizeAttributes; }
+
protected:
//! A struct that contains metadata about a node
struct NodeInfo
@@ -330,6 +360,7 @@ namespace cereal
std::ostringstream itsOS; //!< Used to format strings internally
bool itsOutputType; //!< Controls whether type information is printed
bool itsIndent; //!< Controls whether indenting is used
+ bool itsSizeAttributes; //!< Controls whether lists have a size attribute
}; // XMLOutputArchive
// ######################################################################
@@ -436,7 +467,7 @@ namespace cereal
std::memcpy( data, decoded.data(), decoded.size() );
finishNode();
- };
+ }
//! @}
/*! @name Internal Functionality
@@ -759,12 +790,40 @@ namespace cereal
{ }
// ######################################################################
+ //! Prologue for deferred data for XML archives
+ /*! Do nothing for the defer wrapper */
+ template <class T> inline
+ void prologue( XMLOutputArchive &, DeferredData<T> const & )
+ { }
+
+ //! Prologue for deferred data for XML archives
+ template <class T> inline
+ void prologue( XMLInputArchive &, DeferredData<T> const & )
+ { }
+
+ // ######################################################################
+ //! Epilogue for deferred for XML archives
+ /*! NVPs do not start or finish nodes - they just set up the names */
+ template <class T> inline
+ void epilogue( XMLOutputArchive &, DeferredData<T> const & )
+ { }
+
+ //! Epilogue for deferred for XML archives
+ /*! Do nothing for the defer wrapper */
+ template <class T> inline
+ void epilogue( XMLInputArchive &, DeferredData<T> const & )
+ { }
+
+ // ######################################################################
//! Prologue for SizeTags for XML output archives
/*! SizeTags do not start or finish nodes */
template <class T> inline
void prologue( XMLOutputArchive & ar, SizeTag<T> const & )
{
- ar.appendAttribute( "size", "dynamic" );
+ if (ar.hasSizeAttributes())
+ {
+ ar.appendAttribute("size", "dynamic");
+ }
}
template <class T> inline
diff --git a/source/code/Libs/include/cereal/cereal.hpp b/source/code/Libs/include/cereal/cereal.hpp
index a777010..50a76ee 100644
--- a/source/code/Libs/include/cereal/cereal.hpp
+++ b/source/code/Libs/include/cereal/cereal.hpp
@@ -32,6 +32,7 @@
#include <type_traits>
#include <string>
#include <memory>
+#include <functional>
#include <unordered_map>
#include <unordered_set>
#include <vector>
@@ -98,6 +99,59 @@ namespace cereal
}
// ######################################################################
+ //! Marks data for deferred serialization
+ /*! cereal performs a recursive depth-first traversal of data it serializes. When
+ serializing smart pointers to large, nested, or cyclical data structures, it
+ is possible to encounter a stack overflow from excessive recursion when following
+ a chain of pointers.
+
+ Deferment can help in these situations if the data can be serialized separately from
+ the pointers used to traverse the structure. For example, a graph structure can have its
+ nodes serialized before its edges:
+
+ @code{.cpp}
+ struct MyEdge
+ {
+ std::shared_ptr<MyNode> connection;
+ int some_value;
+
+ template<class Archive>
+ void serialize(Archive & archive)
+ {
+ // when we serialize an edge, we'll defer serializing the associated node
+ archive( cereal::defer( connection ),
+ some_value );
+ }
+ };
+
+ struct MyGraphStructure
+ {
+ std::vector<MyEdge> edges;
+ std::vector<MyNodes> nodes;
+
+ template<class Archive>
+ void serialize(Archive & archive)
+ {
+ // because of the deferment, we ensure all nodes are fully serialized
+ // before any connection pointers to those nodes are serialized
+ archive( edges, nodes );
+
+ // we have to explicitly inform the archive when it is safe to serialize
+ // the deferred data
+ archive.serializeDeferments();
+ }
+ };
+ @endcode
+
+ @relates DeferredData
+ @ingroup Utility */
+ template <class T> inline
+ DeferredData<T> defer( T && value )
+ {
+ return {std::forward<T>(value)};
+ }
+
+ // ######################################################################
//! Called before a type is serialized to set up any special archive state
//! for processing some type
/*! If designing a serializer that needs to set up any kind of special
@@ -145,6 +199,14 @@ namespace cereal
instantiate_polymorphic_binding( T*, Archive*, BindingTag, adl_tag ); \
} } /* end namespaces */
+ //! Helper macro to omit unused warning
+ #if defined(__GNUC__)
+ // GCC / clang don't want the function
+ #define CEREAL_UNUSED_FUNCTION
+ #else
+ #define CEREAL_UNUSED_FUNCTION static void unused() { (void)version; }
+ #endif
+
// ######################################################################
//! Defines a class version for some type
/*! Versioning information is optional and adds some small amount of
@@ -207,7 +269,7 @@ namespace cereal
std::type_index(typeid(TYPE)).hash_code(), VERSION_NUMBER ); \
return VERSION_NUMBER; \
} \
- static void unused() { (void)version; } \
+ CEREAL_UNUSED_FUNCTION \
}; /* end Version */ \
const std::uint32_t Version<TYPE>::version = \
Version<TYPE>::registerVersion(); \
@@ -250,6 +312,14 @@ namespace cereal
return *self;
}
+ //! Serializes any data marked for deferment using defer
+ /*! This will cause any data wrapped in DeferredData to be immediately serialized */
+ void serializeDeferments()
+ {
+ for( auto & deferment : itsDeferments )
+ deferment();
+ }
+
/*! @name Boost Transition Layer
Functionality that mirrors the syntax for Boost. This is useful if you are transitioning
a large project from Boost to cereal. The preferred interface for cereal is using operator(). */
@@ -258,14 +328,14 @@ namespace cereal
//! Indicates this archive is not intended for loading
/*! This ensures compatibility with boost archive types. If you are transitioning
from boost, you can check this value within a member or external serialize function
- (i.e., Archive::is_loading::value) to disable behavior specific to loading, until
+ (i.e., Archive::is_loading::value) to disable behavior specific to loading, until
you can transition to split save/load or save_minimal/load_minimal functions */
using is_loading = std::false_type;
//! Indicates this archive is intended for saving
/*! This ensures compatibility with boost archive types. If you are transitioning
from boost, you can check this value within a member or external serialize function
- (i.e., Archive::is_saving::value) to enable behavior specific to loading, until
+ (i.e., Archive::is_saving::value) to enable behavior specific to loading, until
you can transition to split save/load or save_minimal/load_minimal functions */
using is_saving = std::true_type;
@@ -379,6 +449,17 @@ namespace cereal
return *self;
}
+ std::vector<std::function<void(void)>> itsDeferments;
+
+ template <class T> inline
+ ArchiveType & processImpl(DeferredData<T> const & d)
+ {
+ std::function<void(void)> deferment( [=](){ self->process( d.value ); } );
+ itsDeferments.emplace_back( std::move(deferment) );
+
+ return *self;
+ }
+
//! Helper macro that expands the requirements for activating an overload
/*! Requirements:
Has the requested serialization function
@@ -483,8 +564,7 @@ namespace cereal
/*! If this is the first time this class has been serialized, we will record its
version number and serialize that.
- @tparam T The type of the class being serialized
- @param version The version number associated with it */
+ @tparam T The type of the class being serialized */
template <class T> inline
std::uint32_t registerClassVersion()
{
@@ -620,6 +700,14 @@ namespace cereal
return *self;
}
+ //! Serializes any data marked for deferment using defer
+ /*! This will cause any data wrapped in DeferredData to be immediately serialized */
+ void serializeDeferments()
+ {
+ for( auto & deferment : itsDeferments )
+ deferment();
+ }
+
/*! @name Boost Transition Layer
Functionality that mirrors the syntax for Boost. This is useful if you are transitioning
a large project from Boost to cereal. The preferred interface for cereal is using operator(). */
@@ -628,14 +716,14 @@ namespace cereal
//! Indicates this archive is intended for loading
/*! This ensures compatibility with boost archive types. If you are transitioning
from boost, you can check this value within a member or external serialize function
- (i.e., Archive::is_loading::value) to enable behavior specific to loading, until
+ (i.e., Archive::is_loading::value) to enable behavior specific to loading, until
you can transition to split save/load or save_minimal/load_minimal functions */
using is_loading = std::true_type;
//! Indicates this archive is not intended for saving
/*! This ensures compatibility with boost archive types. If you are transitioning
from boost, you can check this value within a member or external serialize function
- (i.e., Archive::is_saving::value) to disable behavior specific to loading, until
+ (i.e., Archive::is_saving::value) to disable behavior specific to loading, until
you can transition to split save/load or save_minimal/load_minimal functions */
using is_saving = std::false_type;
@@ -667,6 +755,7 @@ namespace cereal
/*! This is used to retrieve a previously registered shared_ptr
which has already been loaded.
+ @internal
@param id The unique id that was serialized for the pointer
@return A shared pointer to the data
@throw Exception if the id does not exist */
@@ -685,6 +774,7 @@ namespace cereal
/*! After a shared pointer has been allocated for the first time, it should
be registered with its loaded id for future references to it.
+ @internal
@param id The unique identifier for the shared pointer
@param ptr The actual shared pointer */
inline void registerSharedPointer(std::uint32_t const id, std::shared_ptr<void> ptr)
@@ -697,6 +787,7 @@ namespace cereal
/*! This is used to retrieve a string previously registered during
a polymorphic load.
+ @internal
@param id The unique id that was serialized for the polymorphic type
@return The string identifier for the tyep */
inline std::string getPolymorphicName(std::uint32_t const id)
@@ -713,6 +804,7 @@ namespace cereal
/*! After a polymorphic type has been loaded for the first time, it should
be registered with its loaded id for future references to it.
+ @internal
@param id The unique identifier for the polymorphic type
@param name The name associated with the tyep */
inline void registerPolymorphicName(std::uint32_t const id, std::string const & name)
@@ -762,6 +854,17 @@ namespace cereal
return *self;
}
+ std::vector<std::function<void(void)>> itsDeferments;
+
+ template <class T> inline
+ ArchiveType & processImpl(DeferredData<T> const & d)
+ {
+ std::function<void(void)> deferment( [=](){ self->process( d.value ); } );
+ itsDeferments.emplace_back( std::move(deferment) );
+
+ return *self;
+ }
+
//! Helper macro that expands the requirements for activating an overload
/*! Requirements:
Has the requested serialization function
@@ -875,8 +978,7 @@ namespace cereal
/*! If this is the first time this class has been serialized, we will record its
version number and serialize that.
- @tparam T The type of the class being serialized
- @param version The version number associated with it */
+ @tparam T The type of the class being serialized */
template <class T> inline
std::uint32_t loadClassVersion()
{
diff --git a/source/code/Libs/include/cereal/details/helpers.hpp b/source/code/Libs/include/cereal/details/helpers.hpp
index 9092688..7b4c4ad 100644
--- a/source/code/Libs/include/cereal/details/helpers.hpp
+++ b/source/code/Libs/include/cereal/details/helpers.hpp
@@ -68,8 +68,10 @@ namespace cereal
namespace detail
{
struct NameValuePairCore {}; //!< Traits struct for NVPs
+ struct DeferredDataCore {}; //!< Traits struct for DeferredData
}
+ // ######################################################################
//! For holding name value pairs
/*! This pairs a name (some string) with some value such that an archive
can potentially take advantage of the pairing.
@@ -210,7 +212,7 @@ namespace cereal
{
//! Internally store the pointer as a void *, keeping const if created with
//! a const pointer
- using PT = typename std::conditional<std::is_const<typename std::remove_pointer<T>::type>::value,
+ using PT = typename std::conditional<std::is_const<typename std::remove_pointer<typename std::remove_reference<T>::type>::type>::value,
const void *,
void *>::type;
@@ -221,6 +223,43 @@ namespace cereal
};
// ######################################################################
+ //! A wrapper around data that should be serialized after all non-deferred data
+ /*! This class is used to demarcate data that can only be safely serialized after
+ any data not wrapped in this class.
+
+ @internal */
+ template <class T>
+ class DeferredData : detail::DeferredDataCore
+ {
+ private:
+ // If we get passed an array, keep the type as is, otherwise store
+ // a reference if we were passed an l value reference, else copy the value
+ using Type = typename std::conditional<std::is_array<typename std::remove_reference<T>::type>::value,
+ typename std::remove_cv<T>::type,
+ typename std::conditional<std::is_lvalue_reference<T>::value,
+ T,
+ typename std::decay<T>::type>::type>::type;
+
+ // prevent nested nvps
+ static_assert( !std::is_base_of<detail::DeferredDataCore, T>::value,
+ "Cannot defer DeferredData" );
+
+ DeferredData & operator=( DeferredData const & ) = delete;
+
+ public:
+ //! Constructs a new NameValuePair
+ /*! @param v The value to defer. Ideally this should be an l-value reference so that
+ the value can be both loaded and saved to. If you pass an r-value reference,
+ the DeferredData will store a copy of it instead of a reference. Thus you should
+ only pass r-values in cases where this makes sense, such as the result of some
+ size() call.
+ @internal */
+ DeferredData( T && v ) : value(std::forward<T>(v)) {}
+
+ Type value;
+ };
+
+ // ######################################################################
namespace detail
{
// base classes for type checking
@@ -256,7 +295,7 @@ namespace cereal
struct adl_tag;
// used during saving pointers
- static const int32_t msb_32bit = 0x80000000;
+ static const uint32_t msb_32bit = 0x80000000;
static const int32_t msb2_32bit = 0x40000000;
}
diff --git a/source/code/Libs/include/cereal/details/polymorphic_impl.hpp b/source/code/Libs/include/cereal/details/polymorphic_impl.hpp
index 81128c8..bee13ab 100644
--- a/source/code/Libs/include/cereal/details/polymorphic_impl.hpp
+++ b/source/code/Libs/include/cereal/details/polymorphic_impl.hpp
@@ -56,6 +56,14 @@
#include <set>
#include <stack>
+//! Helper macro to omit unused warning
+#if defined(__GNUC__)
+ // GCC / clang don't want the function
+ #define CEREAL_BIND_TO_ARCHIVES_UNUSED_FUNCTION
+#else
+ #define CEREAL_BIND_TO_ARCHIVES_UNUSED_FUNCTION static void unused() { (void)b; }
+#endif
+
//! Binds a polymorhic type to all registered archives
/*! This binds a polymorphic type to all compatible registered archives that
have been registered with CEREAL_REGISTER_ARCHIVE. This must be called
@@ -67,7 +75,7 @@
template<> \
struct init_binding<__VA_ARGS__> { \
static bind_to_archives<__VA_ARGS__> const & b; \
- static void unused() { (void)b; } \
+ CEREAL_BIND_TO_ARCHIVES_UNUSED_FUNCTION \
}; \
bind_to_archives<__VA_ARGS__> const & init_binding<__VA_ARGS__>::b = \
::cereal::detail::StaticObject< \
@@ -115,8 +123,10 @@ namespace cereal
all registered mappings between base and derived types. */
struct PolymorphicCasters
{
+ //! Maps from a derived type index to a set of chainable casters
+ using DerivedCasterMap = std::unordered_map<std::type_index, std::vector<PolymorphicCaster const *>>;
//! Maps from base type index to a map from derived type index to caster
- std::map<std::type_index, std::map<std::type_index, std::vector<PolymorphicCaster const*>>> map;
+ std::unordered_map<std::type_index, DerivedCasterMap> map;
std::multimap<std::type_index, std::type_index> reverseMap;
@@ -127,24 +137,26 @@ namespace cereal
"Make sure you either serialize the base class at some point via cereal::base_class or cereal::virtual_base_class.\n" \
"Alternatively, manually register the association with CEREAL_REGISTER_POLYMORPHIC_RELATION.");
- //! Checks if the mapping object that can perform the upcast or downcast
+ //! Checks if the mapping object that can perform the upcast or downcast exists, and returns it if so
/*! Uses the type index from the base and derived class to find the matching
- registered caster. If no matching caster exists, returns false. */
- static bool exists( std::type_index const & baseIndex, std::type_index const & derivedIndex )
+ registered caster. If no matching caster exists, the bool in the pair will be false and the vector
+ reference should not be used. */
+ static std::pair<bool, std::vector<PolymorphicCaster const *> const &>
+ lookup_if_exists( std::type_index const & baseIndex, std::type_index const & derivedIndex )
{
// First phase of lookup - match base type index
auto const & baseMap = StaticObject<PolymorphicCasters>::getInstance().map;
auto baseIter = baseMap.find( baseIndex );
if (baseIter == baseMap.end())
- return false;
+ return {false, {}};
// Second phase - find a match from base to derived
- auto & derivedMap = baseIter->second;
+ auto const & derivedMap = baseIter->second;
auto derivedIter = derivedMap.find( derivedIndex );
if (derivedIter == derivedMap.end())
- return false;
+ return {false, {}};
- return true;
+ return {true, derivedIter->second};
}
//! Gets the mapping object that can perform the upcast or downcast
@@ -162,7 +174,7 @@ namespace cereal
exceptionFunc();
// Second phase - find a match from base to derived
- auto & derivedMap = baseIter->second;
+ auto const & derivedMap = baseIter->second;
auto derivedIter = derivedMap.find( derivedIndex );
if( derivedIter == derivedMap.end() )
exceptionFunc();
@@ -176,8 +188,8 @@ namespace cereal
{
auto const & mapping = lookup( baseInfo, typeid(Derived), [&](){ UNREGISTERED_POLYMORPHIC_CAST_EXCEPTION(save) } );
- for( auto const * map : mapping )
- dptr = map->downcast( dptr );
+ for( auto const * dmap : mapping )
+ dptr = dmap->downcast( dptr );
return static_cast<Derived const *>( dptr );
}
@@ -213,6 +225,14 @@ namespace cereal
#undef UNREGISTERED_POLYMORPHIC_CAST_EXCEPTION
};
+ #ifdef CEREAL_OLDER_GCC
+ #define CEREAL_EMPLACE_MAP(map, key, value) \
+ map.insert( std::make_pair(std::move(key), std::move(value)) );
+ #else // NOT CEREAL_OLDER_GCC
+ #define CEREAL_EMPLACE_MAP(map, key, value) \
+ map.emplace( key, value );
+ #endif // NOT_CEREAL_OLDER_GCC
+
//! Strongly typed derivation of PolymorphicCaster
template <class Base, class Derived>
struct PolymorphicVirtualCaster : PolymorphicCaster
@@ -229,18 +249,16 @@ namespace cereal
// First insert the relation Base->Derived
const auto lock = StaticObject<PolymorphicCasters>::lock();
auto & baseMap = StaticObject<PolymorphicCasters>::getInstance().map;
- auto lb = baseMap.lower_bound(baseKey);
{
- auto & derivedMap = baseMap.insert( lb, {baseKey, {}} )->second;
- auto lbd = derivedMap.lower_bound(derivedKey);
- auto & derivedVec = derivedMap.insert( lbd, { std::move(derivedKey), {}} )->second;
+ auto & derivedMap = baseMap.insert( {baseKey, PolymorphicCasters::DerivedCasterMap{}} ).first->second;
+ auto & derivedVec = derivedMap.insert( {derivedKey, {}} ).first->second;
derivedVec.push_back( this );
}
// Insert reverse relation Derived->Base
auto & reverseMap = StaticObject<PolymorphicCasters>::getInstance().reverseMap;
- reverseMap.insert( {derivedKey, baseKey} );
+ CEREAL_EMPLACE_MAP(reverseMap, derivedKey, baseKey);
// Find all chainable unregistered relations
/* The strategy here is to process only the nodes in the class hierarchy graph that have been
@@ -254,28 +272,40 @@ namespace cereal
// Checks whether there is a path from parent->child and returns a <dist, path> pair
// dist is set to MAX if the path does not exist
auto checkRelation = [](std::type_index const & parentInfo, std::type_index const & childInfo) ->
- std::pair<size_t, std::vector<PolymorphicCaster const *>>
+ std::pair<size_t, std::vector<PolymorphicCaster const *> const &>
{
- if( PolymorphicCasters::exists( parentInfo, childInfo ) )
+ auto result = PolymorphicCasters::lookup_if_exists( parentInfo, childInfo );
+ if( result.first )
{
- auto const & path = PolymorphicCasters::lookup( parentInfo, childInfo, [](){} );
+ auto const & path = result.second;
return {path.size(), path};
}
else
- return {std::numeric_limits<size_t>::max(), {}};
+ return {(std::numeric_limits<size_t>::max)(), {}};
};
- std::stack<std::type_index> parentStack; // Holds the parent nodes to be processed
- std::set<std::type_index> dirtySet; // Marks child nodes that have been changed
- std::set<std::type_index> processedParents; // Marks parent nodes that have been processed
+ std::stack<std::type_index> parentStack; // Holds the parent nodes to be processed
+ std::vector<std::type_index> dirtySet; // Marks child nodes that have been changed
+ std::unordered_set<std::type_index> processedParents; // Marks parent nodes that have been processed
+
+ // Checks if a child has been marked dirty
+ auto isDirty = [&](std::type_index const & c)
+ {
+ auto const dirtySetSize = dirtySet.size();
+ for( size_t i = 0; i < dirtySetSize; ++i )
+ if( dirtySet[i] == c )
+ return true;
+
+ return false;
+ };
// Begin processing the base key and mark derived as dirty
parentStack.push( baseKey );
- dirtySet.insert( derivedKey );
+ dirtySet.emplace_back( derivedKey );
while( !parentStack.empty() )
{
- using Relations = std::multimap<std::type_index, std::pair<std::type_index, std::vector<PolymorphicCaster const *>>>;
+ using Relations = std::unordered_multimap<std::type_index, std::pair<std::type_index, std::vector<PolymorphicCaster const *>>>;
Relations unregisteredRelations; // Defer insertions until after main loop to prevent iterator invalidation
const auto parent = parentStack.top();
@@ -285,7 +315,7 @@ namespace cereal
for( auto const & childPair : baseMap[parent] )
{
const auto child = childPair.first;
- if( dirtySet.count( child ) && baseMap.count( child ) )
+ if( isDirty( child ) && baseMap.count( child ) )
{
auto parentChildPath = checkRelation( parent, child );
@@ -340,11 +370,11 @@ namespace cereal
{
auto & derivedMap = baseMap.find( it.first )->second;
derivedMap[it.second.first] = it.second.second;
- reverseMap.insert( {it.second.first, it.first} );
+ CEREAL_EMPLACE_MAP(reverseMap, it.second.first, it.first );
}
// Mark current parent as modified
- dirtySet.insert( parent );
+ dirtySet.emplace_back( parent );
// Insert all parents of the current parent node that haven't yet been processed
auto parentRange = reverseMap.equal_range( parent );
@@ -361,6 +391,8 @@ namespace cereal
} // end chainable relations
} // end PolymorphicVirtualCaster()
+ #undef CEREAL_EMPLACE_MAP
+
//! Performs the proper downcast with the templated types
void const * downcast( void const * const ptr ) const override
{
diff --git a/source/code/Libs/include/cereal/details/static_object.hpp b/source/code/Libs/include/cereal/details/static_object.hpp
index c9c888d..cd30348 100644
--- a/source/code/Libs/include/cereal/details/static_object.hpp
+++ b/source/code/Libs/include/cereal/details/static_object.hpp
@@ -48,7 +48,7 @@
# define CEREAL_DLL_EXPORT __declspec(dllexport)
# define CEREAL_USED
#else // clang or gcc
-# define CEREAL_DLL_EXPORT
+# define CEREAL_DLL_EXPORT __attribute__ ((visibility("default")))
# define CEREAL_USED __attribute__ ((__used__))
#endif
@@ -67,13 +67,12 @@ namespace cereal
class CEREAL_DLL_EXPORT StaticObject
{
private:
- //! Forces instantiation at pre-execution time
- static void instantiate( T const & ) {}
static T & create()
{
static T t;
- instantiate(instance);
+ //! Forces instantiation at pre-execution time
+ (void)instance;
return t;
}
@@ -95,6 +94,7 @@ namespace cereal
std::unique_lock<std::mutex> lock;
#else
public:
+ LockGuard(LockGuard const &) = default; // prevents implicit copy ctor warning
~LockGuard() CEREAL_NOEXCEPT {} // prevents variable not used
#endif
};
diff --git a/source/code/Libs/include/cereal/details/traits.hpp b/source/code/Libs/include/cereal/details/traits.hpp
index 3390bbd..06fe424 100644
--- a/source/code/Libs/include/cereal/details/traits.hpp
+++ b/source/code/Libs/include/cereal/details/traits.hpp
@@ -800,6 +800,18 @@ namespace cereal
See notes from member load_minimal implementation.
+ Note that there should be an additional const check on load_minimal after the valid check,
+ but this currently interferes with many valid uses of minimal serialization. It has been
+ removed (see #565 on github) and previously was:
+
+ @code
+ static_assert( check::const_valid || !check::exists,
+ "cereal detected an invalid serialization type parameter in non-member " #test_name ". "
+ #test_name " non-member functions must accept their serialization type by non-const reference" );
+ @endcode
+
+ See #132, #436, #263, and #565 on https://github.com/USCiLab/cereal for more details.
+
@param test_name The name to give the test (e.g. load_minimal or versioned_load_minimal)
@param save_name The corresponding name the save test would have (e.g. save_minimal or versioned_save_minimal)
@param versioned Either blank or the macro CEREAL_MAKE_VERSIONED_TEST */
@@ -847,9 +859,6 @@ namespace cereal
static_assert( check::valid || !check::exists, "cereal detected different types in corresponding non-member " \
#test_name " and " #save_name " functions. \n " \
"the paramater to " #test_name " must be a constant reference to the type that " #save_name " returns." ); \
- static_assert( check::const_valid || !check::exists, \
- "cereal detected an invalid serialization type parameter in non-member " #test_name ". " \
- #test_name " non-member functions must accept their serialization type by non-const reference" ); \
}; \
} /* namespace detail */ \
\
@@ -869,17 +878,29 @@ namespace cereal
#undef CEREAL_MAKE_HAS_NON_MEMBER_LOAD_MINIMAL_TEST
// ######################################################################
+ namespace detail
+ {
+ // const stripped away before reaching here, prevents errors on conversion from
+ // construct<const T> to construct<T>
+ template<typename T, typename A>
+ struct has_member_load_and_construct_impl : std::integral_constant<bool,
+ std::is_same<decltype( access::load_and_construct<T>( std::declval<A&>(), std::declval< ::cereal::construct<T>&>() ) ), void>::value>
+ { };
+
+ template<typename T, typename A>
+ struct has_member_versioned_load_and_construct_impl : std::integral_constant<bool,
+ std::is_same<decltype( access::load_and_construct<T>( std::declval<A&>(), std::declval< ::cereal::construct<T>&>(), 0 ) ), void>::value>
+ { };
+ } // namespace detail
+
//! Member load and construct check
template<typename T, typename A>
- struct has_member_load_and_construct : std::integral_constant<bool,
- std::is_same<decltype( access::load_and_construct<T>( std::declval<A&>(), std::declval< ::cereal::construct<T>&>() ) ), void>::value>
+ struct has_member_load_and_construct : detail::has_member_load_and_construct_impl<typename std::remove_const<T>::type, A>
{ };
- // ######################################################################
//! Member load and construct check (versioned)
template<typename T, typename A>
- struct has_member_versioned_load_and_construct : std::integral_constant<bool,
- std::is_same<decltype( access::load_and_construct<T>( std::declval<A&>(), std::declval< ::cereal::construct<T>&>(), 0 ) ), void>::value>
+ struct has_member_versioned_load_and_construct : detail::has_member_versioned_load_and_construct_impl<typename std::remove_const<T>::type, A>
{ };
// ######################################################################
@@ -901,7 +922,8 @@ namespace cereal
}; \
} /* end namespace detail */ \
template <class T, class A> \
- struct has_non_member_##test_name : std::integral_constant<bool, detail::has_non_member_##test_name##_impl<T, A>::value> {};
+ struct has_non_member_##test_name : \
+ std::integral_constant<bool, detail::has_non_member_##test_name##_impl<typename std::remove_const<T>::type, A>::value> {};
// ######################################################################
//! Non member load and construct check
diff --git a/source/code/Libs/include/cereal/external/base64.hpp b/source/code/Libs/include/cereal/external/base64.hpp
index 7eee003..ce32324 100644
--- a/source/code/Libs/include/cereal/external/base64.hpp
+++ b/source/code/Libs/include/cereal/external/base64.hpp
@@ -25,6 +25,11 @@
#ifndef CEREAL_EXTERNAL_BASE64_HPP_
#define CEREAL_EXTERNAL_BASE64_HPP_
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+
#include <string>
namespace cereal
@@ -123,5 +128,7 @@ namespace cereal
}
} // namespace base64
} // namespace cereal
-
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
#endif // CEREAL_EXTERNAL_BASE64_HPP_
diff --git a/source/code/Libs/include/cereal/external/rapidjson/allocators.h b/source/code/Libs/include/cereal/external/rapidjson/allocators.h
index 554dc4a..d375e28 100644
--- a/source/code/Libs/include/cereal/external/rapidjson/allocators.h
+++ b/source/code/Libs/include/cereal/external/rapidjson/allocators.h
@@ -52,6 +52,19 @@ concept Allocator {
\endcode
*/
+
+/*! \def CEREAL_RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY
+ \ingroup CEREAL_RAPIDJSON_CONFIG
+ \brief User-defined kDefaultChunkCapacity definition.
+
+ User can define this as any \c size that is a power of 2.
+*/
+
+#ifndef CEREAL_RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY
+#define CEREAL_RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY (64 * 1024)
+#endif
+
+
///////////////////////////////////////////////////////////////////////////////
// CrtAllocator
@@ -236,7 +249,7 @@ private:
*/
bool AddChunk(size_t capacity) {
if (!baseAllocator_)
- ownBaseAllocator_ = baseAllocator_ = CEREAL_RAPIDJSON_NEW(BaseAllocator());
+ ownBaseAllocator_ = baseAllocator_ = CEREAL_RAPIDJSON_NEW(BaseAllocator)();
if (ChunkHeader* chunk = reinterpret_cast<ChunkHeader*>(baseAllocator_->Malloc(CEREAL_RAPIDJSON_ALIGN(sizeof(ChunkHeader)) + capacity))) {
chunk->capacity = capacity;
chunk->size = 0;
@@ -248,7 +261,7 @@ private:
return false;
}
- static const int kDefaultChunkCapacity = 64 * 1024; //!< Default chunk capacity.
+ static const int kDefaultChunkCapacity = CEREAL_RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY; //!< Default chunk capacity.
//! Chunk header for perpending to each chunk.
/*! Chunks are stored as a singly linked list.
diff --git a/source/code/Libs/include/cereal/external/rapidjson/cursorstreamwrapper.h b/source/code/Libs/include/cereal/external/rapidjson/cursorstreamwrapper.h
new file mode 100644
index 0000000..f3d20f7
--- /dev/null
+++ b/source/code/Libs/include/cereal/external/rapidjson/cursorstreamwrapper.h
@@ -0,0 +1,78 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef CEREAL_RAPIDJSON_CURSORSTREAMWRAPPER_H_
+#define CEREAL_RAPIDJSON_CURSORSTREAMWRAPPER_H_
+
+#include "stream.h"
+
+#if defined(__GNUC__)
+CEREAL_RAPIDJSON_DIAG_PUSH
+CEREAL_RAPIDJSON_DIAG_OFF(effc++)
+#endif
+
+#if defined(_MSC_VER) && _MSC_VER <= 1800
+CEREAL_RAPIDJSON_DIAG_PUSH
+CEREAL_RAPIDJSON_DIAG_OFF(4702) // unreachable code
+CEREAL_RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated
+#endif
+
+CEREAL_RAPIDJSON_NAMESPACE_BEGIN
+
+
+//! Cursor stream wrapper for counting line and column number if error exists.
+/*!
+ \tparam InputStream Any stream that implements Stream Concept
+*/
+template <typename InputStream, typename Encoding = UTF8<> >
+class CursorStreamWrapper : public GenericStreamWrapper<InputStream, Encoding> {
+public:
+ typedef typename Encoding::Ch Ch;
+
+ CursorStreamWrapper(InputStream& is):
+ GenericStreamWrapper<InputStream, Encoding>(is), line_(1), col_(0) {}
+
+ // counting line and column number
+ Ch Take() {
+ Ch ch = this->is_.Take();
+ if(ch == '\n') {
+ line_ ++;
+ col_ = 0;
+ } else {
+ col_ ++;
+ }
+ return ch;
+ }
+
+ //! Get the error line number, if error exists.
+ size_t GetLine() const { return line_; }
+ //! Get the error column number, if error exists.
+ size_t GetColumn() const { return col_; }
+
+private:
+ size_t line_; //!< Current Line
+ size_t col_; //!< Current Column
+};
+
+#if defined(_MSC_VER) && _MSC_VER <= 1800
+CEREAL_RAPIDJSON_DIAG_POP
+#endif
+
+#if defined(__GNUC__)
+CEREAL_RAPIDJSON_DIAG_POP
+#endif
+
+CEREAL_RAPIDJSON_NAMESPACE_END
+
+#endif // CEREAL_RAPIDJSON_CURSORSTREAMWRAPPER_H_
diff --git a/source/code/Libs/include/cereal/external/rapidjson/document.h b/source/code/Libs/include/cereal/external/rapidjson/document.h
index 46faeb1..ca6da63 100644
--- a/source/code/Libs/include/cereal/external/rapidjson/document.h
+++ b/source/code/Libs/include/cereal/external/rapidjson/document.h
@@ -1,5 +1,5 @@
// Tencent is pleased to support the open source community by making RapidJSON available.
-//
+//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
@@ -7,9 +7,9 @@
//
// http://opensource.org/licenses/MIT
//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
// specific language governing permissions and limitations under the License.
#ifndef CEREAL_RAPIDJSON_DOCUMENT_H_
@@ -26,26 +26,21 @@
#include <limits>
CEREAL_RAPIDJSON_DIAG_PUSH
-#ifdef _MSC_VER
-CEREAL_RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant
-CEREAL_RAPIDJSON_DIAG_OFF(4244) // conversion from kXxxFlags to 'uint16_t', possible loss of data
-#endif
-
#ifdef __clang__
CEREAL_RAPIDJSON_DIAG_OFF(padded)
CEREAL_RAPIDJSON_DIAG_OFF(switch-enum)
CEREAL_RAPIDJSON_DIAG_OFF(c++98-compat)
+#elif defined(_MSC_VER)
+CEREAL_RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant
+CEREAL_RAPIDJSON_DIAG_OFF(4244) // conversion from kXxxFlags to 'uint16_t', possible loss of data
#endif
#ifdef __GNUC__
CEREAL_RAPIDJSON_DIAG_OFF(effc++)
-#if __GNUC__ >= 6
-CEREAL_RAPIDJSON_DIAG_OFF(terminate) // ignore throwing CEREAL_RAPIDJSON_ASSERT in CEREAL_RAPIDJSON_NOEXCEPT functions
-#endif
#endif // __GNUC__
#ifndef CEREAL_RAPIDJSON_NOMEMBERITERATORCLASS
-#include <iterator> // std::iterator, std::random_access_iterator_tag
+#include <iterator> // std::random_access_iterator_tag
#endif
#if CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS
@@ -67,10 +62,16 @@ class GenericDocument;
But a compiler (IBM XL C/C++ for AIX) have reported to have problem with that so it moved as a namespace scope struct.
https://code.google.com/p/rapidjson/issues/detail?id=64
*/
-template <typename Encoding, typename Allocator>
-struct GenericMember {
+template <typename Encoding, typename Allocator>
+struct GenericMember {
GenericValue<Encoding, Allocator> name; //!< name of member (must be a string)
GenericValue<Encoding, Allocator> value; //!< value of member.
+
+ // swap() for std::sort() and other potential use in STL.
+ friend inline void swap(GenericMember& a, GenericMember& b) CEREAL_RAPIDJSON_NOEXCEPT {
+ a.name.Swap(b.name);
+ a.value.Swap(b.value);
+ }
};
///////////////////////////////////////////////////////////////////////////////
@@ -98,16 +99,13 @@ struct GenericMember {
\see GenericMember, GenericValue::MemberIterator, GenericValue::ConstMemberIterator
*/
template <bool Const, typename Encoding, typename Allocator>
-class GenericMemberIterator
- : public std::iterator<std::random_access_iterator_tag
- , typename internal::MaybeAddConst<Const,GenericMember<Encoding,Allocator> >::Type> {
+class GenericMemberIterator {
friend class GenericValue<Encoding,Allocator>;
template <bool, typename, typename> friend class GenericMemberIterator;
typedef GenericMember<Encoding,Allocator> PlainType;
typedef typename internal::MaybeAddConst<Const,PlainType>::Type ValueType;
- typedef std::iterator<std::random_access_iterator_tag,ValueType> BaseType;
public:
//! Iterator type itself
@@ -117,12 +115,21 @@ public:
//! Non-constant iterator type
typedef GenericMemberIterator<false,Encoding,Allocator> NonConstIterator;
+ /** \name std::iterator_traits support */
+ //@{
+ typedef ValueType value_type;
+ typedef ValueType * pointer;
+ typedef ValueType & reference;
+ typedef std::ptrdiff_t difference_type;
+ typedef std::random_access_iterator_tag iterator_category;
+ //@}
+
//! Pointer to (const) GenericMember
- typedef typename BaseType::pointer Pointer;
+ typedef pointer Pointer;
//! Reference to (const) GenericMember
- typedef typename BaseType::reference Reference;
+ typedef reference Reference;
//! Signed integer type (e.g. \c ptrdiff_t)
- typedef typename BaseType::difference_type DifferenceType;
+ typedef difference_type DifferenceType;
//! Default constructor (singular value)
/*! Creates an iterator pointing to no element.
@@ -198,17 +205,17 @@ private:
// class-based member iterator implementation disabled, use plain pointers
template <bool Const, typename Encoding, typename Allocator>
-struct GenericMemberIterator;
+class GenericMemberIterator;
//! non-const GenericMemberIterator
template <typename Encoding, typename Allocator>
-struct GenericMemberIterator<false,Encoding,Allocator> {
+class GenericMemberIterator<false,Encoding,Allocator> {
//! use plain pointer as iterator type
typedef GenericMember<Encoding,Allocator>* Iterator;
};
//! const GenericMemberIterator
template <typename Encoding, typename Allocator>
-struct GenericMemberIterator<true,Encoding,Allocator> {
+class GenericMemberIterator<true,Encoding,Allocator> {
//! use plain const pointer as iterator type
typedef const GenericMember<Encoding,Allocator>* Iterator;
};
@@ -300,7 +307,7 @@ struct GenericStringRef {
*/
#endif
explicit GenericStringRef(const CharType* str)
- : s(str), length(internal::StrLen(str)){ CEREAL_RAPIDJSON_ASSERT(s != 0); }
+ : s(str), length(NotNullStrLen(str)) {}
//! Create constant string reference from pointer and length
#ifndef __clang__ // -Wdocumentation
@@ -312,12 +319,10 @@ struct GenericStringRef {
*/
#endif
GenericStringRef(const CharType* str, SizeType len)
- : s(str), length(len) { CEREAL_RAPIDJSON_ASSERT(s != 0); }
+ : s(CEREAL_RAPIDJSON_LIKELY(str) ? str : emptyString), length(len) { CEREAL_RAPIDJSON_ASSERT(str != 0 || len == 0u); }
GenericStringRef(const GenericStringRef& rhs) : s(rhs.s), length(rhs.length) {}
- GenericStringRef& operator=(const GenericStringRef& rhs) { s = rhs.s; length = rhs.length; }
-
//! implicit conversion to plain CharType pointer
operator const Ch *() const { return s; }
@@ -325,11 +330,24 @@ struct GenericStringRef {
const SizeType length; //!< length of the string (excluding the trailing NULL terminator)
private:
+ SizeType NotNullStrLen(const CharType* str) {
+ CEREAL_RAPIDJSON_ASSERT(str != 0);
+ return internal::StrLen(str);
+ }
+
+ /// Empty string - used when passing in a NULL pointer
+ static const Ch emptyString[];
+
//! Disallow construction from non-const array
template<SizeType N>
GenericStringRef(CharType (&str)[N]) /* = delete */;
+ //! Copy assignment operator not permitted - immutable type
+ GenericStringRef& operator=(const GenericStringRef& rhs) /* = delete */;
};
+template<typename CharType>
+const CharType GenericStringRef<CharType>::emptyString[] = { CharType() };
+
//! Mark a character pointer as constant string
/*! Mark a plain character pointer as a "string literal". This function
can be used to avoid copying a character string to be referenced as a
@@ -344,7 +362,7 @@ private:
*/
template<typename CharType>
inline GenericStringRef<CharType> StringRef(const CharType* str) {
- return GenericStringRef<CharType>(str, internal::StrLen(str));
+ return GenericStringRef<CharType>(str);
}
//! Mark a character pointer as constant string
@@ -410,7 +428,7 @@ namespace internal {
template <typename ValueType, typename T>
struct TypeHelper {};
-template<typename ValueType>
+template<typename ValueType>
struct TypeHelper<ValueType, bool> {
static bool Is(const ValueType& v) { return v.IsBool(); }
static bool Get(const ValueType& v) { return v.GetBool(); }
@@ -418,7 +436,7 @@ struct TypeHelper<ValueType, bool> {
static ValueType& Set(ValueType& v, bool data, typename ValueType::AllocatorType&) { return v.SetBool(data); }
};
-template<typename ValueType>
+template<typename ValueType>
struct TypeHelper<ValueType, int> {
static bool Is(const ValueType& v) { return v.IsInt(); }
static int Get(const ValueType& v) { return v.GetInt(); }
@@ -426,7 +444,7 @@ struct TypeHelper<ValueType, int> {
static ValueType& Set(ValueType& v, int data, typename ValueType::AllocatorType&) { return v.SetInt(data); }
};
-template<typename ValueType>
+template<typename ValueType>
struct TypeHelper<ValueType, unsigned> {
static bool Is(const ValueType& v) { return v.IsUint(); }
static unsigned Get(const ValueType& v) { return v.GetUint(); }
@@ -434,7 +452,27 @@ struct TypeHelper<ValueType, unsigned> {
static ValueType& Set(ValueType& v, unsigned data, typename ValueType::AllocatorType&) { return v.SetUint(data); }
};
-template<typename ValueType>
+#ifdef _MSC_VER
+CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(long) == sizeof(int));
+template<typename ValueType>
+struct TypeHelper<ValueType, long> {
+ static bool Is(const ValueType& v) { return v.IsInt(); }
+ static long Get(const ValueType& v) { return v.GetInt(); }
+ static ValueType& Set(ValueType& v, long data) { return v.SetInt(data); }
+ static ValueType& Set(ValueType& v, long data, typename ValueType::AllocatorType&) { return v.SetInt(data); }
+};
+
+CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(unsigned long) == sizeof(unsigned));
+template<typename ValueType>
+struct TypeHelper<ValueType, unsigned long> {
+ static bool Is(const ValueType& v) { return v.IsUint(); }
+ static unsigned long Get(const ValueType& v) { return v.GetUint(); }
+ static ValueType& Set(ValueType& v, unsigned long data) { return v.SetUint(data); }
+ static ValueType& Set(ValueType& v, unsigned long data, typename ValueType::AllocatorType&) { return v.SetUint(data); }
+};
+#endif
+
+template<typename ValueType>
struct TypeHelper<ValueType, int64_t> {
static bool Is(const ValueType& v) { return v.IsInt64(); }
static int64_t Get(const ValueType& v) { return v.GetInt64(); }
@@ -442,7 +480,7 @@ struct TypeHelper<ValueType, int64_t> {
static ValueType& Set(ValueType& v, int64_t data, typename ValueType::AllocatorType&) { return v.SetInt64(data); }
};
-template<typename ValueType>
+template<typename ValueType>
struct TypeHelper<ValueType, uint64_t> {
static bool Is(const ValueType& v) { return v.IsUint64(); }
static uint64_t Get(const ValueType& v) { return v.GetUint64(); }
@@ -450,7 +488,7 @@ struct TypeHelper<ValueType, uint64_t> {
static ValueType& Set(ValueType& v, uint64_t data, typename ValueType::AllocatorType&) { return v.SetUint64(data); }
};
-template<typename ValueType>
+template<typename ValueType>
struct TypeHelper<ValueType, double> {
static bool Is(const ValueType& v) { return v.IsDouble(); }
static double Get(const ValueType& v) { return v.GetDouble(); }
@@ -458,7 +496,7 @@ struct TypeHelper<ValueType, double> {
static ValueType& Set(ValueType& v, double data, typename ValueType::AllocatorType&) { return v.SetDouble(data); }
};
-template<typename ValueType>
+template<typename ValueType>
struct TypeHelper<ValueType, float> {
static bool Is(const ValueType& v) { return v.IsFloat(); }
static float Get(const ValueType& v) { return v.GetFloat(); }
@@ -466,7 +504,7 @@ struct TypeHelper<ValueType, float> {
static ValueType& Set(ValueType& v, float data, typename ValueType::AllocatorType&) { return v.SetFloat(data); }
};
-template<typename ValueType>
+template<typename ValueType>
struct TypeHelper<ValueType, const typename ValueType::Ch*> {
typedef const typename ValueType::Ch* StringType;
static bool Is(const ValueType& v) { return v.IsString(); }
@@ -476,7 +514,7 @@ struct TypeHelper<ValueType, const typename ValueType::Ch*> {
};
#if CEREAL_RAPIDJSON_HAS_STDSTRING
-template<typename ValueType>
+template<typename ValueType>
struct TypeHelper<ValueType, std::basic_string<typename ValueType::Ch> > {
typedef std::basic_string<typename ValueType::Ch> StringType;
static bool Is(const ValueType& v) { return v.IsString(); }
@@ -485,7 +523,7 @@ struct TypeHelper<ValueType, std::basic_string<typename ValueType::Ch> > {
};
#endif
-template<typename ValueType>
+template<typename ValueType>
struct TypeHelper<ValueType, typename ValueType::Array> {
typedef typename ValueType::Array ArrayType;
static bool Is(const ValueType& v) { return v.IsArray(); }
@@ -494,23 +532,23 @@ struct TypeHelper<ValueType, typename ValueType::Array> {
static ValueType& Set(ValueType& v, ArrayType data, typename ValueType::AllocatorType&) { return v = data; }
};
-template<typename ValueType>
+template<typename ValueType>
struct TypeHelper<ValueType, typename ValueType::ConstArray> {
typedef typename ValueType::ConstArray ArrayType;
static bool Is(const ValueType& v) { return v.IsArray(); }
static ArrayType Get(const ValueType& v) { return v.GetArray(); }
};
-template<typename ValueType>
+template<typename ValueType>
struct TypeHelper<ValueType, typename ValueType::Object> {
typedef typename ValueType::Object ObjectType;
static bool Is(const ValueType& v) { return v.IsObject(); }
static ObjectType Get(ValueType& v) { return v.GetObject(); }
static ValueType& Set(ValueType& v, ObjectType data) { return v = data; }
- static ValueType& Set(ValueType& v, ObjectType data, typename ValueType::AllocatorType&) { v = data; }
+ static ValueType& Set(ValueType& v, ObjectType data, typename ValueType::AllocatorType&) { return v = data; }
};
-template<typename ValueType>
+template<typename ValueType>
struct TypeHelper<ValueType, typename ValueType::ConstObject> {
typedef typename ValueType::ConstObject ObjectType;
static bool Is(const ValueType& v) { return v.IsObject(); }
@@ -536,7 +574,7 @@ template <bool, typename> class GenericObject;
\tparam Encoding Encoding of the value. (Even non-string values need to have the same encoding in a document)
\tparam Allocator Allocator type for allocating memory of object, array and string.
*/
-template <typename Encoding, typename Allocator = MemoryPoolAllocator<> >
+template <typename Encoding, typename Allocator = MemoryPoolAllocator<> >
class GenericValue {
public:
//! Name-value pair in an object.
@@ -590,11 +628,11 @@ public:
\note Default content for number is zero.
*/
explicit GenericValue(Type type) CEREAL_RAPIDJSON_NOEXCEPT : data_() {
- static const uint16_t defaultFlags[7] = {
+ static const uint16_t defaultFlags[] = {
kNullFlag, kFalseFlag, kTrueFlag, kObjectFlag, kArrayFlag, kShortStringFlag,
kNumberAnyFlag
};
- CEREAL_RAPIDJSON_ASSERT(type <= kNumberType);
+ CEREAL_RAPIDJSON_NOEXCEPT_ASSERT(type >= kNullType && type <= kNumberType);
data_.f.flags = defaultFlags[type];
// Use ShortString to store empty string.
@@ -607,10 +645,50 @@ public:
\tparam SourceAllocator allocator of \c rhs
\param rhs Value to copy from (read-only)
\param allocator Allocator for allocating copied elements and buffers. Commonly use GenericDocument::GetAllocator().
+ \param copyConstStrings Force copying of constant strings (e.g. referencing an in-situ buffer)
\see CopyFrom()
*/
- template< typename SourceAllocator >
- GenericValue(const GenericValue<Encoding, SourceAllocator>& rhs, Allocator & allocator);
+ template <typename SourceAllocator>
+ GenericValue(const GenericValue<Encoding,SourceAllocator>& rhs, Allocator& allocator, bool copyConstStrings = false) {
+ switch (rhs.GetType()) {
+ case kObjectType: {
+ SizeType count = rhs.data_.o.size;
+ Member* lm = reinterpret_cast<Member*>(allocator.Malloc(count * sizeof(Member)));
+ const typename GenericValue<Encoding,SourceAllocator>::Member* rm = rhs.GetMembersPointer();
+ for (SizeType i = 0; i < count; i++) {
+ new (&lm[i].name) GenericValue(rm[i].name, allocator, copyConstStrings);
+ new (&lm[i].value) GenericValue(rm[i].value, allocator, copyConstStrings);
+ }
+ data_.f.flags = kObjectFlag;
+ data_.o.size = data_.o.capacity = count;
+ SetMembersPointer(lm);
+ }
+ break;
+ case kArrayType: {
+ SizeType count = rhs.data_.a.size;
+ GenericValue* le = reinterpret_cast<GenericValue*>(allocator.Malloc(count * sizeof(GenericValue)));
+ const GenericValue<Encoding,SourceAllocator>* re = rhs.GetElementsPointer();
+ for (SizeType i = 0; i < count; i++)
+ new (&le[i]) GenericValue(re[i], allocator, copyConstStrings);
+ data_.f.flags = kArrayFlag;
+ data_.a.size = data_.a.capacity = count;
+ SetElementsPointer(le);
+ }
+ break;
+ case kStringType:
+ if (rhs.data_.f.flags == kConstStringFlag && !copyConstStrings) {
+ data_.f.flags = rhs.data_.f.flags;
+ data_ = *reinterpret_cast<const Data*>(&rhs.data_);
+ }
+ else
+ SetStringRaw(StringRef(rhs.GetString(), rhs.GetStringLength()), allocator);
+ break;
+ default:
+ data_.f.flags = rhs.data_.f.flags;
+ data_ = *reinterpret_cast<const Data*>(&rhs.data_);
+ break;
+ }
+ }
//! Constructor for boolean value.
/*! \param b Boolean value
@@ -638,7 +716,7 @@ public:
//! Constructor for unsigned value.
explicit GenericValue(unsigned u) CEREAL_RAPIDJSON_NOEXCEPT : data_() {
- data_.n.u64 = u;
+ data_.n.u64 = u;
data_.f.flags = (u & 0x80000000) ? kNumberUintFlag : (kNumberUintFlag | kIntFlag | kInt64Flag);
}
@@ -672,6 +750,9 @@ public:
//! Constructor for double value.
explicit GenericValue(double d) CEREAL_RAPIDJSON_NOEXCEPT : data_() { data_.n.d = d; data_.f.flags = kNumberDoubleFlag; }
+ //! Constructor for float value.
+ explicit GenericValue(float f) CEREAL_RAPIDJSON_NOEXCEPT : data_() { data_.n.d = static_cast<double>(f); data_.f.flags = kNumberDoubleFlag; }
+
//! Constructor for constant string (i.e. do not make a copy of string)
GenericValue(const Ch* s, SizeType length) CEREAL_RAPIDJSON_NOEXCEPT : data_() { SetStringRaw(StringRef(s, length)); }
@@ -753,9 +834,10 @@ public:
/*! \param rhs Source of the assignment. It will become a null value after assignment.
*/
GenericValue& operator=(GenericValue& rhs) CEREAL_RAPIDJSON_NOEXCEPT {
- CEREAL_RAPIDJSON_ASSERT(this != &rhs);
- this->~GenericValue();
- RawAssign(rhs);
+ if (CEREAL_RAPIDJSON_LIKELY(this != &rhs)) {
+ this->~GenericValue();
+ RawAssign(rhs);
+ }
return *this;
}
@@ -800,12 +882,13 @@ public:
\tparam SourceAllocator Allocator type of \c rhs
\param rhs Value to copy from (read-only)
\param allocator Allocator to use for copying
+ \param copyConstStrings Force copying of constant strings (e.g. referencing an in-situ buffer)
*/
template <typename SourceAllocator>
- GenericValue& CopyFrom(const GenericValue<Encoding, SourceAllocator>& rhs, Allocator& allocator) {
+ GenericValue& CopyFrom(const GenericValue<Encoding, SourceAllocator>& rhs, Allocator& allocator, bool copyConstStrings = false) {
CEREAL_RAPIDJSON_ASSERT(static_cast<void*>(this) != static_cast<void const*>(&rhs));
this->~GenericValue();
- new (this) GenericValue(rhs, allocator);
+ new (this) GenericValue(rhs, allocator, copyConstStrings);
return *this;
}
@@ -846,7 +929,7 @@ public:
//! Equal-to operator
/*!
\note If an object contains duplicated named member, comparing equality with any object is always \c false.
- \note Linear time complexity (number of all values in the subtree and total lengths of all strings).
+ \note Complexity is quadratic in Object's member number and linear for the rest (number of all values in the subtree and total lengths of all strings).
*/
template <typename SourceAllocator>
bool operator==(const GenericValue<Encoding, SourceAllocator>& rhs) const {
@@ -857,14 +940,14 @@ public:
switch (GetType()) {
case kObjectType: // Warning: O(n^2) inner-loop
if (data_.o.size != rhs.data_.o.size)
- return false;
+ return false;
for (ConstMemberIterator lhsMemberItr = MemberBegin(); lhsMemberItr != MemberEnd(); ++lhsMemberItr) {
typename RhsType::ConstMemberIterator rhsMemberItr = rhs.FindMember(lhsMemberItr->name);
if (rhsMemberItr == rhs.MemberEnd() || lhsMemberItr->value != rhsMemberItr->value)
return false;
}
return true;
-
+
case kArrayType:
if (data_.a.size != rhs.data_.a.size)
return false;
@@ -955,14 +1038,14 @@ public:
uint64_t u = GetUint64();
volatile double d = static_cast<double>(u);
return (d >= 0.0)
- && (d < static_cast<double>(std::numeric_limits<uint64_t>::max()))
+ && (d < static_cast<double>((std::numeric_limits<uint64_t>::max)()))
&& (u == static_cast<uint64_t>(d));
}
if (IsInt64()) {
int64_t i = GetInt64();
volatile double d = static_cast<double>(i);
- return (d >= static_cast<double>(std::numeric_limits<int64_t>::min()))
- && (d < static_cast<double>(std::numeric_limits<int64_t>::max()))
+ return (d >= static_cast<double>((std::numeric_limits<int64_t>::min)()))
+ && (d < static_cast<double>((std::numeric_limits<int64_t>::max)()))
&& (i == static_cast<int64_t>(d));
}
return true; // double, int, uint are always lossless
@@ -979,8 +1062,8 @@ public:
bool IsLosslessFloat() const {
if (!IsNumber()) return false;
double a = GetDouble();
- if (a < static_cast<double>(-std::numeric_limits<float>::max())
- || a > static_cast<double>(std::numeric_limits<float>::max()))
+ if (a < static_cast<double>(-(std::numeric_limits<float>::max)())
+ || a > static_cast<double>((std::numeric_limits<float>::max)()))
return false;
double b = static_cast<double>(static_cast<float>(a));
return a >= b && a <= b; // Prevent -Wfloat-equal
@@ -1015,6 +1098,9 @@ public:
//! Get the number of members in the object.
SizeType MemberCount() const { CEREAL_RAPIDJSON_ASSERT(IsObject()); return data_.o.size; }
+ //! Get the capacity of object.
+ SizeType MemberCapacity() const { CEREAL_RAPIDJSON_ASSERT(IsObject()); return data_.o.capacity; }
+
//! Check whether the object is empty.
bool ObjectEmpty() const { CEREAL_RAPIDJSON_ASSERT(IsObject()); return data_.o.size == 0; }
@@ -1083,6 +1169,21 @@ public:
/*! \pre IsObject() == true */
MemberIterator MemberEnd() { CEREAL_RAPIDJSON_ASSERT(IsObject()); return MemberIterator(GetMembersPointer() + data_.o.size); }
+ //! Request the object to have enough capacity to store members.
+ /*! \param newCapacity The capacity that the object at least need to have.
+ \param allocator Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().
+ \return The value itself for fluent API.
+ \note Linear time complexity.
+ */
+ GenericValue& MemberReserve(SizeType newCapacity, Allocator &allocator) {
+ CEREAL_RAPIDJSON_ASSERT(IsObject());
+ if (newCapacity > data_.o.capacity) {
+ SetMembersPointer(reinterpret_cast<Member*>(allocator.Realloc(GetMembersPointer(), data_.o.capacity * sizeof(Member), newCapacity * sizeof(Member))));
+ data_.o.capacity = newCapacity;
+ }
+ return *this;
+ }
+
//! Check whether a member exists in the object.
/*!
\param name Member name to be searched.
@@ -1188,17 +1289,8 @@ public:
CEREAL_RAPIDJSON_ASSERT(name.IsString());
ObjectData& o = data_.o;
- if (o.size >= o.capacity) {
- if (o.capacity == 0) {
- o.capacity = kDefaultObjectCapacity;
- SetMembersPointer(reinterpret_cast<Member*>(allocator.Malloc(o.capacity * sizeof(Member))));
- }
- else {
- SizeType oldCapacity = o.capacity;
- o.capacity += (oldCapacity + 1) / 2; // grow by factor 1.5
- SetMembersPointer(reinterpret_cast<Member*>(allocator.Realloc(GetMembersPointer(), oldCapacity * sizeof(Member), o.capacity * sizeof(Member))));
- }
- }
+ if (o.size >= o.capacity)
+ MemberReserve(o.capacity == 0 ? kDefaultObjectCapacity : (o.capacity + (o.capacity + 1) / 2), allocator);
Member* members = GetMembersPointer();
members[o.size].name.RawAssign(name);
members[o.size].value.RawAssign(value);
@@ -1335,7 +1427,7 @@ public:
\note Linear time complexity.
*/
void RemoveAllMembers() {
- CEREAL_RAPIDJSON_ASSERT(IsObject());
+ CEREAL_RAPIDJSON_ASSERT(IsObject());
for (MemberIterator m = MemberBegin(); m != MemberEnd(); ++m)
m->~Member();
data_.o.size = 0;
@@ -1425,7 +1517,7 @@ public:
MemberIterator pos = MemberBegin() + (first - MemberBegin());
for (MemberIterator itr = pos; itr != last; ++itr)
itr->~Member();
- std::memmove(&*pos, &*last, static_cast<size_t>(MemberEnd() - last) * sizeof(Member));
+ std::memmove(static_cast<void*>(&*pos), &*last, static_cast<size_t>(MemberEnd() - last) * sizeof(Member));
data_.o.size -= static_cast<SizeType>(last - first);
return pos;
}
@@ -1481,7 +1573,7 @@ public:
\note Linear time complexity.
*/
void Clear() {
- CEREAL_RAPIDJSON_ASSERT(IsArray());
+ CEREAL_RAPIDJSON_ASSERT(IsArray());
GenericValue* e = GetElementsPointer();
for (GenericValue* v = e; v != e + data_.a.size; ++v)
v->~GenericValue();
@@ -1628,8 +1720,8 @@ public:
CEREAL_RAPIDJSON_ASSERT(last <= End());
ValueIterator pos = Begin() + (first - Begin());
for (ValueIterator itr = pos; itr != last; ++itr)
- itr->~GenericValue();
- std::memmove(pos, last, static_cast<size_t>(End() - last) * sizeof(GenericValue));
+ itr->~GenericValue();
+ std::memmove(static_cast<void*>(pos), last, static_cast<size_t>(End() - last) * sizeof(GenericValue));
data_.a.size -= static_cast<SizeType>(last - first);
return pos;
}
@@ -1671,7 +1763,7 @@ public:
GenericValue& SetInt64(int64_t i64) { this->~GenericValue(); new (this) GenericValue(i64); return *this; }
GenericValue& SetUint64(uint64_t u64) { this->~GenericValue(); new (this) GenericValue(u64); return *this; }
GenericValue& SetDouble(double d) { this->~GenericValue(); new (this) GenericValue(d); return *this; }
- GenericValue& SetFloat(float f) { this->~GenericValue(); new (this) GenericValue(f); return *this; }
+ GenericValue& SetFloat(float f) { this->~GenericValue(); new (this) GenericValue(static_cast<double>(f)); return *this; }
//@}
@@ -1687,7 +1779,7 @@ public:
//! Set this value as a string without copying source string.
/*! This version has better performance with supplied length, and also support string containing null character.
- \param s source string pointer.
+ \param s source string pointer.
\param length The length of source string, excluding the trailing null terminator.
\return The value itself for fluent API.
\post IsString() == true && GetString() == s && GetStringLength() == length
@@ -1704,21 +1796,29 @@ public:
//! Set this value as a string by copying from source string.
/*! This version has better performance with supplied length, and also support string containing null character.
- \param s source string.
+ \param s source string.
\param length The length of source string, excluding the trailing null terminator.
\param allocator Allocator for allocating copied buffer. Commonly use GenericDocument::GetAllocator().
\return The value itself for fluent API.
\post IsString() == true && GetString() != s && strcmp(GetString(),s) == 0 && GetStringLength() == length
*/
- GenericValue& SetString(const Ch* s, SizeType length, Allocator& allocator) { this->~GenericValue(); SetStringRaw(StringRef(s, length), allocator); return *this; }
+ GenericValue& SetString(const Ch* s, SizeType length, Allocator& allocator) { return SetString(StringRef(s, length), allocator); }
//! Set this value as a string by copying from source string.
- /*! \param s source string.
+ /*! \param s source string.
\param allocator Allocator for allocating copied buffer. Commonly use GenericDocument::GetAllocator().
\return The value itself for fluent API.
\post IsString() == true && GetString() != s && strcmp(GetString(),s) == 0 && GetStringLength() == length
*/
- GenericValue& SetString(const Ch* s, Allocator& allocator) { return SetString(s, internal::StrLen(s), allocator); }
+ GenericValue& SetString(const Ch* s, Allocator& allocator) { return SetString(StringRef(s), allocator); }
+
+ //! Set this value as a string by copying from source string.
+ /*! \param s source string reference
+ \param allocator Allocator for allocating copied buffer. Commonly use GenericDocument::GetAllocator().
+ \return The value itself for fluent API.
+ \post IsString() == true && GetString() != s.s && strcmp(GetString(),s) == 0 && GetStringLength() == length
+ */
+ GenericValue& SetString(StringRefType s, Allocator& allocator) { this->~GenericValue(); SetStringRaw(s, allocator); return *this; }
#if CEREAL_RAPIDJSON_HAS_STDSTRING
//! Set this value as a string by copying from source string.
@@ -1728,7 +1828,7 @@ public:
\post IsString() == true && GetString() != s.data() && strcmp(GetString(),s.data() == 0 && GetStringLength() == s.size()
\note Requires the definition of the preprocessor symbol \ref CEREAL_RAPIDJSON_HAS_STDSTRING.
*/
- GenericValue& SetString(const std::basic_string<Ch>& s, Allocator& allocator) { return SetString(s.data(), SizeType(s.size()), allocator); }
+ GenericValue& SetString(const std::basic_string<Ch>& s, Allocator& allocator) { return SetString(StringRef(s), allocator); }
#endif
//@}
@@ -1790,10 +1890,10 @@ public:
if (CEREAL_RAPIDJSON_UNLIKELY(!v->Accept(handler)))
return false;
return handler.EndArray(data_.a.size);
-
+
case kStringType:
return handler.String(GetString(), GetStringLength(), (data_.f.flags & kCopyFlag) != 0);
-
+
default:
CEREAL_RAPIDJSON_ASSERT(GetType() == kNumberType);
if (IsDouble()) return handler.Double(data_.n.d);
@@ -1936,7 +2036,7 @@ private:
if (count) {
GenericValue* e = static_cast<GenericValue*>(allocator.Malloc(count * sizeof(GenericValue)));
SetElementsPointer(e);
- std::memcpy(e, values, count * sizeof(GenericValue));
+ std::memcpy(static_cast<void*>(e), values, count * sizeof(GenericValue));
}
else
SetElementsPointer(0);
@@ -1949,7 +2049,7 @@ private:
if (count) {
Member* m = static_cast<Member*>(allocator.Malloc(count * sizeof(Member)));
SetMembersPointer(m);
- std::memcpy(m, members, count * sizeof(Member));
+ std::memcpy(static_cast<void*>(m), members, count * sizeof(Member));
}
else
SetMembersPointer(0);
@@ -2010,7 +2110,7 @@ private:
typedef GenericValue<UTF8<> > Value;
///////////////////////////////////////////////////////////////////////////////
-// GenericDocument
+// GenericDocument
//! A document for parsing JSON text as DOM.
/*!
@@ -2038,20 +2138,20 @@ public:
GenericValue<Encoding, Allocator>(type), allocator_(allocator), ownAllocator_(0), stack_(stackAllocator, stackCapacity), parseResult_()
{
if (!allocator_)
- ownAllocator_ = allocator_ = CEREAL_RAPIDJSON_NEW(Allocator());
+ ownAllocator_ = allocator_ = CEREAL_RAPIDJSON_NEW(Allocator)();
}
//! Constructor
- /*! Creates an empty document which type is Null.
+ /*! Creates an empty document which type is Null.
\param allocator Optional allocator for allocating memory.
\param stackCapacity Optional initial capacity of stack in bytes.
\param stackAllocator Optional allocator for allocating memory for stack.
*/
- GenericDocument(Allocator* allocator = 0, size_t stackCapacity = kDefaultStackCapacity, StackAllocator* stackAllocator = 0) :
+ GenericDocument(Allocator* allocator = 0, size_t stackCapacity = kDefaultStackCapacity, StackAllocator* stackAllocator = 0) :
allocator_(allocator), ownAllocator_(0), stack_(stackAllocator, stackCapacity), parseResult_()
{
if (!allocator_)
- ownAllocator_ = allocator_ = CEREAL_RAPIDJSON_NEW(Allocator());
+ ownAllocator_ = allocator_ = CEREAL_RAPIDJSON_NEW(Allocator)();
}
#if CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS
@@ -2112,6 +2212,10 @@ public:
return *this;
}
+ // Allow Swap with ValueType.
+ // Refer to Effective C++ 3rd Edition/Item 33: Avoid hiding inherited names.
+ using ValueType::Swap;
+
//! free-standing swap function helper
/*!
Helper function to enable support for common swap implementation pattern based on \c std::swap:
@@ -2243,7 +2347,7 @@ public:
template <unsigned parseFlags, typename SourceEncoding>
GenericDocument& Parse(const typename SourceEncoding::Ch* str, size_t length) {
CEREAL_RAPIDJSON_ASSERT(!(parseFlags & kParseInsituFlag));
- MemoryStream ms(static_cast<const char*>(str), length * sizeof(typename SourceEncoding::Ch));
+ MemoryStream ms(reinterpret_cast<const char*>(str), length * sizeof(typename SourceEncoding::Ch));
EncodedInputStream<SourceEncoding, MemoryStream> is(ms);
ParseStream<parseFlags, SourceEncoding>(is);
return *this;
@@ -2253,7 +2357,7 @@ public:
GenericDocument& Parse(const Ch* str, size_t length) {
return Parse<parseFlags, Encoding>(str, length);
}
-
+
GenericDocument& Parse(const Ch* str, size_t length) {
return Parse<kParseDefaultFlags>(str, length);
}
@@ -2273,14 +2377,14 @@ public:
GenericDocument& Parse(const std::basic_string<Ch>& str) {
return Parse<kParseDefaultFlags>(str);
}
-#endif // CEREAL_RAPIDJSON_HAS_STDSTRING
+#endif // CEREAL_RAPIDJSON_HAS_STDSTRING
//!@}
//!@name Handling parse errors
//!@{
- //! Whether a parse error has occured in the last parsing.
+ //! Whether a parse error has occurred in the last parsing.
bool HasParseError() const { return parseResult_.IsError(); }
//! Get the \ref ParseErrorCode of last parsing.
@@ -2338,16 +2442,16 @@ public:
bool Uint64(uint64_t i) { new (stack_.template Push<ValueType>()) ValueType(i); return true; }
bool Double(double d) { new (stack_.template Push<ValueType>()) ValueType(d); return true; }
- bool RawNumber(const Ch* str, SizeType length, bool copy) {
- if (copy)
+ bool RawNumber(const Ch* str, SizeType length, bool copy) {
+ if (copy)
new (stack_.template Push<ValueType>()) ValueType(str, length, GetAllocator());
else
new (stack_.template Push<ValueType>()) ValueType(str, length);
return true;
}
- bool String(const Ch* str, SizeType length, bool copy) {
- if (copy)
+ bool String(const Ch* str, SizeType length, bool copy) {
+ if (copy)
new (stack_.template Push<ValueType>()) ValueType(str, length, GetAllocator());
else
new (stack_.template Push<ValueType>()) ValueType(str, length);
@@ -2355,7 +2459,7 @@ public:
}
bool StartObject() { new (stack_.template Push<ValueType>()) ValueType(kObjectType); return true; }
-
+
bool Key(const Ch* str, SizeType length, bool copy) { return String(str, length, copy); }
bool EndObject(SizeType memberCount) {
@@ -2365,7 +2469,7 @@ public:
}
bool StartArray() { new (stack_.template Push<ValueType>()) ValueType(kArrayType); return true; }
-
+
bool EndArray(SizeType elementCount) {
ValueType* elements = stack_.template Pop<ValueType>(elementCount);
stack_.template Top<ValueType>()->SetArrayRaw(elements, elementCount, GetAllocator());
@@ -2401,35 +2505,6 @@ private:
//! GenericDocument with UTF8 encoding
typedef GenericDocument<UTF8<> > Document;
-// defined here due to the dependency on GenericDocument
-template <typename Encoding, typename Allocator>
-template <typename SourceAllocator>
-inline
-GenericValue<Encoding,Allocator>::GenericValue(const GenericValue<Encoding,SourceAllocator>& rhs, Allocator& allocator)
-{
- switch (rhs.GetType()) {
- case kObjectType:
- case kArrayType: { // perform deep copy via SAX Handler
- GenericDocument<Encoding,Allocator> d(&allocator);
- rhs.Accept(d);
- RawAssign(*d.stack_.template Pop<GenericValue>(1));
- }
- break;
- case kStringType:
- if (rhs.data_.f.flags == kConstStringFlag) {
- data_.f.flags = rhs.data_.f.flags;
- data_ = *reinterpret_cast<const Data*>(&rhs.data_);
- } else {
- SetStringRaw(StringRef(rhs.GetString(), rhs.GetStringLength()), allocator);
- }
- break;
- default:
- data_.f.flags = rhs.data_.f.flags;
- data_ = *reinterpret_cast<const Data*>(&rhs.data_);
- break;
- }
-}
-
//! Helper class for accessing Value of array type.
/*!
Instance of this helper class is obtained by \c GenericValue::GetArray().
@@ -2510,6 +2585,7 @@ public:
~GenericObject() {}
SizeType MemberCount() const { return value_.MemberCount(); }
+ SizeType MemberCapacity() const { return value_.MemberCapacity(); }
bool ObjectEmpty() const { return value_.ObjectEmpty(); }
template <typename T> ValueType& operator[](T* name) const { return value_[name]; }
template <typename SourceAllocator> ValueType& operator[](const GenericValue<EncodingType, SourceAllocator>& name) const { return value_[name]; }
@@ -2518,6 +2594,7 @@ public:
#endif
MemberIterator MemberBegin() const { return value_.MemberBegin(); }
MemberIterator MemberEnd() const { return value_.MemberEnd(); }
+ GenericObject MemberReserve(SizeType newCapacity, AllocatorType &allocator) const { value_.MemberReserve(newCapacity, allocator); return *this; }
bool HasMember(const Ch* name) const { return value_.HasMember(name); }
#if CEREAL_RAPIDJSON_HAS_STDSTRING
bool HasMember(const std::basic_string<Ch>& name) const { return value_.HasMember(name); }
@@ -2543,7 +2620,7 @@ public:
GenericObject AddMember(StringRefType name, ValueType& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
GenericObject AddMember(StringRefType name, StringRefType value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
template <typename T> CEREAL_RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (GenericObject)) AddMember(StringRefType name, T value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
- void RemoveAllMembers() { return value_.RemoveAllMembers(); }
+ void RemoveAllMembers() { value_.RemoveAllMembers(); }
bool RemoveMember(const Ch* name) const { return value_.RemoveMember(name); }
#if CEREAL_RAPIDJSON_HAS_STDSTRING
bool RemoveMember(const std::basic_string<Ch>& name) const { return value_.RemoveMember(name); }
diff --git a/source/code/Libs/include/cereal/external/rapidjson/encodedstream.h b/source/code/Libs/include/cereal/external/rapidjson/encodedstream.h
index 9671394..b04774b 100644
--- a/source/code/Libs/include/cereal/external/rapidjson/encodedstream.h
+++ b/source/code/Libs/include/cereal/external/rapidjson/encodedstream.h
@@ -200,7 +200,7 @@ private:
// xx xx xx xx UTF-8
if (!hasBOM_) {
- unsigned pattern = (c[0] ? 1 : 0) | (c[1] ? 2 : 0) | (c[2] ? 4 : 0) | (c[3] ? 8 : 0);
+ int pattern = (c[0] ? 1 : 0) | (c[1] ? 2 : 0) | (c[2] ? 4 : 0) | (c[3] ? 8 : 0);
switch (pattern) {
case 0x08: type_ = kUTF32BE; break;
case 0x0A: type_ = kUTF16BE; break;
diff --git a/source/code/Libs/include/cereal/external/rapidjson/encodings.h b/source/code/Libs/include/cereal/external/rapidjson/encodings.h
index ed00b97..a1c27ec 100644
--- a/source/code/Libs/include/cereal/external/rapidjson/encodings.h
+++ b/source/code/Libs/include/cereal/external/rapidjson/encodings.h
@@ -17,7 +17,7 @@
#include "rapidjson.h"
-#ifdef _MSC_VER
+#if defined(_MSC_VER) && !defined(__clang__)
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(4244) // conversion from 'type1' to 'type2', possible loss of data
CEREAL_RAPIDJSON_DIAG_OFF(4702) // unreachable code
@@ -144,9 +144,9 @@ struct UTF8 {
template <typename InputStream>
static bool Decode(InputStream& is, unsigned* codepoint) {
-#define COPY() c = is.Take(); *codepoint = (*codepoint << 6) | (static_cast<unsigned char>(c) & 0x3Fu)
-#define TRANS(mask) result &= ((GetRange(static_cast<unsigned char>(c)) & mask) != 0)
-#define TAIL() COPY(); TRANS(0x70)
+#define CEREAL_RAPIDJSON_COPY() c = is.Take(); *codepoint = (*codepoint << 6) | (static_cast<unsigned char>(c) & 0x3Fu)
+#define CEREAL_RAPIDJSON_TRANS(mask) result &= ((GetRange(static_cast<unsigned char>(c)) & mask) != 0)
+#define CEREAL_RAPIDJSON_TAIL() CEREAL_RAPIDJSON_COPY(); CEREAL_RAPIDJSON_TRANS(0x70)
typename InputStream::Ch c = is.Take();
if (!(c & 0x80)) {
*codepoint = static_cast<unsigned char>(c);
@@ -157,48 +157,48 @@ struct UTF8 {
if (type >= 32) {
*codepoint = 0;
} else {
- *codepoint = (0xFF >> type) & static_cast<unsigned char>(c);
+ *codepoint = (0xFFu >> type) & static_cast<unsigned char>(c);
}
bool result = true;
switch (type) {
- case 2: TAIL(); return result;
- case 3: TAIL(); TAIL(); return result;
- case 4: COPY(); TRANS(0x50); TAIL(); return result;
- case 5: COPY(); TRANS(0x10); TAIL(); TAIL(); return result;
- case 6: TAIL(); TAIL(); TAIL(); return result;
- case 10: COPY(); TRANS(0x20); TAIL(); return result;
- case 11: COPY(); TRANS(0x60); TAIL(); TAIL(); return result;
+ case 2: CEREAL_RAPIDJSON_TAIL(); return result;
+ case 3: CEREAL_RAPIDJSON_TAIL(); CEREAL_RAPIDJSON_TAIL(); return result;
+ case 4: CEREAL_RAPIDJSON_COPY(); CEREAL_RAPIDJSON_TRANS(0x50); CEREAL_RAPIDJSON_TAIL(); return result;
+ case 5: CEREAL_RAPIDJSON_COPY(); CEREAL_RAPIDJSON_TRANS(0x10); CEREAL_RAPIDJSON_TAIL(); CEREAL_RAPIDJSON_TAIL(); return result;
+ case 6: CEREAL_RAPIDJSON_TAIL(); CEREAL_RAPIDJSON_TAIL(); CEREAL_RAPIDJSON_TAIL(); return result;
+ case 10: CEREAL_RAPIDJSON_COPY(); CEREAL_RAPIDJSON_TRANS(0x20); CEREAL_RAPIDJSON_TAIL(); return result;
+ case 11: CEREAL_RAPIDJSON_COPY(); CEREAL_RAPIDJSON_TRANS(0x60); CEREAL_RAPIDJSON_TAIL(); CEREAL_RAPIDJSON_TAIL(); return result;
default: return false;
}
-#undef COPY
-#undef TRANS
-#undef TAIL
+#undef CEREAL_RAPIDJSON_COPY
+#undef CEREAL_RAPIDJSON_TRANS
+#undef CEREAL_RAPIDJSON_TAIL
}
template <typename InputStream, typename OutputStream>
static bool Validate(InputStream& is, OutputStream& os) {
-#define COPY() os.Put(c = is.Take())
-#define TRANS(mask) result &= ((GetRange(static_cast<unsigned char>(c)) & mask) != 0)
-#define TAIL() COPY(); TRANS(0x70)
+#define CEREAL_RAPIDJSON_COPY() os.Put(c = is.Take())
+#define CEREAL_RAPIDJSON_TRANS(mask) result &= ((GetRange(static_cast<unsigned char>(c)) & mask) != 0)
+#define CEREAL_RAPIDJSON_TAIL() CEREAL_RAPIDJSON_COPY(); CEREAL_RAPIDJSON_TRANS(0x70)
Ch c;
- COPY();
+ CEREAL_RAPIDJSON_COPY();
if (!(c & 0x80))
return true;
bool result = true;
switch (GetRange(static_cast<unsigned char>(c))) {
- case 2: TAIL(); return result;
- case 3: TAIL(); TAIL(); return result;
- case 4: COPY(); TRANS(0x50); TAIL(); return result;
- case 5: COPY(); TRANS(0x10); TAIL(); TAIL(); return result;
- case 6: TAIL(); TAIL(); TAIL(); return result;
- case 10: COPY(); TRANS(0x20); TAIL(); return result;
- case 11: COPY(); TRANS(0x60); TAIL(); TAIL(); return result;
+ case 2: CEREAL_RAPIDJSON_TAIL(); return result;
+ case 3: CEREAL_RAPIDJSON_TAIL(); CEREAL_RAPIDJSON_TAIL(); return result;
+ case 4: CEREAL_RAPIDJSON_COPY(); CEREAL_RAPIDJSON_TRANS(0x50); CEREAL_RAPIDJSON_TAIL(); return result;
+ case 5: CEREAL_RAPIDJSON_COPY(); CEREAL_RAPIDJSON_TRANS(0x10); CEREAL_RAPIDJSON_TAIL(); CEREAL_RAPIDJSON_TAIL(); return result;
+ case 6: CEREAL_RAPIDJSON_TAIL(); CEREAL_RAPIDJSON_TAIL(); CEREAL_RAPIDJSON_TAIL(); return result;
+ case 10: CEREAL_RAPIDJSON_COPY(); CEREAL_RAPIDJSON_TRANS(0x20); CEREAL_RAPIDJSON_TAIL(); return result;
+ case 11: CEREAL_RAPIDJSON_COPY(); CEREAL_RAPIDJSON_TRANS(0x60); CEREAL_RAPIDJSON_TAIL(); CEREAL_RAPIDJSON_TAIL(); return result;
default: return false;
}
-#undef COPY
-#undef TRANS
-#undef TAIL
+#undef CEREAL_RAPIDJSON_COPY
+#undef CEREAL_RAPIDJSON_TRANS
+#undef CEREAL_RAPIDJSON_TAIL
}
static unsigned char GetRange(unsigned char c) {
@@ -283,7 +283,7 @@ struct UTF16 {
CEREAL_RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
unsigned v = codepoint - 0x10000;
os.Put(static_cast<typename OutputStream::Ch>((v >> 10) | 0xD800));
- os.Put((v & 0x3FF) | 0xDC00);
+ os.Put(static_cast<typename OutputStream::Ch>((v & 0x3FF) | 0xDC00));
}
}
@@ -299,7 +299,7 @@ struct UTF16 {
CEREAL_RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
unsigned v = codepoint - 0x10000;
PutUnsafe(os, static_cast<typename OutputStream::Ch>((v >> 10) | 0xD800));
- PutUnsafe(os, (v & 0x3FF) | 0xDC00);
+ PutUnsafe(os, static_cast<typename OutputStream::Ch>((v & 0x3FF) | 0xDC00));
}
}
@@ -384,7 +384,7 @@ struct UTF16BE : UTF16<CharType> {
static CharType Take(InputByteStream& is) {
CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
unsigned c = static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 8;
- c |= static_cast<uint8_t>(is.Take());
+ c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take()));
return static_cast<CharType>(c);
}
@@ -620,28 +620,28 @@ struct AutoUTF {
#define CEREAL_RAPIDJSON_ENCODINGS_FUNC(x) UTF8<Ch>::x, UTF16LE<Ch>::x, UTF16BE<Ch>::x, UTF32LE<Ch>::x, UTF32BE<Ch>::x
template<typename OutputStream>
- CEREAL_RAPIDJSON_FORCEINLINE static void Encode(OutputStream& os, unsigned codepoint) {
+ static CEREAL_RAPIDJSON_FORCEINLINE void Encode(OutputStream& os, unsigned codepoint) {
typedef void (*EncodeFunc)(OutputStream&, unsigned);
static const EncodeFunc f[] = { CEREAL_RAPIDJSON_ENCODINGS_FUNC(Encode) };
(*f[os.GetType()])(os, codepoint);
}
template<typename OutputStream>
- CEREAL_RAPIDJSON_FORCEINLINE static void EncodeUnsafe(OutputStream& os, unsigned codepoint) {
+ static CEREAL_RAPIDJSON_FORCEINLINE void EncodeUnsafe(OutputStream& os, unsigned codepoint) {
typedef void (*EncodeFunc)(OutputStream&, unsigned);
static const EncodeFunc f[] = { CEREAL_RAPIDJSON_ENCODINGS_FUNC(EncodeUnsafe) };
(*f[os.GetType()])(os, codepoint);
}
template <typename InputStream>
- CEREAL_RAPIDJSON_FORCEINLINE static bool Decode(InputStream& is, unsigned* codepoint) {
+ static CEREAL_RAPIDJSON_FORCEINLINE bool Decode(InputStream& is, unsigned* codepoint) {
typedef bool (*DecodeFunc)(InputStream&, unsigned*);
static const DecodeFunc f[] = { CEREAL_RAPIDJSON_ENCODINGS_FUNC(Decode) };
return (*f[is.GetType()])(is, codepoint);
}
template <typename InputStream, typename OutputStream>
- CEREAL_RAPIDJSON_FORCEINLINE static bool Validate(InputStream& is, OutputStream& os) {
+ static CEREAL_RAPIDJSON_FORCEINLINE bool Validate(InputStream& is, OutputStream& os) {
typedef bool (*ValidateFunc)(InputStream&, OutputStream&);
static const ValidateFunc f[] = { CEREAL_RAPIDJSON_ENCODINGS_FUNC(Validate) };
return (*f[is.GetType()])(is, os);
@@ -658,7 +658,7 @@ template<typename SourceEncoding, typename TargetEncoding>
struct Transcoder {
//! Take one Unicode codepoint from source encoding, convert it to target encoding and put it to the output stream.
template<typename InputStream, typename OutputStream>
- CEREAL_RAPIDJSON_FORCEINLINE static bool Transcode(InputStream& is, OutputStream& os) {
+ static CEREAL_RAPIDJSON_FORCEINLINE bool Transcode(InputStream& is, OutputStream& os) {
unsigned codepoint;
if (!SourceEncoding::Decode(is, &codepoint))
return false;
@@ -667,7 +667,7 @@ struct Transcoder {
}
template<typename InputStream, typename OutputStream>
- CEREAL_RAPIDJSON_FORCEINLINE static bool TranscodeUnsafe(InputStream& is, OutputStream& os) {
+ static CEREAL_RAPIDJSON_FORCEINLINE bool TranscodeUnsafe(InputStream& is, OutputStream& os) {
unsigned codepoint;
if (!SourceEncoding::Decode(is, &codepoint))
return false;
@@ -677,7 +677,7 @@ struct Transcoder {
//! Validate one Unicode codepoint from an encoded stream.
template<typename InputStream, typename OutputStream>
- CEREAL_RAPIDJSON_FORCEINLINE static bool Validate(InputStream& is, OutputStream& os) {
+ static CEREAL_RAPIDJSON_FORCEINLINE bool Validate(InputStream& is, OutputStream& os) {
return Transcode(is, os); // Since source/target encoding is different, must transcode.
}
};
@@ -690,26 +690,26 @@ inline void PutUnsafe(Stream& stream, typename Stream::Ch c);
template<typename Encoding>
struct Transcoder<Encoding, Encoding> {
template<typename InputStream, typename OutputStream>
- CEREAL_RAPIDJSON_FORCEINLINE static bool Transcode(InputStream& is, OutputStream& os) {
+ static CEREAL_RAPIDJSON_FORCEINLINE bool Transcode(InputStream& is, OutputStream& os) {
os.Put(is.Take()); // Just copy one code unit. This semantic is different from primary template class.
return true;
}
template<typename InputStream, typename OutputStream>
- CEREAL_RAPIDJSON_FORCEINLINE static bool TranscodeUnsafe(InputStream& is, OutputStream& os) {
+ static CEREAL_RAPIDJSON_FORCEINLINE bool TranscodeUnsafe(InputStream& is, OutputStream& os) {
PutUnsafe(os, is.Take()); // Just copy one code unit. This semantic is different from primary template class.
return true;
}
template<typename InputStream, typename OutputStream>
- CEREAL_RAPIDJSON_FORCEINLINE static bool Validate(InputStream& is, OutputStream& os) {
+ static CEREAL_RAPIDJSON_FORCEINLINE bool Validate(InputStream& is, OutputStream& os) {
return Encoding::Validate(is, os); // source/target encoding are the same
}
};
CEREAL_RAPIDJSON_NAMESPACE_END
-#if defined(__GNUC__) || defined(_MSC_VER)
+#if defined(__GNUC__) || (defined(_MSC_VER) && !defined(__clang__))
CEREAL_RAPIDJSON_DIAG_POP
#endif
diff --git a/source/code/Libs/include/cereal/external/rapidjson/error/error.h b/source/code/Libs/include/cereal/external/rapidjson/error/error.h
index c2638f1..7e7cc24 100644
--- a/source/code/Libs/include/cereal/external/rapidjson/error/error.h
+++ b/source/code/Libs/include/cereal/external/rapidjson/error/error.h
@@ -104,6 +104,8 @@ enum ParseErrorCode {
\see GenericReader::Parse, GenericDocument::Parse
*/
struct ParseResult {
+ //!! Unspecified boolean type
+ typedef bool (ParseResult::*BooleanType)() const;
public:
//! Default constructor, no error.
ParseResult() : code_(kParseErrorNone), offset_(0) {}
@@ -115,8 +117,8 @@ public:
//! Get the error offset, if \ref IsError(), 0 otherwise.
size_t Offset() const { return offset_; }
- //! Conversion to \c bool, returns \c true, iff !\ref IsError().
- operator bool() const { return !IsError(); }
+ //! Explicit conversion to \c bool, returns \c true, iff !\ref IsError().
+ operator BooleanType() const { return !IsError() ? &ParseResult::IsError : NULL; }
//! Whether the result is an error.
bool IsError() const { return code_ != kParseErrorNone; }
@@ -124,6 +126,10 @@ public:
bool operator==(ParseErrorCode code) const { return code_ == code; }
friend bool operator==(ParseErrorCode code, const ParseResult & err) { return code == err.code_; }
+ bool operator!=(const ParseResult& that) const { return !(*this == that); }
+ bool operator!=(ParseErrorCode code) const { return !(*this == code); }
+ friend bool operator!=(ParseErrorCode code, const ParseResult & err) { return err != code; }
+
//! Reset error code.
void Clear() { Set(kParseErrorNone); }
//! Update error code and offset.
diff --git a/source/code/Libs/include/cereal/external/rapidjson/filereadstream.h b/source/code/Libs/include/cereal/external/rapidjson/filereadstream.h
index abafb54..253a7f9 100644
--- a/source/code/Libs/include/cereal/external/rapidjson/filereadstream.h
+++ b/source/code/Libs/include/cereal/external/rapidjson/filereadstream.h
@@ -59,7 +59,7 @@ public:
// For encoding detection only.
const Ch* Peek4() const {
- return (current_ + 4 <= bufferLast_) ? current_ : 0;
+ return (current_ + 4 - !eof_ <= bufferLast_) ? current_ : 0;
}
private:
@@ -68,7 +68,7 @@ private:
++current_;
else if (!eof_) {
count_ += readCount_;
- readCount_ = fread(buffer_, 1, bufferSize_, fp_);
+ readCount_ = std::fread(buffer_, 1, bufferSize_, fp_);
bufferLast_ = buffer_ + readCount_ - 1;
current_ = buffer_;
diff --git a/source/code/Libs/include/cereal/external/rapidjson/filewritestream.h b/source/code/Libs/include/cereal/external/rapidjson/filewritestream.h
index 9a60099..44ae127 100644
--- a/source/code/Libs/include/cereal/external/rapidjson/filewritestream.h
+++ b/source/code/Libs/include/cereal/external/rapidjson/filewritestream.h
@@ -25,7 +25,7 @@ CEREAL_RAPIDJSON_DIAG_OFF(unreachable-code)
CEREAL_RAPIDJSON_NAMESPACE_BEGIN
-//! Wrapper of C file stream for input using fread().
+//! Wrapper of C file stream for output using fwrite().
/*!
\note implements Stream concept
*/
@@ -62,7 +62,7 @@ public:
void Flush() {
if (current_ != buffer_) {
- size_t result = fwrite(buffer_, 1, static_cast<size_t>(current_ - buffer_), fp_);
+ size_t result = std::fwrite(buffer_, 1, static_cast<size_t>(current_ - buffer_), fp_);
if (result < static_cast<size_t>(current_ - buffer_)) {
// failure deliberately ignored at this time
// added to avoid warn_unused_result build errors
diff --git a/source/code/Libs/include/cereal/external/rapidjson/internal/biginteger.h b/source/code/Libs/include/cereal/external/rapidjson/internal/biginteger.h
index f8a5a50..77a6519 100644
--- a/source/code/Libs/include/cereal/external/rapidjson/internal/biginteger.h
+++ b/source/code/Libs/include/cereal/external/rapidjson/internal/biginteger.h
@@ -17,7 +17,7 @@
#include "../rapidjson.h"
-#if defined(_MSC_VER) && defined(_M_AMD64)
+#if defined(_MSC_VER) && !__INTEL_COMPILER && defined(_M_AMD64)
#include <intrin.h> // for _umul128
#pragma intrinsic(_umul128)
#endif
@@ -133,7 +133,7 @@ public:
CEREAL_RAPIDJSON_ASSERT(count_ + offset <= kCapacity);
if (interShift == 0) {
- std::memmove(&digits_[count_ - 1 + offset], &digits_[count_ - 1], count_ * sizeof(Type));
+ std::memmove(digits_ + offset, digits_, count_ * sizeof(Type));
count_ += offset;
}
else {
diff --git a/source/code/Libs/include/cereal/external/rapidjson/internal/diyfp.h b/source/code/Libs/include/cereal/external/rapidjson/internal/diyfp.h
index ab7d66b..3f92a07 100644
--- a/source/code/Libs/include/cereal/external/rapidjson/internal/diyfp.h
+++ b/source/code/Libs/include/cereal/external/rapidjson/internal/diyfp.h
@@ -1,5 +1,5 @@
// Tencent is pleased to support the open source community by making RapidJSON available.
-//
+//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
@@ -7,9 +7,9 @@
//
// http://opensource.org/licenses/MIT
//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
// specific language governing permissions and limitations under the License.
// This is a C++ header-only implementation of Grisu2 algorithm from the publication:
@@ -20,8 +20,9 @@
#define CEREAL_RAPIDJSON_DIYFP_H_
#include "../rapidjson.h"
+#include <limits>
-#if defined(_MSC_VER) && defined(_M_AMD64)
+#if defined(_MSC_VER) && defined(_M_AMD64) && !defined(__INTEL_COMPILER)
#include <intrin.h>
#pragma intrinsic(_BitScanReverse64)
#pragma intrinsic(_umul128)
@@ -56,7 +57,7 @@ struct DiyFp {
if (biased_e != 0) {
f = significand + kDpHiddenBit;
e = biased_e - kDpExponentBias;
- }
+ }
else {
f = significand;
e = kDpMinExponent + 1;
@@ -99,6 +100,7 @@ struct DiyFp {
}
DiyFp Normalize() const {
+ CEREAL_RAPIDJSON_ASSERT(f != 0); // https://stackoverflow.com/a/26809183/291737
#if defined(_MSC_VER) && defined(_M_AMD64)
unsigned long index;
_BitScanReverse64(&index, f);
@@ -141,7 +143,16 @@ struct DiyFp {
double d;
uint64_t u64;
}u;
- const uint64_t be = (e == kDpDenormalExponent && (f & kDpHiddenBit) == 0) ? 0 :
+ CEREAL_RAPIDJSON_ASSERT(f <= kDpHiddenBit + kDpSignificandMask);
+ if (e < kDpDenormalExponent) {
+ // Underflow.
+ return 0.0;
+ }
+ if (e >= kDpMaxExponent) {
+ // Overflow.
+ return std::numeric_limits<double>::infinity();
+ }
+ const uint64_t be = (e == kDpDenormalExponent && (f & kDpHiddenBit) == 0) ? 0 :
static_cast<uint64_t>(e + kDpExponentBias);
u.u64 = (f & kDpSignificandMask) | (be << kDpSignificandSize);
return u.d;
@@ -220,9 +231,10 @@ inline DiyFp GetCachedPowerByIndex(size_t index) {
641, 667, 694, 720, 747, 774, 800, 827, 853, 880,
907, 933, 960, 986, 1013, 1039, 1066
};
+ CEREAL_RAPIDJSON_ASSERT(index < 87);
return DiyFp(kCachedPowers_F[index], kCachedPowers_E[index]);
}
-
+
inline DiyFp GetCachedPower(int e, int* K) {
//int k = static_cast<int>(ceil((-61 - e) * 0.30102999566398114)) + 374;
@@ -238,10 +250,11 @@ inline DiyFp GetCachedPower(int e, int* K) {
}
inline DiyFp GetCachedPower10(int exp, int *outExp) {
- unsigned index = (static_cast<unsigned>(exp) + 348u) / 8u;
- *outExp = -348 + static_cast<int>(index) * 8;
- return GetCachedPowerByIndex(index);
- }
+ CEREAL_RAPIDJSON_ASSERT(exp >= -348);
+ unsigned index = static_cast<unsigned>(exp + 348) / 8u;
+ *outExp = -348 + static_cast<int>(index) * 8;
+ return GetCachedPowerByIndex(index);
+}
#ifdef __GNUC__
CEREAL_RAPIDJSON_DIAG_POP
diff --git a/source/code/Libs/include/cereal/external/rapidjson/internal/dtoa.h b/source/code/Libs/include/cereal/external/rapidjson/internal/dtoa.h
index c59c92e..ea62b34 100644
--- a/source/code/Libs/include/cereal/external/rapidjson/internal/dtoa.h
+++ b/source/code/Libs/include/cereal/external/rapidjson/internal/dtoa.h
@@ -41,7 +41,7 @@ inline void GrisuRound(char* buffer, int len, uint64_t delta, uint64_t rest, uin
}
}
-inline unsigned CountDecimalDigit32(uint32_t n) {
+inline int CountDecimalDigit32(uint32_t n) {
// Simple pure C++ implementation was faster than __builtin_clz version in this situation.
if (n < 10) return 1;
if (n < 100) return 2;
@@ -63,7 +63,7 @@ inline void DigitGen(const DiyFp& W, const DiyFp& Mp, uint64_t delta, char* buff
const DiyFp wp_w = Mp - W;
uint32_t p1 = static_cast<uint32_t>(Mp.f >> -one.e);
uint64_t p2 = Mp.f & (one.f - 1);
- unsigned kappa = CountDecimalDigit32(p1); // kappa in [0, 9]
+ int kappa = CountDecimalDigit32(p1); // kappa in [0, 9]
*len = 0;
while (kappa > 0) {
@@ -102,8 +102,8 @@ inline void DigitGen(const DiyFp& W, const DiyFp& Mp, uint64_t delta, char* buff
kappa--;
if (p2 < delta) {
*K += kappa;
- int index = -static_cast<int>(kappa);
- GrisuRound(buffer, *len, delta, p2, one.f, wp_w.f * (index < 9 ? kPow10[-static_cast<int>(kappa)] : 0));
+ int index = -kappa;
+ GrisuRound(buffer, *len, delta, p2, one.f, wp_w.f * (index < 9 ? kPow10[index] : 0));
return;
}
}
diff --git a/source/code/Libs/include/cereal/external/rapidjson/internal/ieee754.h b/source/code/Libs/include/cereal/external/rapidjson/internal/ieee754.h
index 35845a1..6730dfd 100644
--- a/source/code/Libs/include/cereal/external/rapidjson/internal/ieee754.h
+++ b/source/code/Libs/include/cereal/external/rapidjson/internal/ieee754.h
@@ -48,13 +48,13 @@ public:
int IntegerExponent() const { return (IsNormal() ? Exponent() : kDenormalExponent) - kSignificandSize; }
uint64_t ToBias() const { return (u_ & kSignMask) ? ~u_ + 1 : u_ | kSignMask; }
- static unsigned EffectiveSignificandSize(int order) {
+ static int EffectiveSignificandSize(int order) {
if (order >= -1021)
return 53;
else if (order <= -1074)
return 0;
else
- return static_cast<unsigned>(order) + 1074;
+ return order + 1074;
}
private:
diff --git a/source/code/Libs/include/cereal/external/rapidjson/internal/itoa.h b/source/code/Libs/include/cereal/external/rapidjson/internal/itoa.h
index 3e83658..f04e3fa 100644
--- a/source/code/Libs/include/cereal/external/rapidjson/internal/itoa.h
+++ b/source/code/Libs/include/cereal/external/rapidjson/internal/itoa.h
@@ -1,5 +1,5 @@
// Tencent is pleased to support the open source community by making RapidJSON available.
-//
+//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
@@ -7,9 +7,9 @@
//
// http://opensource.org/licenses/MIT
//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
// specific language governing permissions and limitations under the License.
#ifndef CEREAL_RAPIDJSON_ITOA_
@@ -37,12 +37,14 @@ inline const char* GetDigitsLut() {
}
inline char* u32toa(uint32_t value, char* buffer) {
+ CEREAL_RAPIDJSON_ASSERT(buffer != 0);
+
const char* cDigitsLut = GetDigitsLut();
if (value < 10000) {
const uint32_t d1 = (value / 100) << 1;
const uint32_t d2 = (value % 100) << 1;
-
+
if (value >= 1000)
*buffer++ = cDigitsLut[d1];
if (value >= 100)
@@ -55,13 +57,13 @@ inline char* u32toa(uint32_t value, char* buffer) {
// value = bbbbcccc
const uint32_t b = value / 10000;
const uint32_t c = value % 10000;
-
+
const uint32_t d1 = (b / 100) << 1;
const uint32_t d2 = (b % 100) << 1;
-
+
const uint32_t d3 = (c / 100) << 1;
const uint32_t d4 = (c % 100) << 1;
-
+
if (value >= 10000000)
*buffer++ = cDigitsLut[d1];
if (value >= 1000000)
@@ -69,7 +71,7 @@ inline char* u32toa(uint32_t value, char* buffer) {
if (value >= 100000)
*buffer++ = cDigitsLut[d2];
*buffer++ = cDigitsLut[d2 + 1];
-
+
*buffer++ = cDigitsLut[d3];
*buffer++ = cDigitsLut[d3 + 1];
*buffer++ = cDigitsLut[d4];
@@ -77,10 +79,10 @@ inline char* u32toa(uint32_t value, char* buffer) {
}
else {
// value = aabbbbcccc in decimal
-
+
const uint32_t a = value / 100000000; // 1 to 42
value %= 100000000;
-
+
if (a >= 10) {
const unsigned i = a << 1;
*buffer++ = cDigitsLut[i];
@@ -91,13 +93,13 @@ inline char* u32toa(uint32_t value, char* buffer) {
const uint32_t b = value / 10000; // 0 to 9999
const uint32_t c = value % 10000; // 0 to 9999
-
+
const uint32_t d1 = (b / 100) << 1;
const uint32_t d2 = (b % 100) << 1;
-
+
const uint32_t d3 = (c / 100) << 1;
const uint32_t d4 = (c % 100) << 1;
-
+
*buffer++ = cDigitsLut[d1];
*buffer++ = cDigitsLut[d1 + 1];
*buffer++ = cDigitsLut[d2];
@@ -111,6 +113,7 @@ inline char* u32toa(uint32_t value, char* buffer) {
}
inline char* i32toa(int32_t value, char* buffer) {
+ CEREAL_RAPIDJSON_ASSERT(buffer != 0);
uint32_t u = static_cast<uint32_t>(value);
if (value < 0) {
*buffer++ = '-';
@@ -121,6 +124,7 @@ inline char* i32toa(int32_t value, char* buffer) {
}
inline char* u64toa(uint64_t value, char* buffer) {
+ CEREAL_RAPIDJSON_ASSERT(buffer != 0);
const char* cDigitsLut = GetDigitsLut();
const uint64_t kTen8 = 100000000;
const uint64_t kTen9 = kTen8 * 10;
@@ -131,13 +135,13 @@ inline char* u64toa(uint64_t value, char* buffer) {
const uint64_t kTen14 = kTen8 * 1000000;
const uint64_t kTen15 = kTen8 * 10000000;
const uint64_t kTen16 = kTen8 * kTen8;
-
+
if (value < kTen8) {
uint32_t v = static_cast<uint32_t>(value);
if (v < 10000) {
const uint32_t d1 = (v / 100) << 1;
const uint32_t d2 = (v % 100) << 1;
-
+
if (v >= 1000)
*buffer++ = cDigitsLut[d1];
if (v >= 100)
@@ -150,13 +154,13 @@ inline char* u64toa(uint64_t value, char* buffer) {
// value = bbbbcccc
const uint32_t b = v / 10000;
const uint32_t c = v % 10000;
-
+
const uint32_t d1 = (b / 100) << 1;
const uint32_t d2 = (b % 100) << 1;
-
+
const uint32_t d3 = (c / 100) << 1;
const uint32_t d4 = (c % 100) << 1;
-
+
if (value >= 10000000)
*buffer++ = cDigitsLut[d1];
if (value >= 1000000)
@@ -164,7 +168,7 @@ inline char* u64toa(uint64_t value, char* buffer) {
if (value >= 100000)
*buffer++ = cDigitsLut[d2];
*buffer++ = cDigitsLut[d2 + 1];
-
+
*buffer++ = cDigitsLut[d3];
*buffer++ = cDigitsLut[d3 + 1];
*buffer++ = cDigitsLut[d4];
@@ -174,22 +178,22 @@ inline char* u64toa(uint64_t value, char* buffer) {
else if (value < kTen16) {
const uint32_t v0 = static_cast<uint32_t>(value / kTen8);
const uint32_t v1 = static_cast<uint32_t>(value % kTen8);
-
+
const uint32_t b0 = v0 / 10000;
const uint32_t c0 = v0 % 10000;
-
+
const uint32_t d1 = (b0 / 100) << 1;
const uint32_t d2 = (b0 % 100) << 1;
-
+
const uint32_t d3 = (c0 / 100) << 1;
const uint32_t d4 = (c0 % 100) << 1;
const uint32_t b1 = v1 / 10000;
const uint32_t c1 = v1 % 10000;
-
+
const uint32_t d5 = (b1 / 100) << 1;
const uint32_t d6 = (b1 % 100) << 1;
-
+
const uint32_t d7 = (c1 / 100) << 1;
const uint32_t d8 = (c1 % 100) << 1;
@@ -207,9 +211,8 @@ inline char* u64toa(uint64_t value, char* buffer) {
*buffer++ = cDigitsLut[d3 + 1];
if (value >= kTen9)
*buffer++ = cDigitsLut[d4];
- if (value >= kTen8)
- *buffer++ = cDigitsLut[d4 + 1];
-
+
+ *buffer++ = cDigitsLut[d4 + 1];
*buffer++ = cDigitsLut[d5];
*buffer++ = cDigitsLut[d5 + 1];
*buffer++ = cDigitsLut[d6];
@@ -222,7 +225,7 @@ inline char* u64toa(uint64_t value, char* buffer) {
else {
const uint32_t a = static_cast<uint32_t>(value / kTen16); // 1 to 1844
value %= kTen16;
-
+
if (a < 10)
*buffer++ = static_cast<char>('0' + static_cast<char>(a));
else if (a < 100) {
@@ -232,7 +235,7 @@ inline char* u64toa(uint64_t value, char* buffer) {
}
else if (a < 1000) {
*buffer++ = static_cast<char>('0' + static_cast<char>(a / 100));
-
+
const uint32_t i = (a % 100) << 1;
*buffer++ = cDigitsLut[i];
*buffer++ = cDigitsLut[i + 1];
@@ -245,28 +248,28 @@ inline char* u64toa(uint64_t value, char* buffer) {
*buffer++ = cDigitsLut[j];
*buffer++ = cDigitsLut[j + 1];
}
-
+
const uint32_t v0 = static_cast<uint32_t>(value / kTen8);
const uint32_t v1 = static_cast<uint32_t>(value % kTen8);
-
+
const uint32_t b0 = v0 / 10000;
const uint32_t c0 = v0 % 10000;
-
+
const uint32_t d1 = (b0 / 100) << 1;
const uint32_t d2 = (b0 % 100) << 1;
-
+
const uint32_t d3 = (c0 / 100) << 1;
const uint32_t d4 = (c0 % 100) << 1;
-
+
const uint32_t b1 = v1 / 10000;
const uint32_t c1 = v1 % 10000;
-
+
const uint32_t d5 = (b1 / 100) << 1;
const uint32_t d6 = (b1 % 100) << 1;
-
+
const uint32_t d7 = (c1 / 100) << 1;
const uint32_t d8 = (c1 % 100) << 1;
-
+
*buffer++ = cDigitsLut[d1];
*buffer++ = cDigitsLut[d1 + 1];
*buffer++ = cDigitsLut[d2];
@@ -284,11 +287,12 @@ inline char* u64toa(uint64_t value, char* buffer) {
*buffer++ = cDigitsLut[d8];
*buffer++ = cDigitsLut[d8 + 1];
}
-
+
return buffer;
}
inline char* i64toa(int64_t value, char* buffer) {
+ CEREAL_RAPIDJSON_ASSERT(buffer != 0);
uint64_t u = static_cast<uint64_t>(value);
if (value < 0) {
*buffer++ = '-';
diff --git a/source/code/Libs/include/cereal/external/rapidjson/internal/meta.h b/source/code/Libs/include/cereal/external/rapidjson/internal/meta.h
index c98db90..f511ff8 100644
--- a/source/code/Libs/include/cereal/external/rapidjson/internal/meta.h
+++ b/source/code/Libs/include/cereal/external/rapidjson/internal/meta.h
@@ -21,7 +21,8 @@
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(effc++)
#endif
-#if defined(_MSC_VER)
+
+#if defined(_MSC_VER) && !defined(__clang__)
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(6334)
#endif
@@ -174,7 +175,11 @@ template <typename T> struct RemoveSfinaeTag<SfinaeTag&(*)(T)> { typedef T Type;
CEREAL_RAPIDJSON_NAMESPACE_END
//@endcond
-#if defined(__GNUC__) || defined(_MSC_VER)
+#if defined(_MSC_VER) && !defined(__clang__)
+CEREAL_RAPIDJSON_DIAG_POP
+#endif
+
+#ifdef __GNUC__
CEREAL_RAPIDJSON_DIAG_POP
#endif
diff --git a/source/code/Libs/include/cereal/external/rapidjson/internal/regex.h b/source/code/Libs/include/cereal/external/rapidjson/internal/regex.h
index 3bfa3ec..6c2ed6e 100644
--- a/source/code/Libs/include/cereal/external/rapidjson/internal/regex.h
+++ b/source/code/Libs/include/cereal/external/rapidjson/internal/regex.h
@@ -24,16 +24,17 @@ CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(padded)
CEREAL_RAPIDJSON_DIAG_OFF(switch-enum)
CEREAL_RAPIDJSON_DIAG_OFF(implicit-fallthrough)
+#elif defined(_MSC_VER)
+CEREAL_RAPIDJSON_DIAG_PUSH
+CEREAL_RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated
#endif
#ifdef __GNUC__
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(effc++)
+#if __GNUC__ >= 7
+CEREAL_RAPIDJSON_DIAG_OFF(implicit-fallthrough)
#endif
-
-#ifdef _MSC_VER
-CEREAL_RAPIDJSON_DIAG_PUSH
-CEREAL_RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated
#endif
#ifndef CEREAL_RAPIDJSON_REGEX_VERBOSE
@@ -44,11 +45,39 @@ CEREAL_RAPIDJSON_NAMESPACE_BEGIN
namespace internal {
///////////////////////////////////////////////////////////////////////////////
+// DecodedStream
+
+template <typename SourceStream, typename Encoding>
+class DecodedStream {
+public:
+ DecodedStream(SourceStream& ss) : ss_(ss), codepoint_() { Decode(); }
+ unsigned Peek() { return codepoint_; }
+ unsigned Take() {
+ unsigned c = codepoint_;
+ if (c) // No further decoding when '\0'
+ Decode();
+ return c;
+ }
+
+private:
+ void Decode() {
+ if (!Encoding::Decode(ss_, &codepoint_))
+ codepoint_ = 0;
+ }
+
+ SourceStream& ss_;
+ unsigned codepoint_;
+};
+
+///////////////////////////////////////////////////////////////////////////////
// GenericRegex
static const SizeType kRegexInvalidState = ~SizeType(0); //!< Represents an invalid index in GenericRegex::State::out, out1
static const SizeType kRegexInvalidRange = ~SizeType(0);
+template <typename Encoding, typename Allocator>
+class GenericRegexSearch;
+
//! Regular expression engine with subset of ECMAscript grammar.
/*!
Supported regular expression syntax:
@@ -84,45 +113,29 @@ static const SizeType kRegexInvalidRange = ~SizeType(0);
template <typename Encoding, typename Allocator = CrtAllocator>
class GenericRegex {
public:
+ typedef Encoding EncodingType;
typedef typename Encoding::Ch Ch;
+ template <typename, typename> friend class GenericRegexSearch;
GenericRegex(const Ch* source, Allocator* allocator = 0) :
- states_(allocator, 256), ranges_(allocator, 256), root_(kRegexInvalidState), stateCount_(), rangeCount_(),
- stateSet_(), state0_(allocator, 0), state1_(allocator, 0), anchorBegin_(), anchorEnd_()
+ ownAllocator_(allocator ? 0 : CEREAL_RAPIDJSON_NEW(Allocator)()), allocator_(allocator ? allocator : ownAllocator_),
+ states_(allocator_, 256), ranges_(allocator_, 256), root_(kRegexInvalidState), stateCount_(), rangeCount_(),
+ anchorBegin_(), anchorEnd_()
{
GenericStringStream<Encoding> ss(source);
- DecodedStream<GenericStringStream<Encoding> > ds(ss);
+ DecodedStream<GenericStringStream<Encoding>, Encoding> ds(ss);
Parse(ds);
}
- ~GenericRegex() {
- Allocator::Free(stateSet_);
+ ~GenericRegex()
+ {
+ CEREAL_RAPIDJSON_DELETE(ownAllocator_);
}
bool IsValid() const {
return root_ != kRegexInvalidState;
}
- template <typename InputStream>
- bool Match(InputStream& is) const {
- return SearchWithAnchoring(is, true, true);
- }
-
- bool Match(const Ch* s) const {
- GenericStringStream<Encoding> is(s);
- return Match(is);
- }
-
- template <typename InputStream>
- bool Search(InputStream& is) const {
- return SearchWithAnchoring(is, anchorBegin_, anchorEnd_);
- }
-
- bool Search(const Ch* s) const {
- GenericStringStream<Encoding> is(s);
- return Search(is);
- }
-
private:
enum Operator {
kZeroOrOne,
@@ -157,28 +170,6 @@ private:
SizeType minIndex;
};
- template <typename SourceStream>
- class DecodedStream {
- public:
- DecodedStream(SourceStream& ss) : ss_(ss), codepoint_() { Decode(); }
- unsigned Peek() { return codepoint_; }
- unsigned Take() {
- unsigned c = codepoint_;
- if (c) // No further decoding when '\0'
- Decode();
- return c;
- }
-
- private:
- void Decode() {
- if (!Encoding::Decode(ss_, &codepoint_))
- codepoint_ = 0;
- }
-
- SourceStream& ss_;
- unsigned codepoint_;
- };
-
State& GetState(SizeType index) {
CEREAL_RAPIDJSON_ASSERT(index < stateCount_);
return states_.template Bottom<State>()[index];
@@ -200,11 +191,10 @@ private:
}
template <typename InputStream>
- void Parse(DecodedStream<InputStream>& ds) {
- Allocator allocator;
- Stack<Allocator> operandStack(&allocator, 256); // Frag
- Stack<Allocator> operatorStack(&allocator, 256); // Operator
- Stack<Allocator> atomCountStack(&allocator, 256); // unsigned (Atom per parenthesis)
+ void Parse(DecodedStream<InputStream, Encoding>& ds) {
+ Stack<Allocator> operandStack(allocator_, 256); // Frag
+ Stack<Allocator> operatorStack(allocator_, 256); // Operator
+ Stack<Allocator> atomCountStack(allocator_, 256); // unsigned (Atom per parenthesis)
*atomCountStack.template Push<unsigned>() = 0;
@@ -327,14 +317,6 @@ private:
printf("\n");
#endif
}
-
- // Preallocate buffer for SearchWithAnchoring()
- CEREAL_RAPIDJSON_ASSERT(stateSet_ == 0);
- if (stateCount_ > 0) {
- stateSet_ = static_cast<unsigned*>(states_.GetAllocator().Malloc(GetStateSetSize()));
- state0_.template Reserve<SizeType>(stateCount_);
- state1_.template Reserve<SizeType>(stateCount_);
- }
}
SizeType NewState(SizeType out, SizeType out1, unsigned codepoint) {
@@ -413,8 +395,7 @@ private:
}
return false;
- default:
- CEREAL_RAPIDJSON_ASSERT(op == kOneOrMore);
+ case kOneOrMore:
if (operandStack.GetSize() >= sizeof(Frag)) {
Frag e = *operandStack.template Pop<Frag>(1);
SizeType s = NewState(kRegexInvalidState, e.start, 0);
@@ -423,6 +404,10 @@ private:
return true;
}
return false;
+
+ default:
+ // syntax error (e.g. unclosed kLeftParenthesis)
+ return false;
}
}
@@ -483,7 +468,7 @@ private:
}
template <typename InputStream>
- bool ParseUnsigned(DecodedStream<InputStream>& ds, unsigned* u) {
+ bool ParseUnsigned(DecodedStream<InputStream, Encoding>& ds, unsigned* u) {
unsigned r = 0;
if (ds.Peek() < '0' || ds.Peek() > '9')
return false;
@@ -497,7 +482,7 @@ private:
}
template <typename InputStream>
- bool ParseRange(DecodedStream<InputStream>& ds, SizeType* range) {
+ bool ParseRange(DecodedStream<InputStream, Encoding>& ds, SizeType* range) {
bool isBegin = true;
bool negate = false;
int step = 0;
@@ -575,7 +560,7 @@ private:
}
template <typename InputStream>
- bool CharacterEscape(DecodedStream<InputStream>& ds, unsigned* escapedCodepoint) {
+ bool CharacterEscape(DecodedStream<InputStream, Encoding>& ds, unsigned* escapedCodepoint) {
unsigned codepoint;
switch (codepoint = ds.Take()) {
case '^':
@@ -603,34 +588,95 @@ private:
}
}
+ Allocator* ownAllocator_;
+ Allocator* allocator_;
+ Stack<Allocator> states_;
+ Stack<Allocator> ranges_;
+ SizeType root_;
+ SizeType stateCount_;
+ SizeType rangeCount_;
+
+ static const unsigned kInfinityQuantifier = ~0u;
+
+ // For SearchWithAnchoring()
+ bool anchorBegin_;
+ bool anchorEnd_;
+};
+
+template <typename RegexType, typename Allocator = CrtAllocator>
+class GenericRegexSearch {
+public:
+ typedef typename RegexType::EncodingType Encoding;
+ typedef typename Encoding::Ch Ch;
+
+ GenericRegexSearch(const RegexType& regex, Allocator* allocator = 0) :
+ regex_(regex), allocator_(allocator), ownAllocator_(0),
+ state0_(allocator, 0), state1_(allocator, 0), stateSet_()
+ {
+ CEREAL_RAPIDJSON_ASSERT(regex_.IsValid());
+ if (!allocator_)
+ ownAllocator_ = allocator_ = CEREAL_RAPIDJSON_NEW(Allocator)();
+ stateSet_ = static_cast<unsigned*>(allocator_->Malloc(GetStateSetSize()));
+ state0_.template Reserve<SizeType>(regex_.stateCount_);
+ state1_.template Reserve<SizeType>(regex_.stateCount_);
+ }
+
+ ~GenericRegexSearch() {
+ Allocator::Free(stateSet_);
+ CEREAL_RAPIDJSON_DELETE(ownAllocator_);
+ }
+
template <typename InputStream>
- bool SearchWithAnchoring(InputStream& is, bool anchorBegin, bool anchorEnd) const {
- CEREAL_RAPIDJSON_ASSERT(IsValid());
- DecodedStream<InputStream> ds(is);
+ bool Match(InputStream& is) {
+ return SearchWithAnchoring(is, true, true);
+ }
+
+ bool Match(const Ch* s) {
+ GenericStringStream<Encoding> is(s);
+ return Match(is);
+ }
+
+ template <typename InputStream>
+ bool Search(InputStream& is) {
+ return SearchWithAnchoring(is, regex_.anchorBegin_, regex_.anchorEnd_);
+ }
+
+ bool Search(const Ch* s) {
+ GenericStringStream<Encoding> is(s);
+ return Search(is);
+ }
+
+private:
+ typedef typename RegexType::State State;
+ typedef typename RegexType::Range Range;
+
+ template <typename InputStream>
+ bool SearchWithAnchoring(InputStream& is, bool anchorBegin, bool anchorEnd) {
+ DecodedStream<InputStream, Encoding> ds(is);
state0_.Clear();
Stack<Allocator> *current = &state0_, *next = &state1_;
const size_t stateSetSize = GetStateSetSize();
std::memset(stateSet_, 0, stateSetSize);
- bool matched = AddState(*current, root_);
+ bool matched = AddState(*current, regex_.root_);
unsigned codepoint;
while (!current->Empty() && (codepoint = ds.Take()) != 0) {
std::memset(stateSet_, 0, stateSetSize);
next->Clear();
matched = false;
for (const SizeType* s = current->template Bottom<SizeType>(); s != current->template End<SizeType>(); ++s) {
- const State& sr = GetState(*s);
+ const State& sr = regex_.GetState(*s);
if (sr.codepoint == codepoint ||
- sr.codepoint == kAnyCharacterClass ||
- (sr.codepoint == kRangeCharacterClass && MatchRange(sr.rangeStart, codepoint)))
+ sr.codepoint == RegexType::kAnyCharacterClass ||
+ (sr.codepoint == RegexType::kRangeCharacterClass && MatchRange(sr.rangeStart, codepoint)))
{
matched = AddState(*next, sr.out) || matched;
if (!anchorEnd && matched)
return true;
}
if (!anchorBegin)
- AddState(*next, root_);
+ AddState(*next, regex_.root_);
}
internal::Swap(current, next);
}
@@ -639,62 +685,55 @@ private:
}
size_t GetStateSetSize() const {
- return (stateCount_ + 31) / 32 * 4;
+ return (regex_.stateCount_ + 31) / 32 * 4;
}
// Return whether the added states is a match state
- bool AddState(Stack<Allocator>& l, SizeType index) const {
+ bool AddState(Stack<Allocator>& l, SizeType index) {
CEREAL_RAPIDJSON_ASSERT(index != kRegexInvalidState);
- const State& s = GetState(index);
+ const State& s = regex_.GetState(index);
if (s.out1 != kRegexInvalidState) { // Split
bool matched = AddState(l, s.out);
return AddState(l, s.out1) || matched;
}
- else if (!(stateSet_[index >> 5] & (1 << (index & 31)))) {
- stateSet_[index >> 5] |= (1 << (index & 31));
+ else if (!(stateSet_[index >> 5] & (1u << (index & 31)))) {
+ stateSet_[index >> 5] |= (1u << (index & 31));
*l.template PushUnsafe<SizeType>() = index;
}
return s.out == kRegexInvalidState; // by using PushUnsafe() above, we can ensure s is not validated due to reallocation.
}
bool MatchRange(SizeType rangeIndex, unsigned codepoint) const {
- bool yes = (GetRange(rangeIndex).start & kRangeNegationFlag) == 0;
+ bool yes = (regex_.GetRange(rangeIndex).start & RegexType::kRangeNegationFlag) == 0;
while (rangeIndex != kRegexInvalidRange) {
- const Range& r = GetRange(rangeIndex);
- if (codepoint >= (r.start & ~kRangeNegationFlag) && codepoint <= r.end)
+ const Range& r = regex_.GetRange(rangeIndex);
+ if (codepoint >= (r.start & ~RegexType::kRangeNegationFlag) && codepoint <= r.end)
return yes;
rangeIndex = r.next;
}
return !yes;
}
- Stack<Allocator> states_;
- Stack<Allocator> ranges_;
- SizeType root_;
- SizeType stateCount_;
- SizeType rangeCount_;
-
- static const unsigned kInfinityQuantifier = ~0u;
-
- // For SearchWithAnchoring()
- uint32_t* stateSet_; // allocated by states_.GetAllocator()
- mutable Stack<Allocator> state0_;
- mutable Stack<Allocator> state1_;
- bool anchorBegin_;
- bool anchorEnd_;
+ const RegexType& regex_;
+ Allocator* allocator_;
+ Allocator* ownAllocator_;
+ Stack<Allocator> state0_;
+ Stack<Allocator> state1_;
+ uint32_t* stateSet_;
};
typedef GenericRegex<UTF8<> > Regex;
+typedef GenericRegexSearch<Regex> RegexSearch;
} // namespace internal
CEREAL_RAPIDJSON_NAMESPACE_END
-#ifdef __clang__
+#ifdef __GNUC__
CEREAL_RAPIDJSON_DIAG_POP
#endif
-#ifdef _MSC_VER
+#if defined(__clang__) || defined(_MSC_VER)
CEREAL_RAPIDJSON_DIAG_POP
#endif
diff --git a/source/code/Libs/include/cereal/external/rapidjson/internal/stack.h b/source/code/Libs/include/cereal/external/rapidjson/internal/stack.h
index 768551e..be77088 100644
--- a/source/code/Libs/include/cereal/external/rapidjson/internal/stack.h
+++ b/source/code/Libs/include/cereal/external/rapidjson/internal/stack.h
@@ -17,6 +17,7 @@
#include "../allocators.h"
#include "swap.h"
+#include <cstddef>
#if defined(__clang__)
CEREAL_RAPIDJSON_DIAG_PUSH
@@ -100,7 +101,7 @@ public:
void ShrinkToFit() {
if (Empty()) {
// If the stack is empty, completely deallocate the memory.
- Allocator::Free(stack_);
+ Allocator::Free(stack_); // NOLINT (+clang-analyzer-unix.Malloc)
stack_ = 0;
stackTop_ = 0;
stackEnd_ = 0;
@@ -114,7 +115,7 @@ public:
template<typename T>
CEREAL_RAPIDJSON_FORCEINLINE void Reserve(size_t count = 1) {
// Expand the stack if needed
- if (CEREAL_RAPIDJSON_UNLIKELY(stackTop_ + sizeof(T) * count > stackEnd_))
+ if (CEREAL_RAPIDJSON_UNLIKELY(static_cast<std::ptrdiff_t>(sizeof(T) * count) > (stackEnd_ - stackTop_)))
Expand<T>(count);
}
@@ -126,7 +127,8 @@ public:
template<typename T>
CEREAL_RAPIDJSON_FORCEINLINE T* PushUnsafe(size_t count = 1) {
- CEREAL_RAPIDJSON_ASSERT(stackTop_ + sizeof(T) * count <= stackEnd_);
+ CEREAL_RAPIDJSON_ASSERT(stackTop_);
+ CEREAL_RAPIDJSON_ASSERT(static_cast<std::ptrdiff_t>(sizeof(T) * count) <= (stackEnd_ - stackTop_));
T* ret = reinterpret_cast<T*>(stackTop_);
stackTop_ += sizeof(T) * count;
return ret;
@@ -183,7 +185,7 @@ private:
size_t newCapacity;
if (stack_ == 0) {
if (!allocator_)
- ownAllocator_ = allocator_ = CEREAL_RAPIDJSON_NEW(Allocator());
+ ownAllocator_ = allocator_ = CEREAL_RAPIDJSON_NEW(Allocator)();
newCapacity = initialCapacity_;
} else {
newCapacity = GetCapacity();
diff --git a/source/code/Libs/include/cereal/external/rapidjson/internal/strfunc.h b/source/code/Libs/include/cereal/external/rapidjson/internal/strfunc.h
index 0c6973c..44af229 100644
--- a/source/code/Libs/include/cereal/external/rapidjson/internal/strfunc.h
+++ b/source/code/Libs/include/cereal/external/rapidjson/internal/strfunc.h
@@ -16,6 +16,7 @@
#define CEREAL_RAPIDJSON_INTERNAL_STRFUNC_H_
#include "../stream.h"
+#include <cwchar>
CEREAL_RAPIDJSON_NAMESPACE_BEGIN
namespace internal {
@@ -28,14 +29,27 @@ namespace internal {
*/
template <typename Ch>
inline SizeType StrLen(const Ch* s) {
+ CEREAL_RAPIDJSON_ASSERT(s != 0);
const Ch* p = s;
while (*p) ++p;
return SizeType(p - s);
}
+template <>
+inline SizeType StrLen(const char* s) {
+ return SizeType(std::strlen(s));
+}
+
+template <>
+inline SizeType StrLen(const wchar_t* s) {
+ return SizeType(std::wcslen(s));
+}
+
//! Returns number of code points in a encoded string.
template<typename Encoding>
bool CountStringCodePoint(const typename Encoding::Ch* s, SizeType length, SizeType* outCount) {
+ CEREAL_RAPIDJSON_ASSERT(s != 0);
+ CEREAL_RAPIDJSON_ASSERT(outCount != 0);
GenericStringStream<Encoding> is(s);
const typename Encoding::Ch* end = s + length;
SizeType count = 0;
diff --git a/source/code/Libs/include/cereal/external/rapidjson/internal/strtod.h b/source/code/Libs/include/cereal/external/rapidjson/internal/strtod.h
index 076434c..d60c740 100644
--- a/source/code/Libs/include/cereal/external/rapidjson/internal/strtod.h
+++ b/source/code/Libs/include/cereal/external/rapidjson/internal/strtod.h
@@ -19,6 +19,8 @@
#include "biginteger.h"
#include "diyfp.h"
#include "pow10.h"
+#include <climits>
+#include <limits>
CEREAL_RAPIDJSON_NAMESPACE_BEGIN
namespace internal {
@@ -126,46 +128,46 @@ inline bool StrtodFast(double d, int p, double* result) {
}
// Compute an approximation and see if it is within 1/2 ULP
-inline bool StrtodDiyFp(const char* decimals, size_t length, size_t decimalPosition, int exp, double* result) {
+inline bool StrtodDiyFp(const char* decimals, int dLen, int dExp, double* result) {
uint64_t significand = 0;
- size_t i = 0; // 2^64 - 1 = 18446744073709551615, 1844674407370955161 = 0x1999999999999999
- for (; i < length; i++) {
+ int i = 0; // 2^64 - 1 = 18446744073709551615, 1844674407370955161 = 0x1999999999999999
+ for (; i < dLen; i++) {
if (significand > CEREAL_RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) ||
(significand == CEREAL_RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) && decimals[i] > '5'))
break;
significand = significand * 10u + static_cast<unsigned>(decimals[i] - '0');
}
- if (i < length && decimals[i] >= '5') // Rounding
+ if (i < dLen && decimals[i] >= '5') // Rounding
significand++;
- size_t remaining = length - i;
- const unsigned kUlpShift = 3;
- const unsigned kUlp = 1 << kUlpShift;
+ int remaining = dLen - i;
+ const int kUlpShift = 3;
+ const int kUlp = 1 << kUlpShift;
int64_t error = (remaining == 0) ? 0 : kUlp / 2;
DiyFp v(significand, 0);
v = v.Normalize();
error <<= -v.e;
- const int dExp = static_cast<int>(decimalPosition) - static_cast<int>(i) + exp;
+ dExp += remaining;
int actualExp;
DiyFp cachedPower = GetCachedPower10(dExp, &actualExp);
if (actualExp != dExp) {
static const DiyFp kPow10[] = {
- DiyFp(CEREAL_RAPIDJSON_UINT64_C2(0xa0000000, 00000000), -60), // 10^1
- DiyFp(CEREAL_RAPIDJSON_UINT64_C2(0xc8000000, 00000000), -57), // 10^2
- DiyFp(CEREAL_RAPIDJSON_UINT64_C2(0xfa000000, 00000000), -54), // 10^3
- DiyFp(CEREAL_RAPIDJSON_UINT64_C2(0x9c400000, 00000000), -50), // 10^4
- DiyFp(CEREAL_RAPIDJSON_UINT64_C2(0xc3500000, 00000000), -47), // 10^5
- DiyFp(CEREAL_RAPIDJSON_UINT64_C2(0xf4240000, 00000000), -44), // 10^6
- DiyFp(CEREAL_RAPIDJSON_UINT64_C2(0x98968000, 00000000), -40) // 10^7
+ DiyFp(CEREAL_RAPIDJSON_UINT64_C2(0xa0000000, 0x00000000), -60), // 10^1
+ DiyFp(CEREAL_RAPIDJSON_UINT64_C2(0xc8000000, 0x00000000), -57), // 10^2
+ DiyFp(CEREAL_RAPIDJSON_UINT64_C2(0xfa000000, 0x00000000), -54), // 10^3
+ DiyFp(CEREAL_RAPIDJSON_UINT64_C2(0x9c400000, 0x00000000), -50), // 10^4
+ DiyFp(CEREAL_RAPIDJSON_UINT64_C2(0xc3500000, 0x00000000), -47), // 10^5
+ DiyFp(CEREAL_RAPIDJSON_UINT64_C2(0xf4240000, 0x00000000), -44), // 10^6
+ DiyFp(CEREAL_RAPIDJSON_UINT64_C2(0x98968000, 0x00000000), -40) // 10^7
};
- int adjustment = dExp - actualExp - 1;
- CEREAL_RAPIDJSON_ASSERT(adjustment >= 0 && adjustment < 7);
- v = v * kPow10[adjustment];
- if (length + static_cast<unsigned>(adjustment)> 19u) // has more digits than decimal digits in 64-bit
+ int adjustment = dExp - actualExp;
+ CEREAL_RAPIDJSON_ASSERT(adjustment >= 1 && adjustment < 8);
+ v = v * kPow10[adjustment - 1];
+ if (dLen + adjustment > 19) // has more digits than decimal digits in 64-bit
error += kUlp / 2;
}
@@ -177,17 +179,17 @@ inline bool StrtodDiyFp(const char* decimals, size_t length, size_t decimalPosit
v = v.Normalize();
error <<= oldExp - v.e;
- const unsigned effectiveSignificandSize = Double::EffectiveSignificandSize(64 + v.e);
- unsigned precisionSize = 64 - effectiveSignificandSize;
+ const int effectiveSignificandSize = Double::EffectiveSignificandSize(64 + v.e);
+ int precisionSize = 64 - effectiveSignificandSize;
if (precisionSize + kUlpShift >= 64) {
- unsigned scaleExp = (precisionSize + kUlpShift) - 63;
+ int scaleExp = (precisionSize + kUlpShift) - 63;
v.f >>= scaleExp;
v.e += scaleExp;
- error = (error >> scaleExp) + 1 + static_cast<int>(kUlp);
+ error = (error >> scaleExp) + 1 + kUlp;
precisionSize -= scaleExp;
}
- DiyFp rounded(v.f >> precisionSize, v.e + static_cast<int>(precisionSize));
+ DiyFp rounded(v.f >> precisionSize, v.e + precisionSize);
const uint64_t precisionBits = (v.f & ((uint64_t(1) << precisionSize) - 1)) * kUlp;
const uint64_t halfWay = (uint64_t(1) << (precisionSize - 1)) * kUlp;
if (precisionBits >= halfWay + static_cast<unsigned>(error)) {
@@ -203,9 +205,9 @@ inline bool StrtodDiyFp(const char* decimals, size_t length, size_t decimalPosit
return halfWay - static_cast<unsigned>(error) >= precisionBits || precisionBits >= halfWay + static_cast<unsigned>(error);
}
-inline double StrtodBigInteger(double approx, const char* decimals, size_t length, size_t decimalPosition, int exp) {
- const BigInteger dInt(decimals, length);
- const int dExp = static_cast<int>(decimalPosition) - static_cast<int>(length) + exp;
+inline double StrtodBigInteger(double approx, const char* decimals, int dLen, int dExp) {
+ CEREAL_RAPIDJSON_ASSERT(dLen >= 0);
+ const BigInteger dInt(decimals, static_cast<unsigned>(dLen));
Double a(approx);
int cmp = CheckWithinHalfULP(a.Value(), dInt, dExp);
if (cmp < 0)
@@ -225,42 +227,61 @@ inline double StrtodFullPrecision(double d, int p, const char* decimals, size_t
CEREAL_RAPIDJSON_ASSERT(d >= 0.0);
CEREAL_RAPIDJSON_ASSERT(length >= 1);
- double result;
+ double result = 0.0;
if (StrtodFast(d, p, &result))
return result;
+ CEREAL_RAPIDJSON_ASSERT(length <= INT_MAX);
+ int dLen = static_cast<int>(length);
+
+ CEREAL_RAPIDJSON_ASSERT(length >= decimalPosition);
+ CEREAL_RAPIDJSON_ASSERT(length - decimalPosition <= INT_MAX);
+ int dExpAdjust = static_cast<int>(length - decimalPosition);
+
+ CEREAL_RAPIDJSON_ASSERT(exp >= INT_MIN + dExpAdjust);
+ int dExp = exp - dExpAdjust;
+
+ // Make sure length+dExp does not overflow
+ CEREAL_RAPIDJSON_ASSERT(dExp <= INT_MAX - dLen);
+
// Trim leading zeros
- while (*decimals == '0' && length > 1) {
- length--;
+ while (dLen > 0 && *decimals == '0') {
+ dLen--;
decimals++;
- decimalPosition--;
}
// Trim trailing zeros
- while (decimals[length - 1] == '0' && length > 1) {
- length--;
- decimalPosition--;
- exp++;
+ while (dLen > 0 && decimals[dLen - 1] == '0') {
+ dLen--;
+ dExp++;
+ }
+
+ if (dLen == 0) { // Buffer only contains zeros.
+ return 0.0;
}
// Trim right-most digits
- const int kMaxDecimalDigit = 780;
- if (static_cast<int>(length) > kMaxDecimalDigit) {
- int delta = (static_cast<int>(length) - kMaxDecimalDigit);
- exp += delta;
- decimalPosition -= static_cast<unsigned>(delta);
- length = kMaxDecimalDigit;
+ const int kMaxDecimalDigit = 767 + 1;
+ if (dLen > kMaxDecimalDigit) {
+ dExp += dLen - kMaxDecimalDigit;
+ dLen = kMaxDecimalDigit;
}
- // If too small, underflow to zero
- if (int(length) + exp < -324)
+ // If too small, underflow to zero.
+ // Any x <= 10^-324 is interpreted as zero.
+ if (dLen + dExp <= -324)
return 0.0;
- if (StrtodDiyFp(decimals, length, decimalPosition, exp, &result))
+ // If too large, overflow to infinity.
+ // Any x >= 10^309 is interpreted as +infinity.
+ if (dLen + dExp > 309)
+ return std::numeric_limits<double>::infinity();
+
+ if (StrtodDiyFp(decimals, dLen, dExp, &result))
return result;
// Use approximation from StrtodDiyFp and make adjustment with BigInteger comparison
- return StrtodBigInteger(result, decimals, length, decimalPosition, exp);
+ return StrtodBigInteger(result, decimals, dLen, dExp);
}
} // namespace internal
diff --git a/source/code/Libs/include/cereal/external/rapidjson/istreamwrapper.h b/source/code/Libs/include/cereal/external/rapidjson/istreamwrapper.h
index e1c7ea8..4df7ce3 100644
--- a/source/code/Libs/include/cereal/external/rapidjson/istreamwrapper.h
+++ b/source/code/Libs/include/cereal/external/rapidjson/istreamwrapper.h
@@ -1,5 +1,5 @@
// Tencent is pleased to support the open source community by making RapidJSON available.
-//
+//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
@@ -7,9 +7,9 @@
//
// http://opensource.org/licenses/MIT
//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
// specific language governing permissions and limitations under the License.
#ifndef CEREAL_RAPIDJSON_ISTREAMWRAPPER_H_
@@ -17,16 +17,14 @@
#include "stream.h"
#include <iosfwd>
+#include <ios>
#ifdef __clang__
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(padded)
-#endif
-
-#ifdef _MSC_VER
+#elif defined(_MSC_VER)
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(4351) // new behavior: elements of array 'array' will be default initialized
-CEREAL_RAPIDJSON_DIAG_OFF(4127) // ignore assert(false) for triggering exception
#endif
CEREAL_RAPIDJSON_NAMESPACE_BEGIN
@@ -46,62 +44,76 @@ CEREAL_RAPIDJSON_NAMESPACE_BEGIN
\tparam StreamType Class derived from \c std::basic_istream.
*/
-
+
template <typename StreamType>
class BasicIStreamWrapper {
public:
typedef typename StreamType::char_type Ch;
- BasicIStreamWrapper(StreamType& stream) : stream_(stream), count_(), peekBuffer_() {}
- Ch Peek() const {
- typename StreamType::int_type c = stream_.peek();
- return CEREAL_RAPIDJSON_LIKELY(c != StreamType::traits_type::eof()) ? static_cast<Ch>(c) : '\0';
+ //! Constructor.
+ /*!
+ \param stream stream opened for read.
+ */
+ BasicIStreamWrapper(StreamType &stream) : stream_(stream), buffer_(peekBuffer_), bufferSize_(4), bufferLast_(0), current_(buffer_), readCount_(0), count_(0), eof_(false) {
+ Read();
}
- Ch Take() {
- typename StreamType::int_type c = stream_.get();
- if (CEREAL_RAPIDJSON_LIKELY(c != StreamType::traits_type::eof())) {
- count_++;
- return static_cast<Ch>(c);
- }
- else
- return '\0';
+ //! Constructor.
+ /*!
+ \param stream stream opened for read.
+ \param buffer user-supplied buffer.
+ \param bufferSize size of buffer in bytes. Must >=4 bytes.
+ */
+ BasicIStreamWrapper(StreamType &stream, char* buffer, size_t bufferSize) : stream_(stream), buffer_(buffer), bufferSize_(bufferSize), bufferLast_(0), current_(buffer_), readCount_(0), count_(0), eof_(false) {
+ CEREAL_RAPIDJSON_ASSERT(bufferSize >= 4);
+ Read();
}
- // tellg() may return -1 when failed. So we count by ourself.
- size_t Tell() const { return count_; }
+ Ch Peek() const { return *current_; }
+ Ch Take() { Ch c = *current_; Read(); return c; }
+ size_t Tell() const { return count_ + static_cast<size_t>(current_ - buffer_); }
- Ch* PutBegin() { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
+ // Not implemented
void Put(Ch) { CEREAL_RAPIDJSON_ASSERT(false); }
- void Flush() { CEREAL_RAPIDJSON_ASSERT(false); }
+ void Flush() { CEREAL_RAPIDJSON_ASSERT(false); }
+ Ch* PutBegin() { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
size_t PutEnd(Ch*) { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
// For encoding detection only.
const Ch* Peek4() const {
- CEREAL_RAPIDJSON_ASSERT(sizeof(Ch) == 1); // Only usable for byte stream.
- int i;
- bool hasError = false;
- for (i = 0; i < 4; ++i) {
- typename StreamType::int_type c = stream_.get();
- if (c == StreamType::traits_type::eof()) {
- hasError = true;
- stream_.clear();
- break;
- }
- peekBuffer_[i] = static_cast<Ch>(c);
- }
- for (--i; i >= 0; --i)
- stream_.putback(peekBuffer_[i]);
- return !hasError ? peekBuffer_ : 0;
+ return (current_ + 4 - !eof_ <= bufferLast_) ? current_ : 0;
}
private:
+ BasicIStreamWrapper();
BasicIStreamWrapper(const BasicIStreamWrapper&);
BasicIStreamWrapper& operator=(const BasicIStreamWrapper&);
- StreamType& stream_;
- size_t count_; //!< Number of characters read. Note:
- mutable Ch peekBuffer_[4];
+ void Read() {
+ if (current_ < bufferLast_)
+ ++current_;
+ else if (!eof_) {
+ count_ += readCount_;
+ readCount_ = bufferSize_;
+ bufferLast_ = buffer_ + readCount_ - 1;
+ current_ = buffer_;
+
+ if (!stream_.read(buffer_, static_cast<std::streamsize>(bufferSize_))) {
+ readCount_ = static_cast<size_t>(stream_.gcount());
+ *(bufferLast_ = buffer_ + readCount_) = '\0';
+ eof_ = true;
+ }
+ }
+ }
+
+ StreamType &stream_;
+ Ch peekBuffer_[4], *buffer_;
+ size_t bufferSize_;
+ Ch *bufferLast_;
+ Ch *current_;
+ size_t readCount_;
+ size_t count_; //!< Number of characters read
+ bool eof_;
};
typedef BasicIStreamWrapper<std::istream> IStreamWrapper;
diff --git a/source/code/Libs/include/cereal/external/rapidjson/memorystream.h b/source/code/Libs/include/cereal/external/rapidjson/memorystream.h
index e48988c..326bda5 100644
--- a/source/code/Libs/include/cereal/external/rapidjson/memorystream.h
+++ b/source/code/Libs/include/cereal/external/rapidjson/memorystream.h
@@ -1,5 +1,5 @@
// Tencent is pleased to support the open source community by making RapidJSON available.
-//
+//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
@@ -7,9 +7,9 @@
//
// http://opensource.org/licenses/MIT
//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
// specific language governing permissions and limitations under the License.
#ifndef CEREAL_RAPIDJSON_MEMORYSTREAM_H_
@@ -23,11 +23,6 @@ CEREAL_RAPIDJSON_DIAG_OFF(unreachable-code)
CEREAL_RAPIDJSON_DIAG_OFF(missing-noreturn)
#endif
-#ifdef _MSC_VER
-CEREAL_RAPIDJSON_DIAG_PUSH
-CEREAL_RAPIDJSON_DIAG_OFF( 4127 ) // ignore assert(false) for triggering exception
-#endif
-
CEREAL_RAPIDJSON_NAMESPACE_BEGIN
//! Represents an in-memory input byte stream.
@@ -69,7 +64,7 @@ struct MemoryStream {
CEREAL_RAPIDJSON_NAMESPACE_END
-#if defined(__clang__) || defined(_MSC_VER)
+#ifdef __clang__
CEREAL_RAPIDJSON_DIAG_POP
#endif
diff --git a/source/code/Libs/include/cereal/external/rapidjson/pointer.h b/source/code/Libs/include/cereal/external/rapidjson/pointer.h
index 1e4836c..930970f 100644
--- a/source/code/Libs/include/cereal/external/rapidjson/pointer.h
+++ b/source/code/Libs/include/cereal/external/rapidjson/pointer.h
@@ -21,9 +21,7 @@
#ifdef __clang__
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(switch-enum)
-#endif
-
-#ifdef _MSC_VER
+#elif defined(_MSC_VER)
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated
#endif
@@ -165,7 +163,12 @@ public:
GenericPointer(const Token* tokens, size_t tokenCount) : allocator_(), ownAllocator_(), nameBuffer_(), tokens_(const_cast<Token*>(tokens)), tokenCount_(tokenCount), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {}
//! Copy constructor.
- GenericPointer(const GenericPointer& rhs, Allocator* allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
+ GenericPointer(const GenericPointer& rhs) : allocator_(rhs.allocator_), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
+ *this = rhs;
+ }
+
+ //! Copy constructor.
+ GenericPointer(const GenericPointer& rhs, Allocator* allocator) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
*this = rhs;
}
@@ -197,6 +200,36 @@ public:
return *this;
}
+ //! Swap the content of this pointer with an other.
+ /*!
+ \param other The pointer to swap with.
+ \note Constant complexity.
+ */
+ GenericPointer& Swap(GenericPointer& other) CEREAL_RAPIDJSON_NOEXCEPT {
+ internal::Swap(allocator_, other.allocator_);
+ internal::Swap(ownAllocator_, other.ownAllocator_);
+ internal::Swap(nameBuffer_, other.nameBuffer_);
+ internal::Swap(tokens_, other.tokens_);
+ internal::Swap(tokenCount_, other.tokenCount_);
+ internal::Swap(parseErrorOffset_, other.parseErrorOffset_);
+ internal::Swap(parseErrorCode_, other.parseErrorCode_);
+ return *this;
+ }
+
+ //! free-standing swap function helper
+ /*!
+ Helper function to enable support for common swap implementation pattern based on \c std::swap:
+ \code
+ void swap(MyClass& a, MyClass& b) {
+ using std::swap;
+ swap(a.pointer, b.pointer);
+ // ...
+ }
+ \endcode
+ \see Swap()
+ */
+ friend inline void swap(GenericPointer& a, GenericPointer& b) CEREAL_RAPIDJSON_NOEXCEPT { a.Swap(b); }
+
//@}
//!@name Append token
@@ -240,7 +273,7 @@ public:
template <typename T>
CEREAL_RAPIDJSON_DISABLEIF_RETURN((internal::NotExpr<internal::IsSame<typename internal::RemoveConst<T>::Type, Ch> >), (GenericPointer))
Append(T* name, Allocator* allocator = 0) const {
- return Append(name, StrLen(name), allocator);
+ return Append(name, internal::StrLen(name), allocator);
}
#if CEREAL_RAPIDJSON_HAS_STDSTRING
@@ -274,7 +307,7 @@ public:
else {
Ch name[21];
for (size_t i = 0; i <= length; i++)
- name[i] = buffer[i];
+ name[i] = static_cast<Ch>(buffer[i]);
Token token = { name, length, index };
return Append(token, allocator);
}
@@ -353,6 +386,33 @@ public:
*/
bool operator!=(const GenericPointer& rhs) const { return !(*this == rhs); }
+ //! Less than operator.
+ /*!
+ \note Invalid pointers are always greater than valid ones.
+ */
+ bool operator<(const GenericPointer& rhs) const {
+ if (!IsValid())
+ return false;
+ if (!rhs.IsValid())
+ return true;
+
+ if (tokenCount_ != rhs.tokenCount_)
+ return tokenCount_ < rhs.tokenCount_;
+
+ for (size_t i = 0; i < tokenCount_; i++) {
+ if (tokens_[i].index != rhs.tokens_[i].index)
+ return tokens_[i].index < rhs.tokens_[i].index;
+
+ if (tokens_[i].length != rhs.tokens_[i].length)
+ return tokens_[i].length < rhs.tokens_[i].length;
+
+ if (int cmp = std::memcmp(tokens_[i].name, rhs.tokens_[i].name, sizeof(Ch) * tokens_[i].length))
+ return cmp < 0;
+ }
+
+ return false;
+ }
+
//@}
//!@name Stringify
@@ -532,14 +592,14 @@ public:
*/
ValueType& GetWithDefault(ValueType& root, const ValueType& defaultValue, typename ValueType::AllocatorType& allocator) const {
bool alreadyExist;
- Value& v = Create(root, allocator, &alreadyExist);
+ ValueType& v = Create(root, allocator, &alreadyExist);
return alreadyExist ? v : v.CopyFrom(defaultValue, allocator);
}
//! Query a value in a subtree with default null-terminated string.
ValueType& GetWithDefault(ValueType& root, const Ch* defaultValue, typename ValueType::AllocatorType& allocator) const {
bool alreadyExist;
- Value& v = Create(root, allocator, &alreadyExist);
+ ValueType& v = Create(root, allocator, &alreadyExist);
return alreadyExist ? v : v.SetString(defaultValue, allocator);
}
@@ -547,7 +607,7 @@ public:
//! Query a value in a subtree with default std::basic_string.
ValueType& GetWithDefault(ValueType& root, const std::basic_string<Ch>& defaultValue, typename ValueType::AllocatorType& allocator) const {
bool alreadyExist;
- Value& v = Create(root, allocator, &alreadyExist);
+ ValueType& v = Create(root, allocator, &alreadyExist);
return alreadyExist ? v : v.SetString(defaultValue, allocator);
}
#endif
@@ -758,7 +818,7 @@ private:
*/
Ch* CopyFromRaw(const GenericPointer& rhs, size_t extraToken = 0, size_t extraNameBufferSize = 0) {
if (!allocator_) // allocator is independently owned.
- ownAllocator_ = allocator_ = CEREAL_RAPIDJSON_NEW(Allocator());
+ ownAllocator_ = allocator_ = CEREAL_RAPIDJSON_NEW(Allocator)();
size_t nameBufferSize = rhs.tokenCount_; // null terminators for tokens
for (Token *t = rhs.tokens_; t != rhs.tokens_ + rhs.tokenCount_; ++t)
@@ -806,7 +866,7 @@ private:
// Create own allocator if user did not supply.
if (!allocator_)
- ownAllocator_ = allocator_ = CEREAL_RAPIDJSON_NEW(Allocator());
+ ownAllocator_ = allocator_ = CEREAL_RAPIDJSON_NEW(Allocator)();
// Count number of '/' as tokenCount
tokenCount_ = 0;
@@ -1029,8 +1089,8 @@ private:
unsigned char u = static_cast<unsigned char>(c);
static const char hexDigits[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
os_.Put('%');
- os_.Put(hexDigits[u >> 4]);
- os_.Put(hexDigits[u & 15]);
+ os_.Put(static_cast<typename OutputStream::Ch>(hexDigits[u >> 4]));
+ os_.Put(static_cast<typename OutputStream::Ch>(hexDigits[u & 15]));
}
private:
OutputStream& os_;
@@ -1347,11 +1407,7 @@ bool EraseValueByPointer(T& root, const CharType(&source)[N]) {
CEREAL_RAPIDJSON_NAMESPACE_END
-#ifdef __clang__
-CEREAL_RAPIDJSON_DIAG_POP
-#endif
-
-#ifdef _MSC_VER
+#if defined(__clang__) || defined(_MSC_VER)
CEREAL_RAPIDJSON_DIAG_POP
#endif
diff --git a/source/code/Libs/include/cereal/external/rapidjson/prettywriter.h b/source/code/Libs/include/cereal/external/rapidjson/prettywriter.h
index 50a24fc..0c2beb4 100644
--- a/source/code/Libs/include/cereal/external/rapidjson/prettywriter.h
+++ b/source/code/Libs/include/cereal/external/rapidjson/prettywriter.h
@@ -22,6 +22,11 @@ CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(effc++)
#endif
+#if defined(__clang__)
+CEREAL_RAPIDJSON_DIAG_PUSH
+CEREAL_RAPIDJSON_DIAG_OFF(c++98-compat)
+#endif
+
CEREAL_RAPIDJSON_NAMESPACE_BEGIN
//! Combination of PrettyWriter format flags.
@@ -34,7 +39,7 @@ enum PrettyFormatOptions {
//! Writer with indentation and spacing.
/*!
- \tparam OutputStream Type of ouptut os.
+ \tparam OutputStream Type of output os.
\tparam SourceEncoding Encoding of source string.
\tparam TargetEncoding Encoding of output stream.
\tparam StackAllocator Type of allocator for allocating memory of stack.
@@ -42,7 +47,7 @@ enum PrettyFormatOptions {
template<typename OutputStream, typename SourceEncoding = UTF8<>, typename TargetEncoding = UTF8<>, typename StackAllocator = CrtAllocator, unsigned writeFlags = kWriteDefaultFlags>
class PrettyWriter : public Writer<OutputStream, SourceEncoding, TargetEncoding, StackAllocator, writeFlags> {
public:
- typedef Writer<OutputStream, SourceEncoding, TargetEncoding, StackAllocator> Base;
+ typedef Writer<OutputStream, SourceEncoding, TargetEncoding, StackAllocator, writeFlags> Base;
typedef typename Base::Ch Ch;
//! Constructor
@@ -57,6 +62,11 @@ public:
explicit PrettyWriter(StackAllocator* allocator = 0, size_t levelDepth = Base::kDefaultLevelDepth) :
Base(allocator, levelDepth), indentChar_(' '), indentCharCount_(4) {}
+#if CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS
+ PrettyWriter(PrettyWriter&& rhs) :
+ Base(std::forward<PrettyWriter>(rhs)), indentChar_(rhs.indentChar_), indentCharCount_(rhs.indentCharCount_), formatOptions_(rhs.formatOptions_) {}
+#endif
+
//! Set custom indentation.
/*! \param indentChar Character for indentation. Must be whitespace character (' ', '\\t', '\\n', '\\r').
\param indentCharCount Number of indent characters for each indentation level.
@@ -82,24 +92,26 @@ public:
*/
//@{
- bool Null() { PrettyPrefix(kNullType); return Base::WriteNull(); }
- bool Bool(bool b) { PrettyPrefix(b ? kTrueType : kFalseType); return Base::WriteBool(b); }
- bool Int(int i) { PrettyPrefix(kNumberType); return Base::WriteInt(i); }
- bool Uint(unsigned u) { PrettyPrefix(kNumberType); return Base::WriteUint(u); }
- bool Int64(int64_t i64) { PrettyPrefix(kNumberType); return Base::WriteInt64(i64); }
- bool Uint64(uint64_t u64) { PrettyPrefix(kNumberType); return Base::WriteUint64(u64); }
- bool Double(double d) { PrettyPrefix(kNumberType); return Base::WriteDouble(d); }
+ bool Null() { PrettyPrefix(kNullType); return Base::EndValue(Base::WriteNull()); }
+ bool Bool(bool b) { PrettyPrefix(b ? kTrueType : kFalseType); return Base::EndValue(Base::WriteBool(b)); }
+ bool Int(int i) { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteInt(i)); }
+ bool Uint(unsigned u) { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteUint(u)); }
+ bool Int64(int64_t i64) { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteInt64(i64)); }
+ bool Uint64(uint64_t u64) { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteUint64(u64)); }
+ bool Double(double d) { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteDouble(d)); }
bool RawNumber(const Ch* str, SizeType length, bool copy = false) {
+ CEREAL_RAPIDJSON_ASSERT(str != 0);
(void)copy;
PrettyPrefix(kNumberType);
- return Base::WriteString(str, length);
+ return Base::EndValue(Base::WriteString(str, length));
}
bool String(const Ch* str, SizeType length, bool copy = false) {
+ CEREAL_RAPIDJSON_ASSERT(str != 0);
(void)copy;
PrettyPrefix(kStringType);
- return Base::WriteString(str, length);
+ return Base::EndValue(Base::WriteString(str, length));
}
#if CEREAL_RAPIDJSON_HAS_STDSTRING
@@ -124,19 +136,21 @@ public:
bool EndObject(SizeType memberCount = 0) {
(void)memberCount;
- CEREAL_RAPIDJSON_ASSERT(Base::level_stack_.GetSize() >= sizeof(typename Base::Level));
- CEREAL_RAPIDJSON_ASSERT(!Base::level_stack_.template Top<typename Base::Level>()->inArray);
+ CEREAL_RAPIDJSON_ASSERT(Base::level_stack_.GetSize() >= sizeof(typename Base::Level)); // not inside an Object
+ CEREAL_RAPIDJSON_ASSERT(!Base::level_stack_.template Top<typename Base::Level>()->inArray); // currently inside an Array, not Object
+ CEREAL_RAPIDJSON_ASSERT(0 == Base::level_stack_.template Top<typename Base::Level>()->valueCount % 2); // Object has a Key without a Value
+
bool empty = Base::level_stack_.template Pop<typename Base::Level>(1)->valueCount == 0;
if (!empty) {
Base::os_->Put('\n');
WriteIndent();
}
- bool ret = Base::WriteEndObject();
+ bool ret = Base::EndValue(Base::WriteEndObject());
(void)ret;
CEREAL_RAPIDJSON_ASSERT(ret == true);
if (Base::level_stack_.Empty()) // end of json text
- Base::os_->Flush();
+ Base::Flush();
return true;
}
@@ -156,11 +170,11 @@ public:
Base::os_->Put('\n');
WriteIndent();
}
- bool ret = Base::WriteEndArray();
+ bool ret = Base::EndValue(Base::WriteEndArray());
(void)ret;
CEREAL_RAPIDJSON_ASSERT(ret == true);
if (Base::level_stack_.Empty()) // end of json text
- Base::os_->Flush();
+ Base::Flush();
return true;
}
@@ -184,7 +198,11 @@ public:
\param type Type of the root of json.
\note When using PrettyWriter::RawValue(), the result json may not be indented correctly.
*/
- bool RawValue(const Ch* json, size_t length, Type type) { PrettyPrefix(type); return Base::WriteRawValue(json, length); }
+ bool RawValue(const Ch* json, size_t length, Type type) {
+ CEREAL_RAPIDJSON_ASSERT(json != 0);
+ PrettyPrefix(type);
+ return Base::EndValue(Base::WriteRawValue(json, length));
+ }
protected:
void PrettyPrefix(Type type) {
@@ -233,7 +251,7 @@ protected:
void WriteIndent() {
size_t count = (Base::level_stack_.GetSize() / sizeof(typename Base::Level)) * indentCharCount_;
- PutN(*Base::os_, static_cast<typename TargetEncoding::Ch>(indentChar_), count);
+ PutN(*Base::os_, static_cast<typename OutputStream::Ch>(indentChar_), count);
}
Ch indentChar_;
@@ -248,6 +266,10 @@ private:
CEREAL_RAPIDJSON_NAMESPACE_END
+#if defined(__clang__)
+CEREAL_RAPIDJSON_DIAG_POP
+#endif
+
#ifdef __GNUC__
CEREAL_RAPIDJSON_DIAG_POP
#endif
diff --git a/source/code/Libs/include/cereal/external/rapidjson/rapidjson.h b/source/code/Libs/include/cereal/external/rapidjson/rapidjson.h
index b79023c..3eefe60 100644
--- a/source/code/Libs/include/cereal/external/rapidjson/rapidjson.h
+++ b/source/code/Libs/include/cereal/external/rapidjson/rapidjson.h
@@ -26,7 +26,7 @@
Some RapidJSON features are configurable to adapt the library to a wide
variety of platforms, environments and usage scenarios. Most of the
- features can be configured in terms of overriden or predefined
+ features can be configured in terms of overridden or predefined
preprocessor macros at compile-time.
Some additional customization is available in the \ref CEREAL_RAPIDJSON_ERRORS APIs.
@@ -49,6 +49,11 @@
// token stringification
#define CEREAL_RAPIDJSON_STRINGIFY(x) CEREAL_RAPIDJSON_DO_STRINGIFY(x)
#define CEREAL_RAPIDJSON_DO_STRINGIFY(x) #x
+
+// token concatenation
+#define CEREAL_RAPIDJSON_JOIN(X, Y) CEREAL_RAPIDJSON_DO_JOIN(X, Y)
+#define CEREAL_RAPIDJSON_DO_JOIN(X, Y) CEREAL_RAPIDJSON_DO_JOIN2(X, Y)
+#define CEREAL_RAPIDJSON_DO_JOIN2(X, Y) X##Y
//!@endcond
/*! \def CEREAL_RAPIDJSON_MAJOR_VERSION
@@ -68,8 +73,8 @@
\brief Version of RapidJSON in "<major>.<minor>.<patch>" string format.
*/
#define CEREAL_RAPIDJSON_MAJOR_VERSION 1
-#define CEREAL_RAPIDJSON_MINOR_VERSION 0
-#define CEREAL_RAPIDJSON_PATCH_VERSION 2
+#define CEREAL_RAPIDJSON_MINOR_VERSION 1
+#define CEREAL_RAPIDJSON_PATCH_VERSION 0
#define CEREAL_RAPIDJSON_VERSION_STRING \
CEREAL_RAPIDJSON_STRINGIFY(CEREAL_RAPIDJSON_MAJOR_VERSION.CEREAL_RAPIDJSON_MINOR_VERSION.CEREAL_RAPIDJSON_PATCH_VERSION)
@@ -214,7 +219,7 @@
# elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
# define CEREAL_RAPIDJSON_ENDIAN CEREAL_RAPIDJSON_BIGENDIAN
# else
-# error Unknown machine endianess detected. User needs to define CEREAL_RAPIDJSON_ENDIAN.
+# error Unknown machine endianness detected. User needs to define CEREAL_RAPIDJSON_ENDIAN.
# endif // __BYTE_ORDER__
// Detect with GLIBC's endian.h
# elif defined(__GLIBC__)
@@ -224,7 +229,7 @@
# elif (__BYTE_ORDER == __BIG_ENDIAN)
# define CEREAL_RAPIDJSON_ENDIAN CEREAL_RAPIDJSON_BIGENDIAN
# else
-# error Unknown machine endianess detected. User needs to define CEREAL_RAPIDJSON_ENDIAN.
+# error Unknown machine endianness detected. User needs to define CEREAL_RAPIDJSON_ENDIAN.
# endif // __GLIBC__
// Detect with _LITTLE_ENDIAN and _BIG_ENDIAN macro
# elif defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN)
@@ -236,12 +241,12 @@
# define CEREAL_RAPIDJSON_ENDIAN CEREAL_RAPIDJSON_BIGENDIAN
# elif defined(__i386__) || defined(__alpha__) || defined(__ia64) || defined(__ia64__) || defined(_M_IX86) || defined(_M_IA64) || defined(_M_ALPHA) || defined(__amd64) || defined(__amd64__) || defined(_M_AMD64) || defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || defined(__bfin__)
# define CEREAL_RAPIDJSON_ENDIAN CEREAL_RAPIDJSON_LITTLEENDIAN
-# elif defined(_MSC_VER) && defined(_M_ARM)
+# elif defined(_MSC_VER) && (defined(_M_ARM) || defined(_M_ARM64))
# define CEREAL_RAPIDJSON_ENDIAN CEREAL_RAPIDJSON_LITTLEENDIAN
# elif defined(CEREAL_RAPIDJSON_DOXYGEN_RUNNING)
# define CEREAL_RAPIDJSON_ENDIAN
# else
-# error Unknown machine endianess detected. User needs to define CEREAL_RAPIDJSON_ENDIAN.
+# error Unknown machine endianness detected. User needs to define CEREAL_RAPIDJSON_ENDIAN.
# endif
#endif // CEREAL_RAPIDJSON_ENDIAN
@@ -264,16 +269,11 @@
/*! \ingroup CEREAL_RAPIDJSON_CONFIG
\param x pointer to align
- Some machines require strict data alignment. Currently the default uses 4 bytes
- alignment on 32-bit platforms and 8 bytes alignment for 64-bit platforms.
+ Some machines require strict data alignment. The default is 8 bytes.
User can customize by defining the CEREAL_RAPIDJSON_ALIGN function macro.
*/
#ifndef CEREAL_RAPIDJSON_ALIGN
-#if CEREAL_RAPIDJSON_64BIT == 1
-#define CEREAL_RAPIDJSON_ALIGN(x) (((x) + static_cast<uint64_t>(7u)) & ~static_cast<uint64_t>(7u))
-#else
-#define CEREAL_RAPIDJSON_ALIGN(x) (((x) + 3u) & ~3u)
-#endif
+#define CEREAL_RAPIDJSON_ALIGN(x) (((x) + static_cast<size_t>(7u)) & ~static_cast<size_t>(7u))
#endif
///////////////////////////////////////////////////////////////////////////////
@@ -320,17 +320,17 @@
#endif
///////////////////////////////////////////////////////////////////////////////
-// CEREAL_RAPIDJSON_SSE2/CEREAL_RAPIDJSON_SSE42/CEREAL_RAPIDJSON_SIMD
+// CEREAL_RAPIDJSON_SSE2/CEREAL_RAPIDJSON_SSE42/CEREAL_RAPIDJSON_NEON/CEREAL_RAPIDJSON_SIMD
/*! \def CEREAL_RAPIDJSON_SIMD
\ingroup CEREAL_RAPIDJSON_CONFIG
- \brief Enable SSE2/SSE4.2 optimization.
+ \brief Enable SSE2/SSE4.2/Neon optimization.
RapidJSON supports optimized implementations for some parsing operations
- based on the SSE2 or SSE4.2 SIMD extensions on modern Intel-compatible
- processors.
+ based on the SSE2, SSE4.2 or NEon SIMD extensions on modern Intel
+ or ARM compatible processors.
- To enable these optimizations, two different symbols can be defined;
+ To enable these optimizations, three different symbols can be defined;
\code
// Enable SSE2 optimization.
#define CEREAL_RAPIDJSON_SSE2
@@ -339,13 +339,17 @@
#define CEREAL_RAPIDJSON_SSE42
\endcode
- \c CEREAL_RAPIDJSON_SSE42 takes precedence, if both are defined.
+ // Enable ARM Neon optimization.
+ #define CEREAL_RAPIDJSON_NEON
+ \endcode
+
+ \c CEREAL_RAPIDJSON_SSE42 takes precedence over SSE2, if both are defined.
If any of these symbols is defined, RapidJSON defines the macro
\c CEREAL_RAPIDJSON_SIMD to indicate the availability of the optimized code.
*/
#if defined(CEREAL_RAPIDJSON_SSE2) || defined(CEREAL_RAPIDJSON_SSE42) \
- || defined(CEREAL_RAPIDJSON_DOXYGEN_RUNNING)
+ || defined(CEREAL_RAPIDJSON_NEON) || defined(CEREAL_RAPIDJSON_DOXYGEN_RUNNING)
#define CEREAL_RAPIDJSON_SIMD
#endif
@@ -405,7 +409,15 @@ CEREAL_RAPIDJSON_NAMESPACE_END
///////////////////////////////////////////////////////////////////////////////
// CEREAL_RAPIDJSON_STATIC_ASSERT
-// Adopt from boost
+// Prefer C++11 static_assert, if available
+#ifndef CEREAL_RAPIDJSON_STATIC_ASSERT
+#if __cplusplus >= 201103L || ( defined(_MSC_VER) && _MSC_VER >= 1800 )
+#define CEREAL_RAPIDJSON_STATIC_ASSERT(x) \
+ static_assert(x, CEREAL_RAPIDJSON_STRINGIFY(x))
+#endif // C++11
+#endif // CEREAL_RAPIDJSON_STATIC_ASSERT
+
+// Adopt C++03 implementation from boost
#ifndef CEREAL_RAPIDJSON_STATIC_ASSERT
#ifndef __clang__
//!@cond CEREAL_RAPIDJSON_HIDDEN_FROM_DOXYGEN
@@ -413,14 +425,10 @@ CEREAL_RAPIDJSON_NAMESPACE_END
CEREAL_RAPIDJSON_NAMESPACE_BEGIN
template <bool x> struct STATIC_ASSERTION_FAILURE;
template <> struct STATIC_ASSERTION_FAILURE<true> { enum { value = 1 }; };
-template<int x> struct StaticAssertTest {};
+template <size_t x> struct StaticAssertTest {};
CEREAL_RAPIDJSON_NAMESPACE_END
-#define CEREAL_RAPIDJSON_JOIN(X, Y) CEREAL_RAPIDJSON_DO_JOIN(X, Y)
-#define CEREAL_RAPIDJSON_DO_JOIN(X, Y) CEREAL_RAPIDJSON_DO_JOIN2(X, Y)
-#define CEREAL_RAPIDJSON_DO_JOIN2(X, Y) X##Y
-
-#if defined(__GNUC__)
+#if defined(__GNUC__) || defined(__clang__)
#define CEREAL_RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE __attribute__((unused))
#else
#define CEREAL_RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE
@@ -438,7 +446,7 @@ CEREAL_RAPIDJSON_NAMESPACE_END
typedef ::CEREAL_RAPIDJSON_NAMESPACE::StaticAssertTest< \
sizeof(::CEREAL_RAPIDJSON_NAMESPACE::STATIC_ASSERTION_FAILURE<bool(x) >)> \
CEREAL_RAPIDJSON_JOIN(StaticAssertTypedef, __LINE__) CEREAL_RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE
-#endif
+#endif // CEREAL_RAPIDJSON_STATIC_ASSERT
///////////////////////////////////////////////////////////////////////////////
// CEREAL_RAPIDJSON_LIKELY, CEREAL_RAPIDJSON_UNLIKELY
@@ -530,13 +538,14 @@ CEREAL_RAPIDJSON_NAMESPACE_END
#ifndef CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS
#if defined(__clang__)
#if __has_feature(cxx_rvalue_references) && \
- (defined(_LIBCPP_VERSION) || defined(__GLIBCXX__) && __GLIBCXX__ >= 20080306)
+ (defined(_MSC_VER) || defined(_LIBCPP_VERSION) || defined(__GLIBCXX__) && __GLIBCXX__ >= 20080306)
#define CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS 1
#else
#define CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS 0
#endif
#elif (defined(CEREAL_RAPIDJSON_GNUC) && (CEREAL_RAPIDJSON_GNUC >= CEREAL_RAPIDJSON_VERSION_CODE(4,3,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \
- (defined(_MSC_VER) && _MSC_VER >= 1600)
+ (defined(_MSC_VER) && _MSC_VER >= 1600) || \
+ (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140 && defined(__GXX_EXPERIMENTAL_CXX0X__))
#define CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS 1
#else
@@ -547,8 +556,9 @@ CEREAL_RAPIDJSON_NAMESPACE_END
#ifndef CEREAL_RAPIDJSON_HAS_CXX11_NOEXCEPT
#if defined(__clang__)
#define CEREAL_RAPIDJSON_HAS_CXX11_NOEXCEPT __has_feature(cxx_noexcept)
-#elif (defined(CEREAL_RAPIDJSON_GNUC) && (CEREAL_RAPIDJSON_GNUC >= CEREAL_RAPIDJSON_VERSION_CODE(4,6,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__))
-// (defined(_MSC_VER) && _MSC_VER >= ????) // not yet supported
+#elif (defined(CEREAL_RAPIDJSON_GNUC) && (CEREAL_RAPIDJSON_GNUC >= CEREAL_RAPIDJSON_VERSION_CODE(4,6,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \
+ (defined(_MSC_VER) && _MSC_VER >= 1900) || \
+ (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140 && defined(__GXX_EXPERIMENTAL_CXX0X__))
#define CEREAL_RAPIDJSON_HAS_CXX11_NOEXCEPT 1
#else
#define CEREAL_RAPIDJSON_HAS_CXX11_NOEXCEPT 0
@@ -562,14 +572,19 @@ CEREAL_RAPIDJSON_NAMESPACE_END
// no automatic detection, yet
#ifndef CEREAL_RAPIDJSON_HAS_CXX11_TYPETRAITS
+#if (defined(_MSC_VER) && _MSC_VER >= 1700)
+#define CEREAL_RAPIDJSON_HAS_CXX11_TYPETRAITS 1
+#else
#define CEREAL_RAPIDJSON_HAS_CXX11_TYPETRAITS 0
#endif
+#endif
#ifndef CEREAL_RAPIDJSON_HAS_CXX11_RANGE_FOR
#if defined(__clang__)
#define CEREAL_RAPIDJSON_HAS_CXX11_RANGE_FOR __has_feature(cxx_range_for)
-#elif (defined(CEREAL_RAPIDJSON_GNUC) && (CEREAL_RAPIDJSON_GNUC >= CEREAL_RAPIDJSON_VERSION_CODE(4,3,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \
- (defined(_MSC_VER) && _MSC_VER >= 1700)
+#elif (defined(CEREAL_RAPIDJSON_GNUC) && (CEREAL_RAPIDJSON_GNUC >= CEREAL_RAPIDJSON_VERSION_CODE(4,6,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \
+ (defined(_MSC_VER) && _MSC_VER >= 1700) || \
+ (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140 && defined(__GXX_EXPERIMENTAL_CXX0X__))
#define CEREAL_RAPIDJSON_HAS_CXX11_RANGE_FOR 1
#else
#define CEREAL_RAPIDJSON_HAS_CXX11_RANGE_FOR 0
@@ -578,12 +593,38 @@ CEREAL_RAPIDJSON_NAMESPACE_END
//!@endcond
+//! Assertion (in non-throwing contexts).
+ /*! \ingroup CEREAL_RAPIDJSON_CONFIG
+ Some functions provide a \c noexcept guarantee, if the compiler supports it.
+ In these cases, the \ref CEREAL_RAPIDJSON_ASSERT macro cannot be overridden to
+ throw an exception. This macro adds a separate customization point for
+ such cases.
+
+ Defaults to C \c assert() (as \ref CEREAL_RAPIDJSON_ASSERT), if \c noexcept is
+ supported, and to \ref CEREAL_RAPIDJSON_ASSERT otherwise.
+ */
+
+///////////////////////////////////////////////////////////////////////////////
+// CEREAL_RAPIDJSON_NOEXCEPT_ASSERT
+
+#ifndef CEREAL_RAPIDJSON_NOEXCEPT_ASSERT
+#ifdef CEREAL_RAPIDJSON_ASSERT_THROWS
+#if CEREAL_RAPIDJSON_HAS_CXX11_NOEXCEPT
+#define CEREAL_RAPIDJSON_NOEXCEPT_ASSERT(x)
+#else
+#define CEREAL_RAPIDJSON_NOEXCEPT_ASSERT(x) CEREAL_RAPIDJSON_ASSERT(x)
+#endif // CEREAL_RAPIDJSON_HAS_CXX11_NOEXCEPT
+#else
+#define CEREAL_RAPIDJSON_NOEXCEPT_ASSERT(x) CEREAL_RAPIDJSON_ASSERT(x)
+#endif // CEREAL_RAPIDJSON_ASSERT_THROWS
+#endif // CEREAL_RAPIDJSON_NOEXCEPT_ASSERT
+
///////////////////////////////////////////////////////////////////////////////
// new/delete
#ifndef CEREAL_RAPIDJSON_NEW
///! customization point for global \c new
-#define CEREAL_RAPIDJSON_NEW(x) new x
+#define CEREAL_RAPIDJSON_NEW(TypeName) new TypeName
#endif
#ifndef CEREAL_RAPIDJSON_DELETE
///! customization point for global \c delete
diff --git a/source/code/Libs/include/cereal/external/rapidjson/reader.h b/source/code/Libs/include/cereal/external/rapidjson/reader.h
index ad8ff33..43eb525 100644
--- a/source/code/Libs/include/cereal/external/rapidjson/reader.h
+++ b/source/code/Libs/include/cereal/external/rapidjson/reader.h
@@ -33,12 +33,8 @@
#include <nmmintrin.h>
#elif defined(CEREAL_RAPIDJSON_SSE2)
#include <emmintrin.h>
-#endif
-
-#ifdef _MSC_VER
-CEREAL_RAPIDJSON_DIAG_PUSH
-CEREAL_RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant
-CEREAL_RAPIDJSON_DIAG_OFF(4702) // unreachable code
+#elif defined(CEREAL_RAPIDJSON_NEON)
+#include <arm_neon.h>
#endif
#ifdef __clang__
@@ -46,6 +42,10 @@ CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(old-style-cast)
CEREAL_RAPIDJSON_DIAG_OFF(padded)
CEREAL_RAPIDJSON_DIAG_OFF(switch-enum)
+#elif defined(_MSC_VER)
+CEREAL_RAPIDJSON_DIAG_PUSH
+CEREAL_RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant
+CEREAL_RAPIDJSON_DIAG_OFF(4702) // unreachable code
#endif
#ifdef __GNUC__
@@ -299,16 +299,9 @@ inline const char *SkipWhitespace_SIMD(const char* p) {
for (;; p += 16) {
const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
- const int r = _mm_cvtsi128_si32(_mm_cmpistrm(w, s, _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_BIT_MASK | _SIDD_NEGATIVE_POLARITY));
- if (r != 0) { // some of characters is non-whitespace
-#ifdef _MSC_VER // Find the index of first non-whitespace
- unsigned long offset;
- _BitScanForward(&offset, r);
- return p + offset;
-#else
- return p + __builtin_ffs(r) - 1;
-#endif
- }
+ const int r = _mm_cmpistri(w, s, _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT | _SIDD_NEGATIVE_POLARITY);
+ if (r != 16) // some of characters is non-whitespace
+ return p + r;
}
}
@@ -325,16 +318,9 @@ inline const char *SkipWhitespace_SIMD(const char* p, const char* end) {
for (; p <= end - 16; p += 16) {
const __m128i s = _mm_loadu_si128(reinterpret_cast<const __m128i *>(p));
- const int r = _mm_cvtsi128_si32(_mm_cmpistrm(w, s, _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_BIT_MASK | _SIDD_NEGATIVE_POLARITY));
- if (r != 0) { // some of characters is non-whitespace
-#ifdef _MSC_VER // Find the index of first non-whitespace
- unsigned long offset;
- _BitScanForward(&offset, r);
- return p + offset;
-#else
- return p + __builtin_ffs(r) - 1;
-#endif
- }
+ const int r = _mm_cmpistri(w, s, _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT | _SIDD_NEGATIVE_POLARITY);
+ if (r != 16) // some of characters is non-whitespace
+ return p + r;
}
return SkipWhitespace(p, end);
@@ -425,7 +411,92 @@ inline const char *SkipWhitespace_SIMD(const char* p, const char* end) {
return SkipWhitespace(p, end);
}
-#endif // CEREAL_RAPIDJSON_SSE2
+#elif defined(CEREAL_RAPIDJSON_NEON)
+
+//! Skip whitespace with ARM Neon instructions, testing 16 8-byte characters at once.
+inline const char *SkipWhitespace_SIMD(const char* p) {
+ // Fast return for single non-whitespace
+ if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
+ ++p;
+ else
+ return p;
+
+ // 16-byte align to the next boundary
+ const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
+ while (p != nextAligned)
+ if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
+ ++p;
+ else
+ return p;
+
+ const uint8x16_t w0 = vmovq_n_u8(' ');
+ const uint8x16_t w1 = vmovq_n_u8('\n');
+ const uint8x16_t w2 = vmovq_n_u8('\r');
+ const uint8x16_t w3 = vmovq_n_u8('\t');
+
+ for (;; p += 16) {
+ const uint8x16_t s = vld1q_u8(reinterpret_cast<const uint8_t *>(p));
+ uint8x16_t x = vceqq_u8(s, w0);
+ x = vorrq_u8(x, vceqq_u8(s, w1));
+ x = vorrq_u8(x, vceqq_u8(s, w2));
+ x = vorrq_u8(x, vceqq_u8(s, w3));
+
+ x = vmvnq_u8(x); // Negate
+ x = vrev64q_u8(x); // Rev in 64
+ uint64_t low = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 0); // extract
+ uint64_t high = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 1); // extract
+
+ if (low == 0) {
+ if (high != 0) {
+ int lz =__builtin_clzll(high);;
+ return p + 8 + (lz >> 3);
+ }
+ } else {
+ int lz = __builtin_clzll(low);;
+ return p + (lz >> 3);
+ }
+ }
+}
+
+inline const char *SkipWhitespace_SIMD(const char* p, const char* end) {
+ // Fast return for single non-whitespace
+ if (p != end && (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t'))
+ ++p;
+ else
+ return p;
+
+ const uint8x16_t w0 = vmovq_n_u8(' ');
+ const uint8x16_t w1 = vmovq_n_u8('\n');
+ const uint8x16_t w2 = vmovq_n_u8('\r');
+ const uint8x16_t w3 = vmovq_n_u8('\t');
+
+ for (; p <= end - 16; p += 16) {
+ const uint8x16_t s = vld1q_u8(reinterpret_cast<const uint8_t *>(p));
+ uint8x16_t x = vceqq_u8(s, w0);
+ x = vorrq_u8(x, vceqq_u8(s, w1));
+ x = vorrq_u8(x, vceqq_u8(s, w2));
+ x = vorrq_u8(x, vceqq_u8(s, w3));
+
+ x = vmvnq_u8(x); // Negate
+ x = vrev64q_u8(x); // Rev in 64
+ uint64_t low = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 0); // extract
+ uint64_t high = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 1); // extract
+
+ if (low == 0) {
+ if (high != 0) {
+ int lz = __builtin_clzll(high);
+ return p + 8 + (lz >> 3);
+ }
+ } else {
+ int lz = __builtin_clzll(low);
+ return p + (lz >> 3);
+ }
+ }
+
+ return SkipWhitespace(p, end);
+}
+
+#endif // CEREAL_RAPIDJSON_NEON
#ifdef CEREAL_RAPIDJSON_SIMD
//! Template function specialization for InsituStringStream
@@ -471,7 +542,8 @@ public:
/*! \param stackAllocator Optional allocator for allocating stack memory. (Only use for non-destructive parsing)
\param stackCapacity stack capacity in bytes for storing a single decoded string. (Only use for non-destructive parsing)
*/
- GenericReader(StackAllocator* stackAllocator = 0, size_t stackCapacity = kDefaultStackCapacity) : stack_(stackAllocator, stackCapacity), parseResult_() {}
+ GenericReader(StackAllocator* stackAllocator = 0, size_t stackCapacity = kDefaultStackCapacity) :
+ stack_(stackAllocator, stackCapacity), parseResult_(), state_(IterativeParsingStartState) {}
//! Parse JSON text.
/*! \tparam parseFlags Combination of \ref ParseFlag.
@@ -527,7 +599,84 @@ public:
return Parse<kParseDefaultFlags>(is, handler);
}
- //! Whether a parse error has occured in the last parsing.
+ //! Initialize JSON text token-by-token parsing
+ /*!
+ */
+ void IterativeParseInit() {
+ parseResult_.Clear();
+ state_ = IterativeParsingStartState;
+ }
+
+ //! Parse one token from JSON text
+ /*! \tparam InputStream Type of input stream, implementing Stream concept
+ \tparam Handler Type of handler, implementing Handler concept.
+ \param is Input stream to be parsed.
+ \param handler The handler to receive events.
+ \return Whether the parsing is successful.
+ */
+ template <unsigned parseFlags, typename InputStream, typename Handler>
+ bool IterativeParseNext(InputStream& is, Handler& handler) {
+ while (CEREAL_RAPIDJSON_LIKELY(is.Peek() != '\0')) {
+ SkipWhitespaceAndComments<parseFlags>(is);
+
+ Token t = Tokenize(is.Peek());
+ IterativeParsingState n = Predict(state_, t);
+ IterativeParsingState d = Transit<parseFlags>(state_, t, n, is, handler);
+
+ // If we've finished or hit an error...
+ if (CEREAL_RAPIDJSON_UNLIKELY(IsIterativeParsingCompleteState(d))) {
+ // Report errors.
+ if (d == IterativeParsingErrorState) {
+ HandleError(state_, is);
+ return false;
+ }
+
+ // Transition to the finish state.
+ CEREAL_RAPIDJSON_ASSERT(d == IterativeParsingFinishState);
+ state_ = d;
+
+ // If StopWhenDone is not set...
+ if (!(parseFlags & kParseStopWhenDoneFlag)) {
+ // ... and extra non-whitespace data is found...
+ SkipWhitespaceAndComments<parseFlags>(is);
+ if (is.Peek() != '\0') {
+ // ... this is considered an error.
+ HandleError(state_, is);
+ return false;
+ }
+ }
+
+ // Success! We are done!
+ return true;
+ }
+
+ // Transition to the new state.
+ state_ = d;
+
+ // If we parsed anything other than a delimiter, we invoked the handler, so we can return true now.
+ if (!IsIterativeParsingDelimiterState(n))
+ return true;
+ }
+
+ // We reached the end of file.
+ stack_.Clear();
+
+ if (state_ != IterativeParsingFinishState) {
+ HandleError(state_, is);
+ return false;
+ }
+
+ return true;
+ }
+
+ //! Check if token-by-token parsing JSON text is complete
+ /*! \return Whether the JSON has been fully decoded.
+ */
+ CEREAL_RAPIDJSON_FORCEINLINE bool IterativeParseComplete() const {
+ return IsIterativeParsingCompleteState(state_);
+ }
+
+ //! Whether a parse error has occurred in the last parsing.
bool HasParseError() const { return parseResult_.IsError(); }
//! Get the \ref ParseErrorCode of last parsing.
@@ -575,7 +724,7 @@ private:
}
}
else if (CEREAL_RAPIDJSON_LIKELY(Consume(is, '/')))
- while (is.Peek() != '\0' && is.Take() != '\n');
+ while (is.Peek() != '\0' && is.Take() != '\n') {}
else
CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorUnspecificSyntaxError, is.Tell());
@@ -750,7 +899,7 @@ private:
return false;
}
- // Helper function to parse four hexidecimal digits in \uXXXX in ParseString().
+ // Helper function to parse four hexadecimal digits in \uXXXX in ParseString().
template<typename InputStream>
unsigned ParseHex4(InputStream& is, size_t escapeOffset) {
unsigned codepoint = 0;
@@ -857,7 +1006,7 @@ private:
Ch c = is.Peek();
if (CEREAL_RAPIDJSON_UNLIKELY(c == '\\')) { // Escape
- size_t escapeOffset = is.Tell(); // For invalid escaping, report the inital '\\' as error offset
+ size_t escapeOffset = is.Tell(); // For invalid escaping, report the initial '\\' as error offset
is.Take();
Ch e = is.Peek();
if ((sizeof(Ch) == 1 || unsigned(e) < 256) && CEREAL_RAPIDJSON_LIKELY(escape[static_cast<unsigned char>(e)])) {
@@ -892,7 +1041,7 @@ private:
if (c == '\0')
CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorStringMissQuotationMark, is.Tell());
else
- CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorStringEscapeInvalid, is.Tell());
+ CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorStringInvalidEncoding, is.Tell());
}
else {
size_t offset = is.Tell();
@@ -927,7 +1076,7 @@ private:
// The rest of string using SIMD
static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' };
static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' };
- static const char space[16] = { 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19 };
+ static const char space[16] = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F };
const __m128i dq = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&dquote[0]));
const __m128i bs = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&bslash[0]));
const __m128i sp = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&space[0]));
@@ -936,7 +1085,7 @@ private:
const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
const __m128i t1 = _mm_cmpeq_epi8(s, dq);
const __m128i t2 = _mm_cmpeq_epi8(s, bs);
- const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x19) == 0x19
+ const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x1F) == 0x1F
const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3);
unsigned short r = static_cast<unsigned short>(_mm_movemask_epi8(x));
if (CEREAL_RAPIDJSON_UNLIKELY(r != 0)) { // some of characters is escaped
@@ -948,11 +1097,13 @@ private:
#else
length = static_cast<SizeType>(__builtin_ffs(r) - 1);
#endif
- char* q = reinterpret_cast<char*>(os.Push(length));
- for (size_t i = 0; i < length; i++)
- q[i] = p[i];
+ if (length != 0) {
+ char* q = reinterpret_cast<char*>(os.Push(length));
+ for (size_t i = 0; i < length; i++)
+ q[i] = p[i];
- p += length;
+ p += length;
+ }
break;
}
_mm_storeu_si128(reinterpret_cast<__m128i *>(os.Push(16)), s);
@@ -988,7 +1139,7 @@ private:
// The rest of string using SIMD
static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' };
static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' };
- static const char space[16] = { 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19 };
+ static const char space[16] = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F };
const __m128i dq = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&dquote[0]));
const __m128i bs = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&bslash[0]));
const __m128i sp = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&space[0]));
@@ -997,7 +1148,7 @@ private:
const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
const __m128i t1 = _mm_cmpeq_epi8(s, dq);
const __m128i t2 = _mm_cmpeq_epi8(s, bs);
- const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x19) == 0x19
+ const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x1F) == 0x1F
const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3);
unsigned short r = static_cast<unsigned short>(_mm_movemask_epi8(x));
if (CEREAL_RAPIDJSON_UNLIKELY(r != 0)) { // some of characters is escaped
@@ -1036,7 +1187,7 @@ private:
// The rest of string using SIMD
static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' };
static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' };
- static const char space[16] = { 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19 };
+ static const char space[16] = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F };
const __m128i dq = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&dquote[0]));
const __m128i bs = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&bslash[0]));
const __m128i sp = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&space[0]));
@@ -1045,7 +1196,7 @@ private:
const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
const __m128i t1 = _mm_cmpeq_epi8(s, dq);
const __m128i t2 = _mm_cmpeq_epi8(s, bs);
- const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x19) == 0x19
+ const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x1F) == 0x1F
const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3);
unsigned short r = static_cast<unsigned short>(_mm_movemask_epi8(x));
if (CEREAL_RAPIDJSON_UNLIKELY(r != 0)) { // some of characters is escaped
@@ -1064,7 +1215,180 @@ private:
is.src_ = is.dst_ = p;
}
-#endif
+#elif defined(CEREAL_RAPIDJSON_NEON)
+ // StringStream -> StackStream<char>
+ static CEREAL_RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(StringStream& is, StackStream<char>& os) {
+ const char* p = is.src_;
+
+ // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
+ const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
+ while (p != nextAligned)
+ if (CEREAL_RAPIDJSON_UNLIKELY(*p == '\"') || CEREAL_RAPIDJSON_UNLIKELY(*p == '\\') || CEREAL_RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20)) {
+ is.src_ = p;
+ return;
+ }
+ else
+ os.Put(*p++);
+
+ // The rest of string using SIMD
+ const uint8x16_t s0 = vmovq_n_u8('"');
+ const uint8x16_t s1 = vmovq_n_u8('\\');
+ const uint8x16_t s2 = vmovq_n_u8('\b');
+ const uint8x16_t s3 = vmovq_n_u8(32);
+
+ for (;; p += 16) {
+ const uint8x16_t s = vld1q_u8(reinterpret_cast<const uint8_t *>(p));
+ uint8x16_t x = vceqq_u8(s, s0);
+ x = vorrq_u8(x, vceqq_u8(s, s1));
+ x = vorrq_u8(x, vceqq_u8(s, s2));
+ x = vorrq_u8(x, vcltq_u8(s, s3));
+
+ x = vrev64q_u8(x); // Rev in 64
+ uint64_t low = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 0); // extract
+ uint64_t high = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 1); // extract
+
+ SizeType length = 0;
+ bool escaped = false;
+ if (low == 0) {
+ if (high != 0) {
+ unsigned lz = (unsigned)__builtin_clzll(high);;
+ length = 8 + (lz >> 3);
+ escaped = true;
+ }
+ } else {
+ unsigned lz = (unsigned)__builtin_clzll(low);;
+ length = lz >> 3;
+ escaped = true;
+ }
+ if (CEREAL_RAPIDJSON_UNLIKELY(escaped)) { // some of characters is escaped
+ if (length != 0) {
+ char* q = reinterpret_cast<char*>(os.Push(length));
+ for (size_t i = 0; i < length; i++)
+ q[i] = p[i];
+
+ p += length;
+ }
+ break;
+ }
+ vst1q_u8(reinterpret_cast<uint8_t *>(os.Push(16)), s);
+ }
+
+ is.src_ = p;
+ }
+
+ // InsituStringStream -> InsituStringStream
+ static CEREAL_RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(InsituStringStream& is, InsituStringStream& os) {
+ CEREAL_RAPIDJSON_ASSERT(&is == &os);
+ (void)os;
+
+ if (is.src_ == is.dst_) {
+ SkipUnescapedString(is);
+ return;
+ }
+
+ char* p = is.src_;
+ char *q = is.dst_;
+
+ // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
+ const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
+ while (p != nextAligned)
+ if (CEREAL_RAPIDJSON_UNLIKELY(*p == '\"') || CEREAL_RAPIDJSON_UNLIKELY(*p == '\\') || CEREAL_RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20)) {
+ is.src_ = p;
+ is.dst_ = q;
+ return;
+ }
+ else
+ *q++ = *p++;
+
+ // The rest of string using SIMD
+ const uint8x16_t s0 = vmovq_n_u8('"');
+ const uint8x16_t s1 = vmovq_n_u8('\\');
+ const uint8x16_t s2 = vmovq_n_u8('\b');
+ const uint8x16_t s3 = vmovq_n_u8(32);
+
+ for (;; p += 16, q += 16) {
+ const uint8x16_t s = vld1q_u8(reinterpret_cast<uint8_t *>(p));
+ uint8x16_t x = vceqq_u8(s, s0);
+ x = vorrq_u8(x, vceqq_u8(s, s1));
+ x = vorrq_u8(x, vceqq_u8(s, s2));
+ x = vorrq_u8(x, vcltq_u8(s, s3));
+
+ x = vrev64q_u8(x); // Rev in 64
+ uint64_t low = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 0); // extract
+ uint64_t high = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 1); // extract
+
+ SizeType length = 0;
+ bool escaped = false;
+ if (low == 0) {
+ if (high != 0) {
+ unsigned lz = (unsigned)__builtin_clzll(high);
+ length = 8 + (lz >> 3);
+ escaped = true;
+ }
+ } else {
+ unsigned lz = (unsigned)__builtin_clzll(low);
+ length = lz >> 3;
+ escaped = true;
+ }
+ if (CEREAL_RAPIDJSON_UNLIKELY(escaped)) { // some of characters is escaped
+ for (const char* pend = p + length; p != pend; ) {
+ *q++ = *p++;
+ }
+ break;
+ }
+ vst1q_u8(reinterpret_cast<uint8_t *>(q), s);
+ }
+
+ is.src_ = p;
+ is.dst_ = q;
+ }
+
+ // When read/write pointers are the same for insitu stream, just skip unescaped characters
+ static CEREAL_RAPIDJSON_FORCEINLINE void SkipUnescapedString(InsituStringStream& is) {
+ CEREAL_RAPIDJSON_ASSERT(is.src_ == is.dst_);
+ char* p = is.src_;
+
+ // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
+ const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
+ for (; p != nextAligned; p++)
+ if (CEREAL_RAPIDJSON_UNLIKELY(*p == '\"') || CEREAL_RAPIDJSON_UNLIKELY(*p == '\\') || CEREAL_RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20)) {
+ is.src_ = is.dst_ = p;
+ return;
+ }
+
+ // The rest of string using SIMD
+ const uint8x16_t s0 = vmovq_n_u8('"');
+ const uint8x16_t s1 = vmovq_n_u8('\\');
+ const uint8x16_t s2 = vmovq_n_u8('\b');
+ const uint8x16_t s3 = vmovq_n_u8(32);
+
+ for (;; p += 16) {
+ const uint8x16_t s = vld1q_u8(reinterpret_cast<uint8_t *>(p));
+ uint8x16_t x = vceqq_u8(s, s0);
+ x = vorrq_u8(x, vceqq_u8(s, s1));
+ x = vorrq_u8(x, vceqq_u8(s, s2));
+ x = vorrq_u8(x, vcltq_u8(s, s3));
+
+ x = vrev64q_u8(x); // Rev in 64
+ uint64_t low = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 0); // extract
+ uint64_t high = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 1); // extract
+
+ if (low == 0) {
+ if (high != 0) {
+ int lz = __builtin_clzll(high);
+ p += 8 + (lz >> 3);
+ break;
+ }
+ } else {
+ int lz = __builtin_clzll(low);
+ p += lz >> 3;
+ break;
+ }
+ }
+
+ is.src_ = is.dst_ = p;
+ }
+#endif // CEREAL_RAPIDJSON_NEON
template<typename InputStream, bool backup, bool pushOnTake>
class NumberStream;
@@ -1075,7 +1399,6 @@ private:
typedef typename InputStream::Ch Ch;
NumberStream(GenericReader& reader, InputStream& s) : is(s) { (void)reader; }
- ~NumberStream() {}
CEREAL_RAPIDJSON_FORCEINLINE Ch Peek() const { return is.Peek(); }
CEREAL_RAPIDJSON_FORCEINLINE Ch TakePush() { return is.Take(); }
@@ -1097,7 +1420,6 @@ private:
typedef NumberStream<InputStream, false, false> Base;
public:
NumberStream(GenericReader& reader, InputStream& s) : Base(reader, s), stackStream(reader.stack_) {}
- ~NumberStream() {}
CEREAL_RAPIDJSON_FORCEINLINE Ch TakePush() {
stackStream.Put(static_cast<char>(Base::is.Peek()));
@@ -1124,7 +1446,6 @@ private:
typedef NumberStream<InputStream, true, false> Base;
public:
NumberStream(GenericReader& reader, InputStream& is) : Base(reader, is) {}
- ~NumberStream() {}
CEREAL_RAPIDJSON_FORCEINLINE Ch Take() { return Base::TakePush(); }
};
@@ -1185,18 +1506,27 @@ private:
}
// Parse NaN or Infinity here
else if ((parseFlags & kParseNanAndInfFlag) && CEREAL_RAPIDJSON_LIKELY((s.Peek() == 'I' || s.Peek() == 'N'))) {
- useNanOrInf = true;
- if (CEREAL_RAPIDJSON_LIKELY(Consume(s, 'N') && Consume(s, 'a') && Consume(s, 'N'))) {
- d = std::numeric_limits<double>::quiet_NaN();
+ if (Consume(s, 'N')) {
+ if (Consume(s, 'a') && Consume(s, 'N')) {
+ d = std::numeric_limits<double>::quiet_NaN();
+ useNanOrInf = true;
+ }
}
- else if (CEREAL_RAPIDJSON_LIKELY(Consume(s, 'I') && Consume(s, 'n') && Consume(s, 'f'))) {
- d = (minus ? -std::numeric_limits<double>::infinity() : std::numeric_limits<double>::infinity());
- if (CEREAL_RAPIDJSON_UNLIKELY(s.Peek() == 'i' && !(Consume(s, 'i') && Consume(s, 'n')
- && Consume(s, 'i') && Consume(s, 't') && Consume(s, 'y'))))
- CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
+ else if (CEREAL_RAPIDJSON_LIKELY(Consume(s, 'I'))) {
+ if (Consume(s, 'n') && Consume(s, 'f')) {
+ d = (minus ? -std::numeric_limits<double>::infinity() : std::numeric_limits<double>::infinity());
+ useNanOrInf = true;
+
+ if (CEREAL_RAPIDJSON_UNLIKELY(s.Peek() == 'i' && !(Consume(s, 'i') && Consume(s, 'n')
+ && Consume(s, 'i') && Consume(s, 't') && Consume(s, 'y')))) {
+ CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
+ }
+ }
}
- else
+
+ if (CEREAL_RAPIDJSON_UNLIKELY(!useNanOrInf)) {
CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
+ }
}
else
CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
@@ -1231,8 +1561,6 @@ private:
// Force double for big integer
if (useDouble) {
while (CEREAL_RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
- if (CEREAL_RAPIDJSON_UNLIKELY(d >= 1.7976931348623157e307)) // DBL_MAX / 10.0
- CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, startOffset);
d = d * 10 + (s.TakePush() - '0');
}
}
@@ -1302,9 +1630,18 @@ private:
if (CEREAL_RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
exp = static_cast<int>(s.Take() - '0');
if (expMinus) {
+ // (exp + expFrac) must not underflow int => we're detecting when -exp gets
+ // dangerously close to INT_MIN (a pessimistic next digit 9 would push it into
+ // underflow territory):
+ //
+ // -(exp * 10 + 9) + expFrac >= INT_MIN
+ // <=> exp <= (expFrac - INT_MIN - 9) / 10
+ CEREAL_RAPIDJSON_ASSERT(expFrac <= 0);
+ int maxExp = (expFrac + 2147483639) / 10;
+
while (CEREAL_RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
exp = exp * 10 + static_cast<int>(s.Take() - '0');
- if (exp >= 214748364) { // Issue #313: prevent overflow exponent
+ if (CEREAL_RAPIDJSON_UNLIKELY(exp > maxExp)) {
while (CEREAL_RAPIDJSON_UNLIKELY(s.Peek() >= '0' && s.Peek() <= '9')) // Consume the rest of exponent
s.Take();
}
@@ -1363,6 +1700,13 @@ private:
else
d = internal::StrtodNormalPrecision(d, p);
+ // Use > max, instead of == inf, to fix bogus warning -Wfloat-equal
+ if (d > (std::numeric_limits<double>::max)()) {
+ // Overflow
+ // TODO: internal::StrtodX should report overflow (or underflow)
+ CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, startOffset);
+ }
+
cont = handler.Double(minus ? -d : d);
}
else if (useNanOrInf) {
@@ -1408,29 +1752,31 @@ private:
// States
enum IterativeParsingState {
- IterativeParsingStartState = 0,
- IterativeParsingFinishState,
- IterativeParsingErrorState,
+ IterativeParsingFinishState = 0, // sink states at top
+ IterativeParsingErrorState, // sink states at top
+ IterativeParsingStartState,
// Object states
IterativeParsingObjectInitialState,
IterativeParsingMemberKeyState,
- IterativeParsingKeyValueDelimiterState,
IterativeParsingMemberValueState,
- IterativeParsingMemberDelimiterState,
IterativeParsingObjectFinishState,
// Array states
IterativeParsingArrayInitialState,
IterativeParsingElementState,
- IterativeParsingElementDelimiterState,
IterativeParsingArrayFinishState,
// Single value state
- IterativeParsingValueState
- };
+ IterativeParsingValueState,
+
+ // Delimiter states (at bottom)
+ IterativeParsingElementDelimiterState,
+ IterativeParsingMemberDelimiterState,
+ IterativeParsingKeyValueDelimiterState,
- enum { cIterativeParsingStateCount = IterativeParsingValueState + 1 };
+ cIterativeParsingStateCount
+ };
// Tokens
enum Token {
@@ -1452,7 +1798,7 @@ private:
kTokenCount
};
- CEREAL_RAPIDJSON_FORCEINLINE Token Tokenize(Ch c) {
+ CEREAL_RAPIDJSON_FORCEINLINE Token Tokenize(Ch c) const {
//!@cond CEREAL_RAPIDJSON_HIDDEN_FROM_DOXYGEN
#define N NumberToken
@@ -1479,9 +1825,21 @@ private:
return NumberToken;
}
- CEREAL_RAPIDJSON_FORCEINLINE IterativeParsingState Predict(IterativeParsingState state, Token token) {
+ CEREAL_RAPIDJSON_FORCEINLINE IterativeParsingState Predict(IterativeParsingState state, Token token) const {
// current state x one lookahead token -> new state
static const char G[cIterativeParsingStateCount][kTokenCount] = {
+ // Finish(sink state)
+ {
+ IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
+ IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
+ IterativeParsingErrorState
+ },
+ // Error(sink state)
+ {
+ IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
+ IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
+ IterativeParsingErrorState
+ },
// Start
{
IterativeParsingArrayInitialState, // Left bracket
@@ -1496,18 +1854,6 @@ private:
IterativeParsingValueState, // Null
IterativeParsingValueState // Number
},
- // Finish(sink state)
- {
- IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
- IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
- IterativeParsingErrorState
- },
- // Error(sink state)
- {
- IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
- IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
- IterativeParsingErrorState
- },
// ObjectInitial
{
IterativeParsingErrorState, // Left bracket
@@ -1536,20 +1882,6 @@ private:
IterativeParsingErrorState, // Null
IterativeParsingErrorState // Number
},
- // KeyValueDelimiter
- {
- IterativeParsingArrayInitialState, // Left bracket(push MemberValue state)
- IterativeParsingErrorState, // Right bracket
- IterativeParsingObjectInitialState, // Left curly bracket(push MemberValue state)
- IterativeParsingErrorState, // Right curly bracket
- IterativeParsingErrorState, // Comma
- IterativeParsingErrorState, // Colon
- IterativeParsingMemberValueState, // String
- IterativeParsingMemberValueState, // False
- IterativeParsingMemberValueState, // True
- IterativeParsingMemberValueState, // Null
- IterativeParsingMemberValueState // Number
- },
// MemberValue
{
IterativeParsingErrorState, // Left bracket
@@ -1564,20 +1896,6 @@ private:
IterativeParsingErrorState, // Null
IterativeParsingErrorState // Number
},
- // MemberDelimiter
- {
- IterativeParsingErrorState, // Left bracket
- IterativeParsingErrorState, // Right bracket
- IterativeParsingErrorState, // Left curly bracket
- IterativeParsingObjectFinishState, // Right curly bracket
- IterativeParsingErrorState, // Comma
- IterativeParsingErrorState, // Colon
- IterativeParsingMemberKeyState, // String
- IterativeParsingErrorState, // False
- IterativeParsingErrorState, // True
- IterativeParsingErrorState, // Null
- IterativeParsingErrorState // Number
- },
// ObjectFinish(sink state)
{
IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
@@ -1612,6 +1930,18 @@ private:
IterativeParsingErrorState, // Null
IterativeParsingErrorState // Number
},
+ // ArrayFinish(sink state)
+ {
+ IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
+ IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
+ IterativeParsingErrorState
+ },
+ // Single Value (sink state)
+ {
+ IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
+ IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
+ IterativeParsingErrorState
+ },
// ElementDelimiter
{
IterativeParsingArrayInitialState, // Left bracket(push Element state)
@@ -1626,18 +1956,34 @@ private:
IterativeParsingElementState, // Null
IterativeParsingElementState // Number
},
- // ArrayFinish(sink state)
+ // MemberDelimiter
{
- IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
- IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
- IterativeParsingErrorState
+ IterativeParsingErrorState, // Left bracket
+ IterativeParsingErrorState, // Right bracket
+ IterativeParsingErrorState, // Left curly bracket
+ IterativeParsingObjectFinishState, // Right curly bracket
+ IterativeParsingErrorState, // Comma
+ IterativeParsingErrorState, // Colon
+ IterativeParsingMemberKeyState, // String
+ IterativeParsingErrorState, // False
+ IterativeParsingErrorState, // True
+ IterativeParsingErrorState, // Null
+ IterativeParsingErrorState // Number
},
- // Single Value (sink state)
+ // KeyValueDelimiter
{
- IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
- IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
- IterativeParsingErrorState
- }
+ IterativeParsingArrayInitialState, // Left bracket(push MemberValue state)
+ IterativeParsingErrorState, // Right bracket
+ IterativeParsingObjectInitialState, // Left curly bracket(push MemberValue state)
+ IterativeParsingErrorState, // Right curly bracket
+ IterativeParsingErrorState, // Comma
+ IterativeParsingErrorState, // Colon
+ IterativeParsingMemberValueState, // String
+ IterativeParsingMemberValueState, // False
+ IterativeParsingMemberValueState, // True
+ IterativeParsingMemberValueState, // Null
+ IterativeParsingMemberValueState // Number
+ },
}; // End of G
return static_cast<IterativeParsingState>(G[state][token]);
@@ -1818,6 +2164,14 @@ private:
}
}
+ CEREAL_RAPIDJSON_FORCEINLINE bool IsIterativeParsingDelimiterState(IterativeParsingState s) const {
+ return s >= IterativeParsingElementDelimiterState;
+ }
+
+ CEREAL_RAPIDJSON_FORCEINLINE bool IsIterativeParsingCompleteState(IterativeParsingState s) const {
+ return s <= IterativeParsingErrorState;
+ }
+
template <unsigned parseFlags, typename InputStream, typename Handler>
ParseResult IterativeParse(InputStream& is, Handler& handler) {
parseResult_.Clear();
@@ -1856,6 +2210,7 @@ private:
static const size_t kDefaultStackCapacity = 256; //!< Default stack capacity in bytes for storing a single decoded string.
internal::Stack<StackAllocator> stack_; //!< A stack for storing decoded string temporarily during non-destructive parsing.
ParseResult parseResult_;
+ IterativeParsingState state_;
}; // class GenericReader
//! Reader with UTF8 encoding and default allocator.
@@ -1863,7 +2218,7 @@ typedef GenericReader<UTF8<>, UTF8<> > Reader;
CEREAL_RAPIDJSON_NAMESPACE_END
-#ifdef __clang__
+#if defined(__clang__) || defined(_MSC_VER)
CEREAL_RAPIDJSON_DIAG_POP
#endif
@@ -1872,8 +2227,4 @@ CEREAL_RAPIDJSON_DIAG_POP
CEREAL_RAPIDJSON_DIAG_POP
#endif
-#ifdef _MSC_VER
-CEREAL_RAPIDJSON_DIAG_POP
-#endif
-
#endif // CEREAL_RAPIDJSON_READER_H_
diff --git a/source/code/Libs/include/cereal/external/rapidjson/schema.h b/source/code/Libs/include/cereal/external/rapidjson/schema.h
index 1298755..17366c6 100644
--- a/source/code/Libs/include/cereal/external/rapidjson/schema.h
+++ b/source/code/Libs/include/cereal/external/rapidjson/schema.h
@@ -17,6 +17,7 @@
#include "document.h"
#include "pointer.h"
+#include "stringbuffer.h"
#include <cmath> // abs, floor
#if !defined(CEREAL_RAPIDJSON_SCHEMA_USE_INTERNALREGEX)
@@ -25,7 +26,7 @@
#define CEREAL_RAPIDJSON_SCHEMA_USE_INTERNALREGEX 0
#endif
-#if !CEREAL_RAPIDJSON_SCHEMA_USE_INTERNALREGEX && !defined(CEREAL_RAPIDJSON_SCHEMA_USE_STDREGEX) && (__cplusplus >=201103L || (defined(_MSC_VER) && _MSC_VER >= 1800))
+#if !CEREAL_RAPIDJSON_SCHEMA_USE_INTERNALREGEX && defined(CEREAL_RAPIDJSON_SCHEMA_USE_STDREGEX) && (__cplusplus >=201103L || (defined(_MSC_VER) && _MSC_VER >= 1800))
#define CEREAL_RAPIDJSON_SCHEMA_USE_STDREGEX 1
#else
#define CEREAL_RAPIDJSON_SCHEMA_USE_STDREGEX 0
@@ -62,9 +63,7 @@ CEREAL_RAPIDJSON_DIAG_OFF(weak-vtables)
CEREAL_RAPIDJSON_DIAG_OFF(exit-time-destructors)
CEREAL_RAPIDJSON_DIAG_OFF(c++98-compat-pedantic)
CEREAL_RAPIDJSON_DIAG_OFF(variadic-macros)
-#endif
-
-#ifdef _MSC_VER
+#elif defined(_MSC_VER)
CEREAL_RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated
#endif
@@ -158,6 +157,62 @@ public:
};
///////////////////////////////////////////////////////////////////////////////
+// IValidationErrorHandler
+
+template <typename SchemaType>
+class IValidationErrorHandler {
+public:
+ typedef typename SchemaType::Ch Ch;
+ typedef typename SchemaType::SValue SValue;
+
+ virtual ~IValidationErrorHandler() {}
+
+ virtual void NotMultipleOf(int64_t actual, const SValue& expected) = 0;
+ virtual void NotMultipleOf(uint64_t actual, const SValue& expected) = 0;
+ virtual void NotMultipleOf(double actual, const SValue& expected) = 0;
+ virtual void AboveMaximum(int64_t actual, const SValue& expected, bool exclusive) = 0;
+ virtual void AboveMaximum(uint64_t actual, const SValue& expected, bool exclusive) = 0;
+ virtual void AboveMaximum(double actual, const SValue& expected, bool exclusive) = 0;
+ virtual void BelowMinimum(int64_t actual, const SValue& expected, bool exclusive) = 0;
+ virtual void BelowMinimum(uint64_t actual, const SValue& expected, bool exclusive) = 0;
+ virtual void BelowMinimum(double actual, const SValue& expected, bool exclusive) = 0;
+
+ virtual void TooLong(const Ch* str, SizeType length, SizeType expected) = 0;
+ virtual void TooShort(const Ch* str, SizeType length, SizeType expected) = 0;
+ virtual void DoesNotMatch(const Ch* str, SizeType length) = 0;
+
+ virtual void DisallowedItem(SizeType index) = 0;
+ virtual void TooFewItems(SizeType actualCount, SizeType expectedCount) = 0;
+ virtual void TooManyItems(SizeType actualCount, SizeType expectedCount) = 0;
+ virtual void DuplicateItems(SizeType index1, SizeType index2) = 0;
+
+ virtual void TooManyProperties(SizeType actualCount, SizeType expectedCount) = 0;
+ virtual void TooFewProperties(SizeType actualCount, SizeType expectedCount) = 0;
+ virtual void StartMissingProperties() = 0;
+ virtual void AddMissingProperty(const SValue& name) = 0;
+ virtual bool EndMissingProperties() = 0;
+ virtual void PropertyViolations(ISchemaValidator** subvalidators, SizeType count) = 0;
+ virtual void DisallowedProperty(const Ch* name, SizeType length) = 0;
+
+ virtual void StartDependencyErrors() = 0;
+ virtual void StartMissingDependentProperties() = 0;
+ virtual void AddMissingDependentProperty(const SValue& targetName) = 0;
+ virtual void EndMissingDependentProperties(const SValue& sourceName) = 0;
+ virtual void AddDependencySchemaError(const SValue& souceName, ISchemaValidator* subvalidator) = 0;
+ virtual bool EndDependencyErrors() = 0;
+
+ virtual void DisallowedValue() = 0;
+ virtual void StartDisallowedType() = 0;
+ virtual void AddExpectedType(const typename SchemaType::ValueType& expectedType) = 0;
+ virtual void EndDisallowedType(const typename SchemaType::ValueType& actualType) = 0;
+ virtual void NotAllOf(ISchemaValidator** subvalidators, SizeType count) = 0;
+ virtual void NoneOf(ISchemaValidator** subvalidators, SizeType count) = 0;
+ virtual void NotOneOf(ISchemaValidator** subvalidators, SizeType count) = 0;
+ virtual void Disallowed() = 0;
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
// Hasher
// For comparison of compound value
@@ -261,6 +316,7 @@ template <typename SchemaDocumentType>
struct SchemaValidationContext {
typedef Schema<SchemaDocumentType> SchemaType;
typedef ISchemaStateFactory<SchemaType> SchemaValidatorFactoryType;
+ typedef IValidationErrorHandler<SchemaType> ErrorHandlerType;
typedef typename SchemaType::ValueType ValueType;
typedef typename ValueType::Ch Ch;
@@ -270,8 +326,9 @@ struct SchemaValidationContext {
kPatternValidatorWithAdditionalProperty
};
- SchemaValidationContext(SchemaValidatorFactoryType& f, const SchemaType* s) :
+ SchemaValidationContext(SchemaValidatorFactoryType& f, ErrorHandlerType& eh, const SchemaType* s) :
factory(f),
+ error_handler(eh),
schema(s),
valueSchema(),
invalidKeyword(),
@@ -311,6 +368,7 @@ struct SchemaValidationContext {
}
SchemaValidatorFactoryType& factory;
+ ErrorHandlerType& error_handler;
const SchemaType* schema;
const SchemaType* valueSchema;
const Ch* invalidKeyword;
@@ -345,15 +403,20 @@ public:
typedef SchemaValidationContext<SchemaDocumentType> Context;
typedef Schema<SchemaDocumentType> SchemaType;
typedef GenericValue<EncodingType, AllocatorType> SValue;
+ typedef IValidationErrorHandler<Schema> ErrorHandler;
friend class GenericSchemaDocument<ValueType, AllocatorType>;
Schema(SchemaDocumentType* schemaDocument, const PointerType& p, const ValueType& value, const ValueType& document, AllocatorType* allocator) :
allocator_(allocator),
+ uri_(schemaDocument->GetURI(), *allocator),
+ pointer_(p, allocator),
+ typeless_(schemaDocument->GetTypeless()),
enum_(),
enumCount_(),
not_(),
type_((1 << kTotalSchemaType) - 1), // typeless
validatorCount_(),
+ notValidatorIndex_(),
properties_(),
additionalPropertiesSchema_(),
patternProperties_(),
@@ -377,7 +440,8 @@ public:
minLength_(0),
maxLength_(~SizeType(0)),
exclusiveMinimum_(false),
- exclusiveMaximum_(false)
+ exclusiveMaximum_(false),
+ defaultValueLength_(0)
{
typedef typename SchemaDocumentType::ValueType ValueType;
typedef typename ValueType::ConstValueIterator ConstValueIterator;
@@ -400,7 +464,7 @@ public:
enum_ = static_cast<uint64_t*>(allocator_->Malloc(sizeof(uint64_t) * v->Size()));
for (ConstValueIterator itr = v->Begin(); itr != v->End(); ++itr) {
typedef Hasher<EncodingType, MemoryPoolAllocator<> > EnumHasherType;
- char buffer[256 + 24];
+ char buffer[256u + 24];
MemoryPoolAllocator<> hasherAllocator(buffer, sizeof(buffer));
EnumHasherType h(&hasherAllocator, 256);
itr->Accept(h);
@@ -453,7 +517,7 @@ public:
for (SizeType i = 0; i < propertyCount_; i++) {
new (&properties_[i]) Property();
properties_[i].name = allProperties[i];
- properties_[i].schema = GetTypeless();
+ properties_[i].schema = typeless_;
}
}
}
@@ -572,12 +636,16 @@ public:
if (const ValueType* v = GetMember(value, GetMultipleOfString()))
if (v->IsNumber() && v->GetDouble() > 0.0)
multipleOf_.CopyFrom(*v, *allocator_);
+
+ // Default
+ if (const ValueType* v = GetMember(value, GetDefaultValueString()))
+ if (v->IsString())
+ defaultValueLength_ = v->GetStringLength();
+
}
~Schema() {
- if (allocator_) {
- allocator_->Free(enum_);
- }
+ AllocatorType::Free(enum_);
if (properties_) {
for (SizeType i = 0; i < propertyCount_; i++)
properties_[i].~Property();
@@ -592,11 +660,19 @@ public:
#if CEREAL_RAPIDJSON_SCHEMA_HAS_REGEX
if (pattern_) {
pattern_->~RegexType();
- allocator_->Free(pattern_);
+ AllocatorType::Free(pattern_);
}
#endif
}
+ const SValue& GetURI() const {
+ return uri_;
+ }
+
+ const PointerType& GetPointer() const {
+ return pointer_;
+ }
+
bool BeginValue(Context& context) const {
if (context.inArray) {
if (uniqueItems_)
@@ -610,12 +686,14 @@ public:
else if (additionalItemsSchema_)
context.valueSchema = additionalItemsSchema_;
else if (additionalItems_)
- context.valueSchema = GetTypeless();
- else
+ context.valueSchema = typeless_;
+ else {
+ context.error_handler.DisallowedItem(context.arrayElementIndex);
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetItemsString());
+ }
}
else
- context.valueSchema = GetTypeless();
+ context.valueSchema = typeless_;
context.arrayElementIndex++;
}
@@ -637,15 +715,21 @@ public:
}
if (context.objectPatternValidatorType == Context::kPatternValidatorOnly) {
- if (!patternValid)
+ if (!patternValid) {
+ context.error_handler.PropertyViolations(context.patternPropertiesValidators, count);
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternPropertiesString());
+ }
}
else if (context.objectPatternValidatorType == Context::kPatternValidatorWithProperty) {
- if (!patternValid || !otherValid)
+ if (!patternValid || !otherValid) {
+ context.error_handler.PropertyViolations(context.patternPropertiesValidators, count + 1);
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternPropertiesString());
+ }
}
- else if (!patternValid && !otherValid) // kPatternValidatorWithAdditionalProperty)
+ else if (!patternValid && !otherValid) { // kPatternValidatorWithAdditionalProperty)
+ context.error_handler.PropertyViolations(context.patternPropertiesValidators, count + 1);
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternPropertiesString());
+ }
}
if (enum_) {
@@ -653,19 +737,23 @@ public:
for (SizeType i = 0; i < enumCount_; i++)
if (enum_[i] == h)
goto foundEnum;
+ context.error_handler.DisallowedValue();
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetEnumString());
foundEnum:;
}
if (allOf_.schemas)
for (SizeType i = allOf_.begin; i < allOf_.begin + allOf_.count; i++)
- if (!context.validators[i]->IsValid())
+ if (!context.validators[i]->IsValid()) {
+ context.error_handler.NotAllOf(&context.validators[allOf_.begin], allOf_.count);
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetAllOfString());
+ }
if (anyOf_.schemas) {
for (SizeType i = anyOf_.begin; i < anyOf_.begin + anyOf_.count; i++)
if (context.validators[i]->IsValid())
goto foundAny;
+ context.error_handler.NoneOf(&context.validators[anyOf_.begin], anyOf_.count);
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetAnyOfString());
foundAny:;
}
@@ -674,30 +762,39 @@ public:
bool oneValid = false;
for (SizeType i = oneOf_.begin; i < oneOf_.begin + oneOf_.count; i++)
if (context.validators[i]->IsValid()) {
- if (oneValid)
+ if (oneValid) {
+ context.error_handler.NotOneOf(&context.validators[oneOf_.begin], oneOf_.count);
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetOneOfString());
- else
+ } else
oneValid = true;
}
- if (!oneValid)
+ if (!oneValid) {
+ context.error_handler.NotOneOf(&context.validators[oneOf_.begin], oneOf_.count);
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetOneOfString());
+ }
}
- if (not_ && context.validators[notValidatorIndex_]->IsValid())
+ if (not_ && context.validators[notValidatorIndex_]->IsValid()) {
+ context.error_handler.Disallowed();
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetNotString());
+ }
return true;
}
- bool Null(Context& context) const {
- if (!(type_ & (1 << kNullSchemaType)))
+ bool Null(Context& context) const {
+ if (!(type_ & (1 << kNullSchemaType))) {
+ DisallowedType(context, GetNullString());
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+ }
return CreateParallelValidator(context);
}
- bool Bool(Context& context, bool) const {
- if (!(type_ & (1 << kBooleanSchemaType)))
+ bool Bool(Context& context, bool) const {
+ if (!(type_ & (1 << kBooleanSchemaType))) {
+ DisallowedType(context, GetBooleanString());
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+ }
return CreateParallelValidator(context);
}
@@ -726,8 +823,10 @@ public:
}
bool Double(Context& context, double d) const {
- if (!(type_ & (1 << kNumberSchemaType)))
+ if (!(type_ & (1 << kNumberSchemaType))) {
+ DisallowedType(context, GetNumberString());
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+ }
if (!minimum_.IsNull() && !CheckDoubleMinimum(context, d))
return false;
@@ -742,28 +841,38 @@ public:
}
bool String(Context& context, const Ch* str, SizeType length, bool) const {
- if (!(type_ & (1 << kStringSchemaType)))
+ if (!(type_ & (1 << kStringSchemaType))) {
+ DisallowedType(context, GetStringString());
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+ }
if (minLength_ != 0 || maxLength_ != SizeType(~0)) {
SizeType count;
if (internal::CountStringCodePoint<EncodingType>(str, length, &count)) {
- if (count < minLength_)
+ if (count < minLength_) {
+ context.error_handler.TooShort(str, length, minLength_);
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinLengthString());
- if (count > maxLength_)
+ }
+ if (count > maxLength_) {
+ context.error_handler.TooLong(str, length, maxLength_);
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaxLengthString());
+ }
}
}
- if (pattern_ && !IsPatternMatch(pattern_, str, length))
+ if (pattern_ && !IsPatternMatch(pattern_, str, length)) {
+ context.error_handler.DoesNotMatch(str, length);
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternString());
+ }
return CreateParallelValidator(context);
}
- bool StartObject(Context& context) const {
- if (!(type_ & (1 << kObjectSchemaType)))
+ bool StartObject(Context& context) const {
+ if (!(type_ & (1 << kObjectSchemaType))) {
+ DisallowedType(context, GetObjectString());
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+ }
if (hasDependencies_ || hasRequired_) {
context.propertyExist = static_cast<bool*>(context.factory.MallocState(sizeof(bool) * propertyCount_));
@@ -784,15 +893,17 @@ public:
if (patternProperties_) {
context.patternPropertiesSchemaCount = 0;
for (SizeType i = 0; i < patternPropertyCount_; i++)
- if (patternProperties_[i].pattern && IsPatternMatch(patternProperties_[i].pattern, str, len))
+ if (patternProperties_[i].pattern && IsPatternMatch(patternProperties_[i].pattern, str, len)) {
context.patternPropertiesSchemas[context.patternPropertiesSchemaCount++] = patternProperties_[i].schema;
+ context.valueSchema = typeless_;
+ }
}
SizeType index;
if (FindPropertyIndex(ValueType(str, len).Move(), &index)) {
if (context.patternPropertiesSchemaCount > 0) {
context.patternPropertiesSchemas[context.patternPropertiesSchemaCount++] = properties_[index].schema;
- context.valueSchema = GetTypeless();
+ context.valueSchema = typeless_;
context.valuePatternValidatorType = Context::kPatternValidatorWithProperty;
}
else
@@ -807,7 +918,7 @@ public:
if (additionalPropertiesSchema_) {
if (additionalPropertiesSchema_ && context.patternPropertiesSchemaCount > 0) {
context.patternPropertiesSchemas[context.patternPropertiesSchemaCount++] = additionalPropertiesSchema_;
- context.valueSchema = GetTypeless();
+ context.valueSchema = typeless_;
context.valuePatternValidatorType = Context::kPatternValidatorWithAdditionalProperty;
}
else
@@ -815,49 +926,70 @@ public:
return true;
}
else if (additionalProperties_) {
- context.valueSchema = GetTypeless();
+ context.valueSchema = typeless_;
return true;
}
- if (context.patternPropertiesSchemaCount == 0) // patternProperties are not additional properties
+ if (context.patternPropertiesSchemaCount == 0) { // patternProperties are not additional properties
+ context.error_handler.DisallowedProperty(str, len);
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetAdditionalPropertiesString());
+ }
return true;
}
bool EndObject(Context& context, SizeType memberCount) const {
- if (hasRequired_)
+ if (hasRequired_) {
+ context.error_handler.StartMissingProperties();
for (SizeType index = 0; index < propertyCount_; index++)
- if (properties_[index].required)
- if (!context.propertyExist[index])
- CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetRequiredString());
+ if (properties_[index].required && !context.propertyExist[index])
+ if (properties_[index].schema->defaultValueLength_ == 0 )
+ context.error_handler.AddMissingProperty(properties_[index].name);
+ if (context.error_handler.EndMissingProperties())
+ CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetRequiredString());
+ }
- if (memberCount < minProperties_)
+ if (memberCount < minProperties_) {
+ context.error_handler.TooFewProperties(memberCount, minProperties_);
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinPropertiesString());
+ }
- if (memberCount > maxProperties_)
+ if (memberCount > maxProperties_) {
+ context.error_handler.TooManyProperties(memberCount, maxProperties_);
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaxPropertiesString());
+ }
if (hasDependencies_) {
- for (SizeType sourceIndex = 0; sourceIndex < propertyCount_; sourceIndex++)
+ context.error_handler.StartDependencyErrors();
+ for (SizeType sourceIndex = 0; sourceIndex < propertyCount_; sourceIndex++) {
+ const Property& source = properties_[sourceIndex];
if (context.propertyExist[sourceIndex]) {
- if (properties_[sourceIndex].dependencies) {
+ if (source.dependencies) {
+ context.error_handler.StartMissingDependentProperties();
for (SizeType targetIndex = 0; targetIndex < propertyCount_; targetIndex++)
- if (properties_[sourceIndex].dependencies[targetIndex] && !context.propertyExist[targetIndex])
- CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetDependenciesString());
+ if (source.dependencies[targetIndex] && !context.propertyExist[targetIndex])
+ context.error_handler.AddMissingDependentProperty(properties_[targetIndex].name);
+ context.error_handler.EndMissingDependentProperties(source.name);
+ }
+ else if (source.dependenciesSchema) {
+ ISchemaValidator* dependenciesValidator = context.validators[source.dependenciesValidatorIndex];
+ if (!dependenciesValidator->IsValid())
+ context.error_handler.AddDependencySchemaError(source.name, dependenciesValidator);
}
- else if (properties_[sourceIndex].dependenciesSchema)
- if (!context.validators[properties_[sourceIndex].dependenciesValidatorIndex]->IsValid())
- CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetDependenciesString());
}
+ }
+ if (context.error_handler.EndDependencyErrors())
+ CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetDependenciesString());
}
return true;
}
- bool StartArray(Context& context) const {
- if (!(type_ & (1 << kArraySchemaType)))
+ bool StartArray(Context& context) const {
+ if (!(type_ & (1 << kArraySchemaType))) {
+ DisallowedType(context, GetArrayString());
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+ }
context.arrayElementIndex = 0;
context.inArray = true;
@@ -865,14 +997,18 @@ public:
return CreateParallelValidator(context);
}
- bool EndArray(Context& context, SizeType elementCount) const {
+ bool EndArray(Context& context, SizeType elementCount) const {
context.inArray = false;
- if (elementCount < minItems_)
+ if (elementCount < minItems_) {
+ context.error_handler.TooFewItems(elementCount, minItems_);
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinItemsString());
+ }
- if (elementCount > maxItems_)
+ if (elementCount > maxItems_) {
+ context.error_handler.TooManyItems(elementCount, maxItems_);
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaxItemsString());
+ }
return true;
}
@@ -881,7 +1017,7 @@ public:
#define CEREAL_RAPIDJSON_STRING_(name, ...) \
static const ValueType& Get##name##String() {\
static const Ch s[] = { __VA_ARGS__, '\0' };\
- static const ValueType v(s, sizeof(s) / sizeof(Ch) - 1);\
+ static const ValueType v(s, static_cast<SizeType>(sizeof(s) / sizeof(Ch) - 1));\
return v;\
}
@@ -918,6 +1054,7 @@ public:
CEREAL_RAPIDJSON_STRING_(ExclusiveMinimum, 'e', 'x', 'c', 'l', 'u', 's', 'i', 'v', 'e', 'M', 'i', 'n', 'i', 'm', 'u', 'm')
CEREAL_RAPIDJSON_STRING_(ExclusiveMaximum, 'e', 'x', 'c', 'l', 'u', 's', 'i', 'v', 'e', 'M', 'a', 'x', 'i', 'm', 'u', 'm')
CEREAL_RAPIDJSON_STRING_(MultipleOf, 'm', 'u', 'l', 't', 'i', 'p', 'l', 'e', 'O', 'f')
+ CEREAL_RAPIDJSON_STRING_(DefaultValue, 'd', 'e', 'f', 'a', 'u', 'l', 't')
#undef CEREAL_RAPIDJSON_STRING_
@@ -934,7 +1071,7 @@ private:
};
#if CEREAL_RAPIDJSON_SCHEMA_USE_INTERNALREGEX
- typedef internal::GenericRegex<EncodingType> RegexType;
+ typedef internal::GenericRegex<EncodingType, AllocatorType> RegexType;
#elif CEREAL_RAPIDJSON_SCHEMA_USE_STDREGEX
typedef std::basic_regex<Ch> RegexType;
#else
@@ -949,11 +1086,6 @@ private:
SizeType count;
};
- static const SchemaType* GetTypeless() {
- static SchemaType typeless(0, PointerType(), ValueType(kObjectType).Move(), ValueType(kObjectType).Move(), 0);
- return &typeless;
- }
-
template <typename V1, typename V2>
void AddUniqueElement(V1& a, const V2& v) {
for (typename V1::ConstValueIterator itr = a.Begin(); itr != a.End(); ++itr)
@@ -999,7 +1131,7 @@ private:
template <typename ValueType>
RegexType* CreatePattern(const ValueType& value) {
if (value.IsString()) {
- RegexType* r = new (allocator_->Malloc(sizeof(RegexType))) RegexType(value.GetString());
+ RegexType* r = new (allocator_->Malloc(sizeof(RegexType))) RegexType(value.GetString(), allocator_);
if (!r->IsValid()) {
r->~RegexType();
AllocatorType::Free(r);
@@ -1011,17 +1143,21 @@ private:
}
static bool IsPatternMatch(const RegexType* pattern, const Ch *str, SizeType) {
- return pattern->Search(str);
+ GenericRegexSearch<RegexType> rs(*pattern);
+ return rs.Search(str);
}
#elif CEREAL_RAPIDJSON_SCHEMA_USE_STDREGEX
template <typename ValueType>
RegexType* CreatePattern(const ValueType& value) {
- if (value.IsString())
+ if (value.IsString()) {
+ RegexType *r = static_cast<RegexType*>(allocator_->Malloc(sizeof(RegexType)));
try {
- return new (allocator_->Malloc(sizeof(RegexType))) RegexType(value.GetString(), std::size_t(value.GetStringLength()), std::regex_constants::ECMAScript);
+ return new (r) RegexType(value.GetString(), std::size_t(value.GetStringLength()), std::regex_constants::ECMAScript);
}
catch (const std::regex_error&) {
+ AllocatorType::Free(r);
}
+ }
return 0;
}
@@ -1097,15 +1233,20 @@ private:
}
bool CheckInt(Context& context, int64_t i) const {
- if (!(type_ & ((1 << kIntegerSchemaType) | (1 << kNumberSchemaType))))
+ if (!(type_ & ((1 << kIntegerSchemaType) | (1 << kNumberSchemaType)))) {
+ DisallowedType(context, GetIntegerString());
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+ }
if (!minimum_.IsNull()) {
if (minimum_.IsInt64()) {
- if (exclusiveMinimum_ ? i <= minimum_.GetInt64() : i < minimum_.GetInt64())
+ if (exclusiveMinimum_ ? i <= minimum_.GetInt64() : i < minimum_.GetInt64()) {
+ context.error_handler.BelowMinimum(i, minimum_, exclusiveMinimum_);
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString());
+ }
}
else if (minimum_.IsUint64()) {
+ context.error_handler.BelowMinimum(i, minimum_, exclusiveMinimum_);
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString()); // i <= max(int64_t) < minimum.GetUint64()
}
else if (!CheckDoubleMinimum(context, static_cast<double>(i)))
@@ -1114,19 +1255,23 @@ private:
if (!maximum_.IsNull()) {
if (maximum_.IsInt64()) {
- if (exclusiveMaximum_ ? i >= maximum_.GetInt64() : i > maximum_.GetInt64())
+ if (exclusiveMaximum_ ? i >= maximum_.GetInt64() : i > maximum_.GetInt64()) {
+ context.error_handler.AboveMaximum(i, maximum_, exclusiveMaximum_);
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString());
+ }
}
- else if (maximum_.IsUint64())
- /* do nothing */; // i <= max(int64_t) < maximum_.GetUint64()
+ else if (maximum_.IsUint64()) { }
+ /* do nothing */ // i <= max(int64_t) < maximum_.GetUint64()
else if (!CheckDoubleMaximum(context, static_cast<double>(i)))
return false;
}
if (!multipleOf_.IsNull()) {
if (multipleOf_.IsUint64()) {
- if (static_cast<uint64_t>(i >= 0 ? i : -i) % multipleOf_.GetUint64() != 0)
+ if (static_cast<uint64_t>(i >= 0 ? i : -i) % multipleOf_.GetUint64() != 0) {
+ context.error_handler.NotMultipleOf(i, multipleOf_);
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetMultipleOfString());
+ }
}
else if (!CheckDoubleMultipleOf(context, static_cast<double>(i)))
return false;
@@ -1136,13 +1281,17 @@ private:
}
bool CheckUint(Context& context, uint64_t i) const {
- if (!(type_ & ((1 << kIntegerSchemaType) | (1 << kNumberSchemaType))))
+ if (!(type_ & ((1 << kIntegerSchemaType) | (1 << kNumberSchemaType)))) {
+ DisallowedType(context, GetIntegerString());
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+ }
if (!minimum_.IsNull()) {
if (minimum_.IsUint64()) {
- if (exclusiveMinimum_ ? i <= minimum_.GetUint64() : i < minimum_.GetUint64())
+ if (exclusiveMinimum_ ? i <= minimum_.GetUint64() : i < minimum_.GetUint64()) {
+ context.error_handler.BelowMinimum(i, minimum_, exclusiveMinimum_);
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString());
+ }
}
else if (minimum_.IsInt64())
/* do nothing */; // i >= 0 > minimum.Getint64()
@@ -1152,19 +1301,25 @@ private:
if (!maximum_.IsNull()) {
if (maximum_.IsUint64()) {
- if (exclusiveMaximum_ ? i >= maximum_.GetUint64() : i > maximum_.GetUint64())
+ if (exclusiveMaximum_ ? i >= maximum_.GetUint64() : i > maximum_.GetUint64()) {
+ context.error_handler.AboveMaximum(i, maximum_, exclusiveMaximum_);
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString());
+ }
}
- else if (maximum_.IsInt64())
+ else if (maximum_.IsInt64()) {
+ context.error_handler.AboveMaximum(i, maximum_, exclusiveMaximum_);
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString()); // i >= 0 > maximum_
+ }
else if (!CheckDoubleMaximum(context, static_cast<double>(i)))
return false;
}
if (!multipleOf_.IsNull()) {
if (multipleOf_.IsUint64()) {
- if (i % multipleOf_.GetUint64() != 0)
+ if (i % multipleOf_.GetUint64() != 0) {
+ context.error_handler.NotMultipleOf(i, multipleOf_);
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetMultipleOfString());
+ }
}
else if (!CheckDoubleMultipleOf(context, static_cast<double>(i)))
return false;
@@ -1174,14 +1329,18 @@ private:
}
bool CheckDoubleMinimum(Context& context, double d) const {
- if (exclusiveMinimum_ ? d <= minimum_.GetDouble() : d < minimum_.GetDouble())
+ if (exclusiveMinimum_ ? d <= minimum_.GetDouble() : d < minimum_.GetDouble()) {
+ context.error_handler.BelowMinimum(d, minimum_, exclusiveMinimum_);
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString());
+ }
return true;
}
bool CheckDoubleMaximum(Context& context, double d) const {
- if (exclusiveMaximum_ ? d >= maximum_.GetDouble() : d > maximum_.GetDouble())
+ if (exclusiveMaximum_ ? d >= maximum_.GetDouble() : d > maximum_.GetDouble()) {
+ context.error_handler.AboveMaximum(d, maximum_, exclusiveMaximum_);
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString());
+ }
return true;
}
@@ -1189,11 +1348,29 @@ private:
double a = std::abs(d), b = std::abs(multipleOf_.GetDouble());
double q = std::floor(a / b);
double r = a - q * b;
- if (r > 0.0)
+ if (r > 0.0) {
+ context.error_handler.NotMultipleOf(d, multipleOf_);
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetMultipleOfString());
+ }
return true;
}
+ void DisallowedType(Context& context, const ValueType& actualType) const {
+ ErrorHandler& eh = context.error_handler;
+ eh.StartDisallowedType();
+
+ if (type_ & (1 << kNullSchemaType)) eh.AddExpectedType(GetNullString());
+ if (type_ & (1 << kBooleanSchemaType)) eh.AddExpectedType(GetBooleanString());
+ if (type_ & (1 << kObjectSchemaType)) eh.AddExpectedType(GetObjectString());
+ if (type_ & (1 << kArraySchemaType)) eh.AddExpectedType(GetArrayString());
+ if (type_ & (1 << kStringSchemaType)) eh.AddExpectedType(GetStringString());
+
+ if (type_ & (1 << kNumberSchemaType)) eh.AddExpectedType(GetNumberString());
+ else if (type_ & (1 << kIntegerSchemaType)) eh.AddExpectedType(GetIntegerString());
+
+ eh.EndDisallowedType(actualType);
+ }
+
struct Property {
Property() : schema(), dependenciesSchema(), dependenciesValidatorIndex(), dependencies(), required(false) {}
~Property() { AllocatorType::Free(dependencies); }
@@ -1218,6 +1395,9 @@ private:
};
AllocatorType* allocator_;
+ SValue uri_;
+ PointerType pointer_;
+ const SchemaType* typeless_;
uint64_t* enum_;
SizeType enumCount_;
SchemaArray allOf_;
@@ -1258,6 +1438,8 @@ private:
SValue multipleOf_;
bool exclusiveMinimum_;
bool exclusiveMaximum_;
+
+ SizeType defaultValueLength_;
};
template<typename Stack, typename Ch>
@@ -1267,7 +1449,7 @@ struct TokenHelper {
char buffer[21];
size_t length = static_cast<size_t>((sizeof(SizeType) == 4 ? u32toa(index, buffer) : u64toa(index, buffer)) - buffer);
for (size_t i = 0; i < length; i++)
- *documentStack.template Push<Ch>() = buffer[i];
+ *documentStack.template Push<Ch>() = static_cast<Ch>(buffer[i]);
}
};
@@ -1326,6 +1508,7 @@ public:
typedef typename EncodingType::Ch Ch;
typedef internal::Schema<GenericSchemaDocument> SchemaType;
typedef GenericPointer<ValueType, Allocator> PointerType;
+ typedef GenericValue<EncodingType, Allocator> URIType;
friend class internal::Schema<GenericSchemaDocument>;
template <typename, typename, typename>
friend class GenericSchemaValidator;
@@ -1335,19 +1518,29 @@ public:
Compile a JSON document into schema document.
\param document A JSON document as source.
+ \param uri The base URI of this schema document for purposes of violation reporting.
+ \param uriLength Length of \c name, in code points.
\param remoteProvider An optional remote schema document provider for resolving remote reference. Can be null.
\param allocator An optional allocator instance for allocating memory. Can be null.
*/
- explicit GenericSchemaDocument(const ValueType& document, IRemoteSchemaDocumentProviderType* remoteProvider = 0, Allocator* allocator = 0) :
+ explicit GenericSchemaDocument(const ValueType& document, const Ch* uri = 0, SizeType uriLength = 0,
+ IRemoteSchemaDocumentProviderType* remoteProvider = 0, Allocator* allocator = 0) :
remoteProvider_(remoteProvider),
allocator_(allocator),
ownAllocator_(),
root_(),
+ typeless_(),
schemaMap_(allocator, kInitialSchemaMapSize),
schemaRef_(allocator, kInitialSchemaRefSize)
{
if (!allocator_)
- ownAllocator_ = allocator_ = CEREAL_RAPIDJSON_NEW(Allocator());
+ ownAllocator_ = allocator_ = CEREAL_RAPIDJSON_NEW(Allocator)();
+
+ Ch noUri[1] = {0};
+ uri_.SetString(uri ? uri : noUri, uriLength, *allocator_);
+
+ typeless_ = static_cast<SchemaType*>(allocator_->Malloc(sizeof(SchemaType)));
+ new (typeless_) SchemaType(this, PointerType(), ValueType(kObjectType).Move(), ValueType(kObjectType).Move(), allocator_);
// Generate root schema, it will call CreateSchema() to create sub-schemas,
// And call AddRefSchema() if there are $ref.
@@ -1365,6 +1558,9 @@ public:
new (schemaMap_.template Push<SchemaEntry>()) SchemaEntry(refEntry->source, const_cast<SchemaType*>(s), false, allocator_);
}
}
+ else if (refEntry->schema)
+ *refEntry->schema = typeless_;
+
refEntry->~SchemaRefEntry();
}
@@ -1380,12 +1576,15 @@ public:
allocator_(rhs.allocator_),
ownAllocator_(rhs.ownAllocator_),
root_(rhs.root_),
+ typeless_(rhs.typeless_),
schemaMap_(std::move(rhs.schemaMap_)),
- schemaRef_(std::move(rhs.schemaRef_))
+ schemaRef_(std::move(rhs.schemaRef_)),
+ uri_(std::move(rhs.uri_))
{
rhs.remoteProvider_ = 0;
rhs.allocator_ = 0;
rhs.ownAllocator_ = 0;
+ rhs.typeless_ = 0;
}
#endif
@@ -1394,9 +1593,16 @@ public:
while (!schemaMap_.Empty())
schemaMap_.template Pop<SchemaEntry>(1)->~SchemaEntry();
+ if (typeless_) {
+ typeless_->~SchemaType();
+ Allocator::Free(typeless_);
+ }
+
CEREAL_RAPIDJSON_DELETE(ownAllocator_);
}
+ const URIType& GetURI() const { return uri_; }
+
//! Get the root schema.
const SchemaType& GetRoot() const { return *root_; }
@@ -1428,7 +1634,7 @@ private:
void CreateSchemaRecursive(const SchemaType** schema, const PointerType& pointer, const ValueType& v, const ValueType& document) {
if (schema)
- *schema = SchemaType::GetTypeless();
+ *schema = typeless_;
if (v.GetType() == kObjectType) {
const SchemaType* s = GetSchema(pointer);
@@ -1473,12 +1679,13 @@ private:
if (i > 0) { // Remote reference, resolve immediately
if (remoteProvider_) {
- if (const GenericSchemaDocument* remoteDocument = remoteProvider_->GetRemoteDocument(s, i - 1)) {
+ if (const GenericSchemaDocument* remoteDocument = remoteProvider_->GetRemoteDocument(s, i)) {
PointerType pointer(&s[i], len - i, allocator_);
if (pointer.IsValid()) {
if (const SchemaType* sc = remoteDocument->GetSchema(pointer)) {
if (schema)
*schema = sc;
+ new (schemaMap_.template Push<SchemaEntry>()) SchemaEntry(source, const_cast<SchemaType*>(sc), false, allocator_);
return true;
}
}
@@ -1515,6 +1722,8 @@ private:
return PointerType();
}
+ const SchemaType* GetTypeless() const { return typeless_; }
+
static const size_t kInitialSchemaMapSize = 64;
static const size_t kInitialSchemaRefSize = 64;
@@ -1522,8 +1731,10 @@ private:
Allocator *allocator_;
Allocator *ownAllocator_;
const SchemaType* root_; //!< Root schema.
+ SchemaType* typeless_;
internal::Stack<Allocator> schemaMap_; // Stores created Pointer -> Schemas
internal::Stack<Allocator> schemaRef_; // Stores Pointer from $ref and schema which holds the $ref
+ URIType uri_;
};
//! GenericSchemaDocument using Value type.
@@ -1552,13 +1763,17 @@ template <
typename StateAllocator = CrtAllocator>
class GenericSchemaValidator :
public internal::ISchemaStateFactory<typename SchemaDocumentType::SchemaType>,
- public internal::ISchemaValidator
+ public internal::ISchemaValidator,
+ public internal::IValidationErrorHandler<typename SchemaDocumentType::SchemaType>
{
public:
typedef typename SchemaDocumentType::SchemaType SchemaType;
typedef typename SchemaDocumentType::PointerType PointerType;
typedef typename SchemaType::EncodingType EncodingType;
+ typedef typename SchemaType::SValue SValue;
typedef typename EncodingType::Ch Ch;
+ typedef GenericStringRef<Ch> StringRefType;
+ typedef GenericValue<EncodingType, StateAllocator> ValueType;
//! Constructor without output handler.
/*!
@@ -1575,11 +1790,14 @@ public:
:
schemaDocument_(&schemaDocument),
root_(schemaDocument.GetRoot()),
- outputHandler_(GetNullHandler()),
stateAllocator_(allocator),
ownStateAllocator_(0),
schemaStack_(allocator, schemaStackCapacity),
documentStack_(allocator, documentStackCapacity),
+ outputHandler_(0),
+ error_(kObjectType),
+ currentError_(),
+ missingDependents_(),
valid_(true)
#if CEREAL_RAPIDJSON_SCHEMA_VERBOSE
, depth_(0)
@@ -1603,11 +1821,14 @@ public:
:
schemaDocument_(&schemaDocument),
root_(schemaDocument.GetRoot()),
- outputHandler_(outputHandler),
stateAllocator_(allocator),
ownStateAllocator_(0),
schemaStack_(allocator, schemaStackCapacity),
documentStack_(allocator, documentStackCapacity),
+ outputHandler_(&outputHandler),
+ error_(kObjectType),
+ currentError_(),
+ missingDependents_(),
valid_(true)
#if CEREAL_RAPIDJSON_SCHEMA_VERBOSE
, depth_(0)
@@ -1626,6 +1847,9 @@ public:
while (!schemaStack_.Empty())
PopSchema();
documentStack_.Clear();
+ error_.SetObject();
+ currentError_.SetNull();
+ missingDependents_.SetNull();
valid_ = true;
}
@@ -1633,9 +1857,13 @@ public:
// Implementation of ISchemaValidator
virtual bool IsValid() const { return valid_; }
+ //! Gets the error object.
+ ValueType& GetError() { return error_; }
+ const ValueType& GetError() const { return error_; }
+
//! Gets the JSON pointer pointed to the invalid schema.
PointerType GetInvalidSchemaPointer() const {
- return schemaStack_.Empty() ? PointerType() : schemaDocument_->GetPointer(&CurrentSchema());
+ return schemaStack_.Empty() ? PointerType() : CurrentSchema().GetPointer();
}
//! Gets the keyword of invalid schema.
@@ -1645,9 +1873,196 @@ public:
//! Gets the JSON pointer pointed to the invalid value.
PointerType GetInvalidDocumentPointer() const {
- return documentStack_.Empty() ? PointerType() : PointerType(documentStack_.template Bottom<Ch>(), documentStack_.GetSize() / sizeof(Ch));
+ if (documentStack_.Empty()) {
+ return PointerType();
+ }
+ else {
+ return PointerType(documentStack_.template Bottom<Ch>(), documentStack_.GetSize() / sizeof(Ch));
+ }
+ }
+
+ void NotMultipleOf(int64_t actual, const SValue& expected) {
+ AddNumberError(SchemaType::GetMultipleOfString(), ValueType(actual).Move(), expected);
+ }
+ void NotMultipleOf(uint64_t actual, const SValue& expected) {
+ AddNumberError(SchemaType::GetMultipleOfString(), ValueType(actual).Move(), expected);
+ }
+ void NotMultipleOf(double actual, const SValue& expected) {
+ AddNumberError(SchemaType::GetMultipleOfString(), ValueType(actual).Move(), expected);
+ }
+ void AboveMaximum(int64_t actual, const SValue& expected, bool exclusive) {
+ AddNumberError(SchemaType::GetMaximumString(), ValueType(actual).Move(), expected,
+ exclusive ? &SchemaType::GetExclusiveMaximumString : 0);
+ }
+ void AboveMaximum(uint64_t actual, const SValue& expected, bool exclusive) {
+ AddNumberError(SchemaType::GetMaximumString(), ValueType(actual).Move(), expected,
+ exclusive ? &SchemaType::GetExclusiveMaximumString : 0);
+ }
+ void AboveMaximum(double actual, const SValue& expected, bool exclusive) {
+ AddNumberError(SchemaType::GetMaximumString(), ValueType(actual).Move(), expected,
+ exclusive ? &SchemaType::GetExclusiveMaximumString : 0);
+ }
+ void BelowMinimum(int64_t actual, const SValue& expected, bool exclusive) {
+ AddNumberError(SchemaType::GetMinimumString(), ValueType(actual).Move(), expected,
+ exclusive ? &SchemaType::GetExclusiveMinimumString : 0);
+ }
+ void BelowMinimum(uint64_t actual, const SValue& expected, bool exclusive) {
+ AddNumberError(SchemaType::GetMinimumString(), ValueType(actual).Move(), expected,
+ exclusive ? &SchemaType::GetExclusiveMinimumString : 0);
+ }
+ void BelowMinimum(double actual, const SValue& expected, bool exclusive) {
+ AddNumberError(SchemaType::GetMinimumString(), ValueType(actual).Move(), expected,
+ exclusive ? &SchemaType::GetExclusiveMinimumString : 0);
+ }
+
+ void TooLong(const Ch* str, SizeType length, SizeType expected) {
+ AddNumberError(SchemaType::GetMaxLengthString(),
+ ValueType(str, length, GetStateAllocator()).Move(), SValue(expected).Move());
+ }
+ void TooShort(const Ch* str, SizeType length, SizeType expected) {
+ AddNumberError(SchemaType::GetMinLengthString(),
+ ValueType(str, length, GetStateAllocator()).Move(), SValue(expected).Move());
+ }
+ void DoesNotMatch(const Ch* str, SizeType length) {
+ currentError_.SetObject();
+ currentError_.AddMember(GetActualString(), ValueType(str, length, GetStateAllocator()).Move(), GetStateAllocator());
+ AddCurrentError(SchemaType::GetPatternString());
+ }
+
+ void DisallowedItem(SizeType index) {
+ currentError_.SetObject();
+ currentError_.AddMember(GetDisallowedString(), ValueType(index).Move(), GetStateAllocator());
+ AddCurrentError(SchemaType::GetAdditionalItemsString(), true);
+ }
+ void TooFewItems(SizeType actualCount, SizeType expectedCount) {
+ AddNumberError(SchemaType::GetMinItemsString(),
+ ValueType(actualCount).Move(), SValue(expectedCount).Move());
+ }
+ void TooManyItems(SizeType actualCount, SizeType expectedCount) {
+ AddNumberError(SchemaType::GetMaxItemsString(),
+ ValueType(actualCount).Move(), SValue(expectedCount).Move());
+ }
+ void DuplicateItems(SizeType index1, SizeType index2) {
+ ValueType duplicates(kArrayType);
+ duplicates.PushBack(index1, GetStateAllocator());
+ duplicates.PushBack(index2, GetStateAllocator());
+ currentError_.SetObject();
+ currentError_.AddMember(GetDuplicatesString(), duplicates, GetStateAllocator());
+ AddCurrentError(SchemaType::GetUniqueItemsString(), true);
}
+ void TooManyProperties(SizeType actualCount, SizeType expectedCount) {
+ AddNumberError(SchemaType::GetMaxPropertiesString(),
+ ValueType(actualCount).Move(), SValue(expectedCount).Move());
+ }
+ void TooFewProperties(SizeType actualCount, SizeType expectedCount) {
+ AddNumberError(SchemaType::GetMinPropertiesString(),
+ ValueType(actualCount).Move(), SValue(expectedCount).Move());
+ }
+ void StartMissingProperties() {
+ currentError_.SetArray();
+ }
+ void AddMissingProperty(const SValue& name) {
+ currentError_.PushBack(ValueType(name, GetStateAllocator()).Move(), GetStateAllocator());
+ }
+ bool EndMissingProperties() {
+ if (currentError_.Empty())
+ return false;
+ ValueType error(kObjectType);
+ error.AddMember(GetMissingString(), currentError_, GetStateAllocator());
+ currentError_ = error;
+ AddCurrentError(SchemaType::GetRequiredString());
+ return true;
+ }
+ void PropertyViolations(ISchemaValidator** subvalidators, SizeType count) {
+ for (SizeType i = 0; i < count; ++i)
+ MergeError(static_cast<GenericSchemaValidator*>(subvalidators[i])->GetError());
+ }
+ void DisallowedProperty(const Ch* name, SizeType length) {
+ currentError_.SetObject();
+ currentError_.AddMember(GetDisallowedString(), ValueType(name, length, GetStateAllocator()).Move(), GetStateAllocator());
+ AddCurrentError(SchemaType::GetAdditionalPropertiesString(), true);
+ }
+
+ void StartDependencyErrors() {
+ currentError_.SetObject();
+ }
+ void StartMissingDependentProperties() {
+ missingDependents_.SetArray();
+ }
+ void AddMissingDependentProperty(const SValue& targetName) {
+ missingDependents_.PushBack(ValueType(targetName, GetStateAllocator()).Move(), GetStateAllocator());
+ }
+ void EndMissingDependentProperties(const SValue& sourceName) {
+ if (!missingDependents_.Empty())
+ currentError_.AddMember(ValueType(sourceName, GetStateAllocator()).Move(),
+ missingDependents_, GetStateAllocator());
+ }
+ void AddDependencySchemaError(const SValue& sourceName, ISchemaValidator* subvalidator) {
+ currentError_.AddMember(ValueType(sourceName, GetStateAllocator()).Move(),
+ static_cast<GenericSchemaValidator*>(subvalidator)->GetError(), GetStateAllocator());
+ }
+ bool EndDependencyErrors() {
+ if (currentError_.ObjectEmpty())
+ return false;
+ ValueType error(kObjectType);
+ error.AddMember(GetErrorsString(), currentError_, GetStateAllocator());
+ currentError_ = error;
+ AddCurrentError(SchemaType::GetDependenciesString());
+ return true;
+ }
+
+ void DisallowedValue() {
+ currentError_.SetObject();
+ AddCurrentError(SchemaType::GetEnumString());
+ }
+ void StartDisallowedType() {
+ currentError_.SetArray();
+ }
+ void AddExpectedType(const typename SchemaType::ValueType& expectedType) {
+ currentError_.PushBack(ValueType(expectedType, GetStateAllocator()).Move(), GetStateAllocator());
+ }
+ void EndDisallowedType(const typename SchemaType::ValueType& actualType) {
+ ValueType error(kObjectType);
+ error.AddMember(GetExpectedString(), currentError_, GetStateAllocator());
+ error.AddMember(GetActualString(), ValueType(actualType, GetStateAllocator()).Move(), GetStateAllocator());
+ currentError_ = error;
+ AddCurrentError(SchemaType::GetTypeString());
+ }
+ void NotAllOf(ISchemaValidator** subvalidators, SizeType count) {
+ for (SizeType i = 0; i < count; ++i) {
+ MergeError(static_cast<GenericSchemaValidator*>(subvalidators[i])->GetError());
+ }
+ }
+ void NoneOf(ISchemaValidator** subvalidators, SizeType count) {
+ AddErrorArray(SchemaType::GetAnyOfString(), subvalidators, count);
+ }
+ void NotOneOf(ISchemaValidator** subvalidators, SizeType count) {
+ AddErrorArray(SchemaType::GetOneOfString(), subvalidators, count);
+ }
+ void Disallowed() {
+ currentError_.SetObject();
+ AddCurrentError(SchemaType::GetNotString());
+ }
+
+#define CEREAL_RAPIDJSON_STRING_(name, ...) \
+ static const StringRefType& Get##name##String() {\
+ static const Ch s[] = { __VA_ARGS__, '\0' };\
+ static const StringRefType v(s, static_cast<SizeType>(sizeof(s) / sizeof(Ch) - 1)); \
+ return v;\
+ }
+
+ CEREAL_RAPIDJSON_STRING_(InstanceRef, 'i', 'n', 's', 't', 'a', 'n', 'c', 'e', 'R', 'e', 'f')
+ CEREAL_RAPIDJSON_STRING_(SchemaRef, 's', 'c', 'h', 'e', 'm', 'a', 'R', 'e', 'f')
+ CEREAL_RAPIDJSON_STRING_(Expected, 'e', 'x', 'p', 'e', 'c', 't', 'e', 'd')
+ CEREAL_RAPIDJSON_STRING_(Actual, 'a', 'c', 't', 'u', 'a', 'l')
+ CEREAL_RAPIDJSON_STRING_(Disallowed, 'd', 'i', 's', 'a', 'l', 'l', 'o', 'w', 'e', 'd')
+ CEREAL_RAPIDJSON_STRING_(Missing, 'm', 'i', 's', 's', 'i', 'n', 'g')
+ CEREAL_RAPIDJSON_STRING_(Errors, 'e', 'r', 'r', 'o', 'r', 's')
+ CEREAL_RAPIDJSON_STRING_(Duplicates, 'd', 'u', 'p', 'l', 'i', 'c', 'a', 't', 'e', 's')
+
+#undef CEREAL_RAPIDJSON_STRING_
+
#if CEREAL_RAPIDJSON_SCHEMA_VERBOSE
#define CEREAL_RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_() \
CEREAL_RAPIDJSON_MULTILINEMACRO_BEGIN\
@@ -1679,14 +2094,14 @@ CEREAL_RAPIDJSON_MULTILINEMACRO_END
}
#define CEREAL_RAPIDJSON_SCHEMA_HANDLE_END_(method, arg2)\
- return valid_ = EndValue() && outputHandler_.method arg2
+ return valid_ = EndValue() && (!outputHandler_ || outputHandler_->method arg2)
#define CEREAL_RAPIDJSON_SCHEMA_HANDLE_VALUE_(method, arg1, arg2) \
CEREAL_RAPIDJSON_SCHEMA_HANDLE_BEGIN_ (method, arg1);\
CEREAL_RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(method, arg2);\
CEREAL_RAPIDJSON_SCHEMA_HANDLE_END_ (method, arg2)
- bool Null() { CEREAL_RAPIDJSON_SCHEMA_HANDLE_VALUE_(Null, (CurrentContext() ), ( )); }
+ bool Null() { CEREAL_RAPIDJSON_SCHEMA_HANDLE_VALUE_(Null, (CurrentContext()), ( )); }
bool Bool(bool b) { CEREAL_RAPIDJSON_SCHEMA_HANDLE_VALUE_(Bool, (CurrentContext(), b), (b)); }
bool Int(int i) { CEREAL_RAPIDJSON_SCHEMA_HANDLE_VALUE_(Int, (CurrentContext(), i), (i)); }
bool Uint(unsigned u) { CEREAL_RAPIDJSON_SCHEMA_HANDLE_VALUE_(Uint, (CurrentContext(), u), (u)); }
@@ -1701,7 +2116,7 @@ CEREAL_RAPIDJSON_MULTILINEMACRO_END
bool StartObject() {
CEREAL_RAPIDJSON_SCHEMA_HANDLE_BEGIN_(StartObject, (CurrentContext()));
CEREAL_RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(StartObject, ());
- return valid_ = outputHandler_.StartObject();
+ return valid_ = !outputHandler_ || outputHandler_->StartObject();
}
bool Key(const Ch* str, SizeType len, bool copy) {
@@ -1709,7 +2124,7 @@ CEREAL_RAPIDJSON_MULTILINEMACRO_END
AppendToken(str, len);
if (!CurrentSchema().Key(CurrentContext(), str, len, copy)) return valid_ = false;
CEREAL_RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(Key, (str, len, copy));
- return valid_ = outputHandler_.Key(str, len, copy);
+ return valid_ = !outputHandler_ || outputHandler_->Key(str, len, copy);
}
bool EndObject(SizeType memberCount) {
@@ -1722,7 +2137,7 @@ CEREAL_RAPIDJSON_MULTILINEMACRO_END
bool StartArray() {
CEREAL_RAPIDJSON_SCHEMA_HANDLE_BEGIN_(StartArray, (CurrentContext()));
CEREAL_RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(StartArray, ());
- return valid_ = outputHandler_.StartArray();
+ return valid_ = !outputHandler_ || outputHandler_->StartArray();
}
bool EndArray(SizeType elementCount) {
@@ -1739,7 +2154,7 @@ CEREAL_RAPIDJSON_MULTILINEMACRO_END
// Implementation of ISchemaStateFactory<SchemaType>
virtual ISchemaValidator* CreateSchemaValidator(const SchemaType& root) {
- return new (GetStateAllocator().Malloc(sizeof(GenericSchemaValidator))) GenericSchemaValidator(*schemaDocument_, root,
+ return new (GetStateAllocator().Malloc(sizeof(GenericSchemaValidator))) GenericSchemaValidator(*schemaDocument_, root, documentStack_.template Bottom<char>(), documentStack_.GetSize(),
#if CEREAL_RAPIDJSON_SCHEMA_VERBOSE
depth_ + 1,
#endif
@@ -1771,7 +2186,7 @@ CEREAL_RAPIDJSON_MULTILINEMACRO_END
}
virtual void FreeState(void* p) {
- return StateAllocator::Free(p);
+ StateAllocator::Free(p);
}
private:
@@ -1782,6 +2197,7 @@ private:
GenericSchemaValidator(
const SchemaDocumentType& schemaDocument,
const SchemaType& root,
+ const char* basePath, size_t basePathSize,
#if CEREAL_RAPIDJSON_SCHEMA_VERBOSE
unsigned depth,
#endif
@@ -1791,21 +2207,26 @@ private:
:
schemaDocument_(&schemaDocument),
root_(root),
- outputHandler_(GetNullHandler()),
stateAllocator_(allocator),
ownStateAllocator_(0),
schemaStack_(allocator, schemaStackCapacity),
documentStack_(allocator, documentStackCapacity),
+ outputHandler_(0),
+ error_(kObjectType),
+ currentError_(),
+ missingDependents_(),
valid_(true)
#if CEREAL_RAPIDJSON_SCHEMA_VERBOSE
, depth_(depth)
#endif
{
+ if (basePath && basePathSize)
+ memcpy(documentStack_.template Push<char>(basePathSize), basePath, basePathSize);
}
StateAllocator& GetStateAllocator() {
if (!stateAllocator_)
- stateAllocator_ = ownStateAllocator_ = CEREAL_RAPIDJSON_NEW(StateAllocator());
+ stateAllocator_ = ownStateAllocator_ = CEREAL_RAPIDJSON_NEW(StateAllocator)();
return *stateAllocator_;
}
@@ -1823,8 +2244,8 @@ private:
const SchemaType** sa = CurrentContext().patternPropertiesSchemas;
typename Context::PatternValidatorType patternValidatorType = CurrentContext().valuePatternValidatorType;
bool valueUniqueness = CurrentContext().valueUniqueness;
- if (CurrentContext().valueSchema)
- PushSchema(*CurrentContext().valueSchema);
+ CEREAL_RAPIDJSON_ASSERT(CurrentContext().valueSchema);
+ PushSchema(*CurrentContext().valueSchema);
if (count > 0) {
CurrentContext().objectPatternValidatorType = patternValidatorType;
@@ -1864,8 +2285,10 @@ private:
if (!a)
CurrentContext().arrayElementHashCodes = a = new (GetStateAllocator().Malloc(sizeof(HashCodeArray))) HashCodeArray(kArrayType);
for (typename HashCodeArray::ConstValueIterator itr = a->Begin(); itr != a->End(); ++itr)
- if (itr->GetUint64() == h)
+ if (itr->GetUint64() == h) {
+ DuplicateItems(static_cast<SizeType>(itr - a->Begin()), a->Size());
CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(SchemaType::GetUniqueItemsString());
+ }
a->PushBack(h, GetStateAllocator());
}
}
@@ -1894,7 +2317,7 @@ private:
}
}
- CEREAL_RAPIDJSON_FORCEINLINE void PushSchema(const SchemaType& schema) { new (schemaStack_.template Push<Context>()) Context(*this, &schema); }
+ CEREAL_RAPIDJSON_FORCEINLINE void PushSchema(const SchemaType& schema) { new (schemaStack_.template Push<Context>()) Context(*this, *this, &schema); }
CEREAL_RAPIDJSON_FORCEINLINE void PopSchema() {
Context* c = schemaStack_.template Pop<Context>(1);
@@ -1905,24 +2328,86 @@ private:
c->~Context();
}
+ void AddErrorLocation(ValueType& result, bool parent) {
+ GenericStringBuffer<EncodingType> sb;
+ PointerType instancePointer = GetInvalidDocumentPointer();
+ ((parent && instancePointer.GetTokenCount() > 0)
+ ? PointerType(instancePointer.GetTokens(), instancePointer.GetTokenCount() - 1)
+ : instancePointer).StringifyUriFragment(sb);
+ ValueType instanceRef(sb.GetString(), static_cast<SizeType>(sb.GetSize() / sizeof(Ch)),
+ GetStateAllocator());
+ result.AddMember(GetInstanceRefString(), instanceRef, GetStateAllocator());
+ sb.Clear();
+ memcpy(sb.Push(CurrentSchema().GetURI().GetStringLength()),
+ CurrentSchema().GetURI().GetString(),
+ CurrentSchema().GetURI().GetStringLength() * sizeof(Ch));
+ GetInvalidSchemaPointer().StringifyUriFragment(sb);
+ ValueType schemaRef(sb.GetString(), static_cast<SizeType>(sb.GetSize() / sizeof(Ch)),
+ GetStateAllocator());
+ result.AddMember(GetSchemaRefString(), schemaRef, GetStateAllocator());
+ }
+
+ void AddError(ValueType& keyword, ValueType& error) {
+ typename ValueType::MemberIterator member = error_.FindMember(keyword);
+ if (member == error_.MemberEnd())
+ error_.AddMember(keyword, error, GetStateAllocator());
+ else {
+ if (member->value.IsObject()) {
+ ValueType errors(kArrayType);
+ errors.PushBack(member->value, GetStateAllocator());
+ member->value = errors;
+ }
+ member->value.PushBack(error, GetStateAllocator());
+ }
+ }
+
+ void AddCurrentError(const typename SchemaType::ValueType& keyword, bool parent = false) {
+ AddErrorLocation(currentError_, parent);
+ AddError(ValueType(keyword, GetStateAllocator(), false).Move(), currentError_);
+ }
+
+ void MergeError(ValueType& other) {
+ for (typename ValueType::MemberIterator it = other.MemberBegin(), end = other.MemberEnd(); it != end; ++it) {
+ AddError(it->name, it->value);
+ }
+ }
+
+ void AddNumberError(const typename SchemaType::ValueType& keyword, ValueType& actual, const SValue& expected,
+ const typename SchemaType::ValueType& (*exclusive)() = 0) {
+ currentError_.SetObject();
+ currentError_.AddMember(GetActualString(), actual, GetStateAllocator());
+ currentError_.AddMember(GetExpectedString(), ValueType(expected, GetStateAllocator()).Move(), GetStateAllocator());
+ if (exclusive)
+ currentError_.AddMember(ValueType(exclusive(), GetStateAllocator()).Move(), true, GetStateAllocator());
+ AddCurrentError(keyword);
+ }
+
+ void AddErrorArray(const typename SchemaType::ValueType& keyword,
+ ISchemaValidator** subvalidators, SizeType count) {
+ ValueType errors(kArrayType);
+ for (SizeType i = 0; i < count; ++i)
+ errors.PushBack(static_cast<GenericSchemaValidator*>(subvalidators[i])->GetError(), GetStateAllocator());
+ currentError_.SetObject();
+ currentError_.AddMember(GetErrorsString(), errors, GetStateAllocator());
+ AddCurrentError(keyword);
+ }
+
const SchemaType& CurrentSchema() const { return *schemaStack_.template Top<Context>()->schema; }
Context& CurrentContext() { return *schemaStack_.template Top<Context>(); }
const Context& CurrentContext() const { return *schemaStack_.template Top<Context>(); }
- static OutputHandler& GetNullHandler() {
- static OutputHandler nullHandler;
- return nullHandler;
- }
-
static const size_t kDefaultSchemaStackCapacity = 1024;
static const size_t kDefaultDocumentStackCapacity = 256;
const SchemaDocumentType* schemaDocument_;
const SchemaType& root_;
- OutputHandler& outputHandler_;
StateAllocator* stateAllocator_;
StateAllocator* ownStateAllocator_;
internal::Stack<StateAllocator> schemaStack_; //!< stack to store the current path of schema (BaseSchemaType *)
internal::Stack<StateAllocator> documentStack_; //!< stack to store the current path of validating document (Ch)
+ OutputHandler* outputHandler_;
+ ValueType error_;
+ ValueType currentError_;
+ ValueType missingDependents_;
bool valid_;
#if CEREAL_RAPIDJSON_SCHEMA_VERBOSE
unsigned depth_;
@@ -1954,13 +2439,14 @@ class SchemaValidatingReader {
public:
typedef typename SchemaDocumentType::PointerType PointerType;
typedef typename InputStream::Ch Ch;
+ typedef GenericValue<SourceEncoding, StackAllocator> ValueType;
//! Constructor
/*!
\param is Input stream.
\param sd Schema document.
*/
- SchemaValidatingReader(InputStream& is, const SchemaDocumentType& sd) : is_(is), sd_(sd), invalidSchemaKeyword_(), isValid_(true) {}
+ SchemaValidatingReader(InputStream& is, const SchemaDocumentType& sd) : is_(is), sd_(sd), invalidSchemaKeyword_(), error_(kObjectType), isValid_(true) {}
template <typename Handler>
bool operator()(Handler& handler) {
@@ -1973,11 +2459,13 @@ public:
invalidSchemaPointer_ = PointerType();
invalidSchemaKeyword_ = 0;
invalidDocumentPointer_ = PointerType();
+ error_.SetObject();
}
else {
invalidSchemaPointer_ = validator.GetInvalidSchemaPointer();
invalidSchemaKeyword_ = validator.GetInvalidSchemaKeyword();
invalidDocumentPointer_ = validator.GetInvalidDocumentPointer();
+ error_.CopyFrom(validator.GetError(), allocator_);
}
return parseResult_;
@@ -1988,6 +2476,7 @@ public:
const PointerType& GetInvalidSchemaPointer() const { return invalidSchemaPointer_; }
const Ch* GetInvalidSchemaKeyword() const { return invalidSchemaKeyword_; }
const PointerType& GetInvalidDocumentPointer() const { return invalidDocumentPointer_; }
+ const ValueType& GetError() const { return error_; }
private:
InputStream& is_;
@@ -1997,6 +2486,8 @@ private:
PointerType invalidSchemaPointer_;
const Ch* invalidSchemaKeyword_;
PointerType invalidDocumentPointer_;
+ StackAllocator allocator_;
+ ValueType error_;
bool isValid_;
};
diff --git a/source/code/Libs/include/cereal/external/rapidjson/stream.h b/source/code/Libs/include/cereal/external/rapidjson/stream.h
index c05c2d4..abc0153 100644
--- a/source/code/Libs/include/cereal/external/rapidjson/stream.h
+++ b/source/code/Libs/include/cereal/external/rapidjson/stream.h
@@ -1,5 +1,5 @@
// Tencent is pleased to support the open source community by making RapidJSON available.
-//
+//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
@@ -7,9 +7,9 @@
//
// http://opensource.org/licenses/MIT
//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
// specific language governing permissions and limitations under the License.
#include "rapidjson.h"
@@ -101,6 +101,50 @@ inline void PutN(Stream& stream, Ch c, size_t n) {
}
///////////////////////////////////////////////////////////////////////////////
+// GenericStreamWrapper
+
+//! A Stream Wrapper
+/*! \tThis string stream is a wrapper for any stream by just forwarding any
+ \treceived message to the origin stream.
+ \note implements Stream concept
+*/
+
+#if defined(_MSC_VER) && _MSC_VER <= 1800
+CEREAL_RAPIDJSON_DIAG_PUSH
+CEREAL_RAPIDJSON_DIAG_OFF(4702) // unreachable code
+CEREAL_RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated
+#endif
+
+template <typename InputStream, typename Encoding = UTF8<> >
+class GenericStreamWrapper {
+public:
+ typedef typename Encoding::Ch Ch;
+ GenericStreamWrapper(InputStream& is): is_(is) {}
+
+ Ch Peek() const { return is_.Peek(); }
+ Ch Take() { return is_.Take(); }
+ size_t Tell() { return is_.Tell(); }
+ Ch* PutBegin() { return is_.PutBegin(); }
+ void Put(Ch ch) { is_.Put(ch); }
+ void Flush() { is_.Flush(); }
+ size_t PutEnd(Ch* ch) { return is_.PutEnd(ch); }
+
+ // wrapper for MemoryStream
+ const Ch* Peek4() const { return is_.Peek4(); }
+
+ // wrapper for AutoUTFInputStream
+ UTFType GetType() const { return is_.GetType(); }
+ bool HasBOM() const { return is_.HasBOM(); }
+
+protected:
+ InputStream& is_;
+};
+
+#if defined(_MSC_VER) && _MSC_VER <= 1800
+CEREAL_RAPIDJSON_DIAG_POP
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
// StringStream
//! Read-only string stream.
diff --git a/source/code/Libs/include/cereal/external/rapidjson/stringbuffer.h b/source/code/Libs/include/cereal/external/rapidjson/stringbuffer.h
index 76eb730..d010477 100644
--- a/source/code/Libs/include/cereal/external/rapidjson/stringbuffer.h
+++ b/source/code/Libs/include/cereal/external/rapidjson/stringbuffer.h
@@ -78,8 +78,12 @@ public:
return stack_.template Bottom<Ch>();
}
+ //! Get the size of string in bytes in the string buffer.
size_t GetSize() const { return stack_.GetSize(); }
+ //! Get the length of string in Ch in the string buffer.
+ size_t GetLength() const { return stack_.GetSize() / sizeof(Ch); }
+
static const size_t kDefaultCapacity = 256;
mutable internal::Stack<Allocator> stack_;
diff --git a/source/code/Libs/include/cereal/external/rapidjson/writer.h b/source/code/Libs/include/cereal/external/rapidjson/writer.h
index ae86cb5..b8da773 100644
--- a/source/code/Libs/include/cereal/external/rapidjson/writer.h
+++ b/source/code/Libs/include/cereal/external/rapidjson/writer.h
@@ -16,6 +16,7 @@
#define CEREAL_RAPIDJSON_WRITER_H_
#include "stream.h"
+#include "internal/meta.h"
#include "internal/stack.h"
#include "internal/strfunc.h"
#include "internal/dtoa.h"
@@ -31,17 +32,18 @@
#include <nmmintrin.h>
#elif defined(CEREAL_RAPIDJSON_SSE2)
#include <emmintrin.h>
-#endif
-
-#ifdef _MSC_VER
-CEREAL_RAPIDJSON_DIAG_PUSH
-CEREAL_RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant
+#elif defined(CEREAL_RAPIDJSON_NEON)
+#include <arm_neon.h>
#endif
#ifdef __clang__
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(padded)
CEREAL_RAPIDJSON_DIAG_OFF(unreachable-code)
+CEREAL_RAPIDJSON_DIAG_OFF(c++98-compat)
+#elif defined(_MSC_VER)
+CEREAL_RAPIDJSON_DIAG_PUSH
+CEREAL_RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant
#endif
CEREAL_RAPIDJSON_NAMESPACE_BEGIN
@@ -63,7 +65,7 @@ CEREAL_RAPIDJSON_NAMESPACE_BEGIN
enum WriteFlag {
kWriteNoFlags = 0, //!< No flags are set.
kWriteValidateEncodingFlag = 1, //!< Validate encoding of JSON strings.
- kWriteNanAndInfFlag = 2, //!< Allow writing of Inf, -Inf and NaN.
+ kWriteNanAndInfFlag = 2, //!< Allow writing of Infinity, -Infinity and NaN.
kWriteDefaultFlags = CEREAL_RAPIDJSON_WRITE_DEFAULT_FLAGS //!< Default write flags. Can be customized by defining CEREAL_RAPIDJSON_WRITE_DEFAULT_FLAGS
};
@@ -103,6 +105,13 @@ public:
Writer(StackAllocator* allocator = 0, size_t levelDepth = kDefaultLevelDepth) :
os_(0), level_stack_(allocator, levelDepth * sizeof(Level)), maxDecimalPlaces_(kDefaultMaxDecimalPlaces), hasRoot_(false) {}
+#if CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS
+ Writer(Writer&& rhs) :
+ os_(rhs.os_), level_stack_(std::move(rhs.level_stack_)), maxDecimalPlaces_(rhs.maxDecimalPlaces_), hasRoot_(rhs.hasRoot_) {
+ rhs.os_ = 0;
+ }
+#endif
+
//! Reset the writer with a new stream.
/*!
This function reset the writer with a new stream and default settings,
@@ -184,12 +193,14 @@ public:
bool Double(double d) { Prefix(kNumberType); return EndValue(WriteDouble(d)); }
bool RawNumber(const Ch* str, SizeType length, bool copy = false) {
+ CEREAL_RAPIDJSON_ASSERT(str != 0);
(void)copy;
Prefix(kNumberType);
return EndValue(WriteString(str, length));
}
bool String(const Ch* str, SizeType length, bool copy = false) {
+ CEREAL_RAPIDJSON_ASSERT(str != 0);
(void)copy;
Prefix(kStringType);
return EndValue(WriteString(str, length));
@@ -209,10 +220,18 @@ public:
bool Key(const Ch* str, SizeType length, bool copy = false) { return String(str, length, copy); }
+#if CEREAL_RAPIDJSON_HAS_STDSTRING
+ bool Key(const std::basic_string<Ch>& str)
+ {
+ return Key(str.data(), SizeType(str.size()));
+ }
+#endif
+
bool EndObject(SizeType memberCount = 0) {
(void)memberCount;
- CEREAL_RAPIDJSON_ASSERT(level_stack_.GetSize() >= sizeof(Level));
- CEREAL_RAPIDJSON_ASSERT(!level_stack_.template Top<Level>()->inArray);
+ CEREAL_RAPIDJSON_ASSERT(level_stack_.GetSize() >= sizeof(Level)); // not inside an Object
+ CEREAL_RAPIDJSON_ASSERT(!level_stack_.template Top<Level>()->inArray); // currently inside an Array, not Object
+ CEREAL_RAPIDJSON_ASSERT(0 == level_stack_.template Top<Level>()->valueCount % 2); // Object has a Key without a Value
level_stack_.template Pop<Level>(1);
return EndValue(WriteEndObject());
}
@@ -236,9 +255,9 @@ public:
//@{
//! Simpler but slower overload.
- bool String(const Ch* str) { return String(str, internal::StrLen(str)); }
- bool Key(const Ch* str) { return Key(str, internal::StrLen(str)); }
-
+ bool String(const Ch* const& str) { return String(str, internal::StrLen(str)); }
+ bool Key(const Ch* const& str) { return Key(str, internal::StrLen(str)); }
+
//@}
//! Write a raw JSON value.
@@ -249,7 +268,19 @@ public:
\param length Length of the json.
\param type Type of the root of json.
*/
- bool RawValue(const Ch* json, size_t length, Type type) { Prefix(type); return EndValue(WriteRawValue(json, length)); }
+ bool RawValue(const Ch* json, size_t length, Type type) {
+ CEREAL_RAPIDJSON_ASSERT(json != 0);
+ Prefix(type);
+ return EndValue(WriteRawValue(json, length));
+ }
+
+ //! Flush the output stream.
+ /*!
+ Allows the user to flush the output stream immediately.
+ */
+ void Flush() {
+ os_->Flush();
+ }
protected:
//! Information for each nested level
@@ -283,7 +314,7 @@ protected:
const char* end = internal::i32toa(i, buffer);
PutReserve(*os_, static_cast<size_t>(end - buffer));
for (const char* p = buffer; p != end; ++p)
- PutUnsafe(*os_, static_cast<typename TargetEncoding::Ch>(*p));
+ PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
return true;
}
@@ -292,7 +323,7 @@ protected:
const char* end = internal::u32toa(u, buffer);
PutReserve(*os_, static_cast<size_t>(end - buffer));
for (const char* p = buffer; p != end; ++p)
- PutUnsafe(*os_, static_cast<typename TargetEncoding::Ch>(*p));
+ PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
return true;
}
@@ -301,7 +332,7 @@ protected:
const char* end = internal::i64toa(i64, buffer);
PutReserve(*os_, static_cast<size_t>(end - buffer));
for (const char* p = buffer; p != end; ++p)
- PutUnsafe(*os_, static_cast<typename TargetEncoding::Ch>(*p));
+ PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
return true;
}
@@ -310,7 +341,7 @@ protected:
char* end = internal::u64toa(u64, buffer);
PutReserve(*os_, static_cast<size_t>(end - buffer));
for (char* p = buffer; p != end; ++p)
- PutUnsafe(*os_, static_cast<typename TargetEncoding::Ch>(*p));
+ PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
return true;
}
@@ -338,12 +369,12 @@ protected:
char* end = internal::dtoa(d, buffer, maxDecimalPlaces_);
PutReserve(*os_, static_cast<size_t>(end - buffer));
for (char* p = buffer; p != end; ++p)
- PutUnsafe(*os_, static_cast<typename TargetEncoding::Ch>(*p));
+ PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
return true;
}
bool WriteString(const Ch* str, SizeType length) {
- static const typename TargetEncoding::Ch hexDigits[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
+ static const typename OutputStream::Ch hexDigits[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
static const char escape[256] = {
#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
//0 1 2 3 4 5 6 7 8 9 A B C D E F
@@ -399,7 +430,7 @@ protected:
else if ((sizeof(Ch) == 1 || static_cast<unsigned>(c) < 256) && CEREAL_RAPIDJSON_UNLIKELY(escape[static_cast<unsigned char>(c)])) {
is.Take();
PutUnsafe(*os_, '\\');
- PutUnsafe(*os_, static_cast<typename TargetEncoding::Ch>(escape[static_cast<unsigned char>(c)]));
+ PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(escape[static_cast<unsigned char>(c)]));
if (escape[static_cast<unsigned char>(c)] == 'u') {
PutUnsafe(*os_, '0');
PutUnsafe(*os_, '0');
@@ -427,9 +458,13 @@ protected:
bool WriteRawValue(const Ch* json, size_t length) {
PutReserve(*os_, length);
- for (size_t i = 0; i < length; i++) {
- CEREAL_RAPIDJSON_ASSERT(json[i] != '\0');
- PutUnsafe(*os_, json[i]);
+ GenericStringStream<SourceEncoding> is(json);
+ while (CEREAL_RAPIDJSON_LIKELY(is.Tell() < length)) {
+ CEREAL_RAPIDJSON_ASSERT(is.Peek() != '\0');
+ if (CEREAL_RAPIDJSON_UNLIKELY(!(writeFlags & kWriteValidateEncodingFlag ?
+ Transcoder<SourceEncoding, TargetEncoding>::Validate(is, *os_) :
+ Transcoder<SourceEncoding, TargetEncoding>::TranscodeUnsafe(is, *os_))))
+ return false;
}
return true;
}
@@ -457,7 +492,7 @@ protected:
// Flush the value if it is the top level one.
bool EndValue(bool ret) {
if (CEREAL_RAPIDJSON_UNLIKELY(level_stack_.Empty())) // end of json text
- os_->Flush();
+ Flush();
return ret;
}
@@ -561,7 +596,7 @@ inline bool Writer<StringBuffer>::ScanWriteUnescapedString(StringStream& is, siz
// The rest of string using SIMD
static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' };
static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' };
- static const char space[16] = { 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19 };
+ static const char space[16] = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F };
const __m128i dq = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&dquote[0]));
const __m128i bs = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&bslash[0]));
const __m128i sp = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&space[0]));
@@ -570,7 +605,7 @@ inline bool Writer<StringBuffer>::ScanWriteUnescapedString(StringStream& is, siz
const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
const __m128i t1 = _mm_cmpeq_epi8(s, dq);
const __m128i t2 = _mm_cmpeq_epi8(s, bs);
- const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x19) == 0x19
+ const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x1F) == 0x1F
const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3);
unsigned short r = static_cast<unsigned short>(_mm_movemask_epi8(x));
if (CEREAL_RAPIDJSON_UNLIKELY(r != 0)) { // some of characters is escaped
@@ -595,15 +630,79 @@ inline bool Writer<StringBuffer>::ScanWriteUnescapedString(StringStream& is, siz
is.src_ = p;
return CEREAL_RAPIDJSON_LIKELY(is.Tell() < length);
}
-#endif // defined(CEREAL_RAPIDJSON_SSE2) || defined(CEREAL_RAPIDJSON_SSE42)
+#elif defined(CEREAL_RAPIDJSON_NEON)
+template<>
+inline bool Writer<StringBuffer>::ScanWriteUnescapedString(StringStream& is, size_t length) {
+ if (length < 16)
+ return CEREAL_RAPIDJSON_LIKELY(is.Tell() < length);
-CEREAL_RAPIDJSON_NAMESPACE_END
+ if (!CEREAL_RAPIDJSON_LIKELY(is.Tell() < length))
+ return false;
-#ifdef _MSC_VER
-CEREAL_RAPIDJSON_DIAG_POP
-#endif
+ const char* p = is.src_;
+ const char* end = is.head_ + length;
+ const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
+ const char* endAligned = reinterpret_cast<const char*>(reinterpret_cast<size_t>(end) & static_cast<size_t>(~15));
+ if (nextAligned > end)
+ return true;
-#ifdef __clang__
+ while (p != nextAligned)
+ if (*p < 0x20 || *p == '\"' || *p == '\\') {
+ is.src_ = p;
+ return CEREAL_RAPIDJSON_LIKELY(is.Tell() < length);
+ }
+ else
+ os_->PutUnsafe(*p++);
+
+ // The rest of string using SIMD
+ const uint8x16_t s0 = vmovq_n_u8('"');
+ const uint8x16_t s1 = vmovq_n_u8('\\');
+ const uint8x16_t s2 = vmovq_n_u8('\b');
+ const uint8x16_t s3 = vmovq_n_u8(32);
+
+ for (; p != endAligned; p += 16) {
+ const uint8x16_t s = vld1q_u8(reinterpret_cast<const uint8_t *>(p));
+ uint8x16_t x = vceqq_u8(s, s0);
+ x = vorrq_u8(x, vceqq_u8(s, s1));
+ x = vorrq_u8(x, vceqq_u8(s, s2));
+ x = vorrq_u8(x, vcltq_u8(s, s3));
+
+ x = vrev64q_u8(x); // Rev in 64
+ uint64_t low = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 0); // extract
+ uint64_t high = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 1); // extract
+
+ SizeType len = 0;
+ bool escaped = false;
+ if (low == 0) {
+ if (high != 0) {
+ unsigned lz = (unsigned)__builtin_clzll(high);
+ len = 8 + (lz >> 3);
+ escaped = true;
+ }
+ } else {
+ unsigned lz = (unsigned)__builtin_clzll(low);
+ len = lz >> 3;
+ escaped = true;
+ }
+ if (CEREAL_RAPIDJSON_UNLIKELY(escaped)) { // some of characters is escaped
+ char* q = reinterpret_cast<char*>(os_->PushUnsafe(len));
+ for (size_t i = 0; i < len; i++)
+ q[i] = p[i];
+
+ p += len;
+ break;
+ }
+ vst1q_u8(reinterpret_cast<uint8_t *>(os_->PushUnsafe(16)), s);
+ }
+
+ is.src_ = p;
+ return CEREAL_RAPIDJSON_LIKELY(is.Tell() < length);
+}
+#endif // CEREAL_RAPIDJSON_NEON
+
+CEREAL_RAPIDJSON_NAMESPACE_END
+
+#if defined(_MSC_VER) || defined(__clang__)
CEREAL_RAPIDJSON_DIAG_POP
#endif
diff --git a/source/code/Libs/include/cereal/external/rapidxml/rapidxml.hpp b/source/code/Libs/include/cereal/external/rapidxml/rapidxml.hpp
index 61013a9..d82893a 100644
--- a/source/code/Libs/include/cereal/external/rapidxml/rapidxml.hpp
+++ b/source/code/Libs/include/cereal/external/rapidxml/rapidxml.hpp
@@ -85,7 +85,7 @@ namespace rapidxml
//! Gets human readable description of error.
//! \return Pointer to null terminated description of the error.
- virtual const char *what() const throw()
+ virtual const char *what() const CEREAL_NOEXCEPT override
{
return m_what;
}
@@ -317,7 +317,7 @@ namespace rapidxml
const Ch *tmp = p;
while (*tmp)
++tmp;
- return tmp - p;
+ return static_cast<std::size_t>(tmp - p);
}
// Compare strings for equality
@@ -387,7 +387,7 @@ namespace rapidxml
//! If required, you can tweak <code>CEREAL_RAPIDXML_STATIC_POOL_SIZE</code>, <code>CEREAL_RAPIDXML_DYNAMIC_POOL_SIZE</code> and <code>CEREAL_RAPIDXML_ALIGNMENT</code>
//! to obtain best wasted memory to performance compromise.
//! To do it, define their values before rapidxml.hpp file is included.
- //! \param Ch Character type of created nodes.
+ //! \tparam Ch Character type of created nodes.
template<class Ch = char>
class memory_pool
{
@@ -656,7 +656,7 @@ namespace rapidxml
//! Base class for xml_node and xml_attribute implementing common functions:
//! name(), name_size(), value(), value_size() and parent().
- //! \param Ch Character type to use
+ //! \tparam Ch Character type to use
template<class Ch = char>
class xml_base
{
@@ -729,7 +729,7 @@ namespace rapidxml
//! <br><br>
//! Size of name must be specified separately, because name does not have to be zero terminated.
//! Use name(const Ch *) function to have the length automatically calculated (string must be zero terminated).
- //! \param name Name of node to set. Does not have to be zero terminated.
+ //! \param name_ Name of node to set. Does not have to be zero terminated.
//! \param size Size of name, in characters. This does not include zero terminator, if one is present.
void name(const Ch *name_, std::size_t size)
{
@@ -739,7 +739,7 @@ namespace rapidxml
//! Sets name of node to a zero-terminated string.
//! See also \ref ownership_of_strings and xml_node::name(const Ch *, std::size_t).
- //! \param name Name of node to set. Must be zero terminated.
+ //! \param name_ Name of node to set. Must be zero terminated.
void name(const Ch *name_)
{
this->name(name_, internal::measure(name_));
@@ -759,7 +759,7 @@ namespace rapidxml
//! <br><br>
//! If an element has a child node of type node_data, it will take precedence over element value when printing.
//! If you want to manipulate data of elements using values, use parser flag rapidxml::parse_no_data_nodes to prevent creation of data nodes by the parser.
- //! \param value value of node to set. Does not have to be zero terminated.
+ //! \param value_ value of node to set. Does not have to be zero terminated.
//! \param size Size of value, in characters. This does not include zero terminator, if one is present.
void value(const Ch *value_, std::size_t size)
{
@@ -769,7 +769,7 @@ namespace rapidxml
//! Sets value of node to a zero-terminated string.
//! See also \ref ownership_of_strings and xml_node::value(const Ch *, std::size_t).
- //! \param value Vame of node to set. Must be zero terminated.
+ //! \param value_ Vame of node to set. Must be zero terminated.
void value(const Ch *value_)
{
this->value(value_, internal::measure(value_));
@@ -806,7 +806,7 @@ namespace rapidxml
//! Each attribute has name and value strings, which are available through name() and value() functions (inherited from xml_base).
//! Note that after parse, both name and value of attribute will point to interior of source text used for parsing.
//! Thus, this text must persist in memory for the lifetime of attribute.
- //! \param Ch Character type to use.
+ //! \tparam Ch Character type to use.
template<class Ch = char>
class xml_attribute: public xml_base<Ch>
{
@@ -862,8 +862,8 @@ namespace rapidxml
}
//! Gets next attribute, optionally matching attribute name.
- //! \param name Name of attribute to find, or 0 to return next attribute regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
- //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
+ //! \param name_ Name of attribute to find, or 0 to return next attribute regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
+ //! \param name_size_ Size of name, in characters, or 0 to have size calculated automatically from string
//! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
//! \return Pointer to found attribute, or 0 if not found.
xml_attribute<Ch> *next_attribute(const Ch *name_ = 0, std::size_t name_size_ = 0, bool case_sensitive = true) const
@@ -898,7 +898,7 @@ namespace rapidxml
//! <br><br>
//! Note that after parse, both name and value of node, if any, will point interior of source text used for parsing.
//! Thus, this text must persist in the memory for the lifetime of node.
- //! \param Ch Character type to use.
+ //! \tparam Ch Character type to use.
template<class Ch = char>
class xml_node: public xml_base<Ch>
{
@@ -910,7 +910,7 @@ namespace rapidxml
//! Constructs an empty node with the specified type.
//! Consider using memory_pool of appropriate document to allocate nodes manually.
- //! \param type Type of node to construct.
+ //! \param type_ Type of node to construct.
xml_node(node_type type_)
: m_type(type_)
, m_first_node(0)
@@ -942,8 +942,8 @@ namespace rapidxml
}
//! Gets first child node, optionally matching node name.
- //! \param name Name of child to find, or 0 to return first child regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
- //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
+ //! \param name_ Name of child to find, or 0 to return first child regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
+ //! \param name_size_ Size of name, in characters, or 0 to have size calculated automatically from string
//! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
//! \return Pointer to found child, or 0 if not found.
xml_node<Ch> *first_node(const Ch *name_ = 0, std::size_t name_size_ = 0, bool case_sensitive = true) const
@@ -1010,8 +1010,8 @@ namespace rapidxml
//! Gets next sibling node, optionally matching node name.
//! Behaviour is undefined if node has no parent.
//! Use parent() to test if node has a parent.
- //! \param name Name of sibling to find, or 0 to return next sibling regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
- //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
+ //! \param name_ Name of sibling to find, or 0 to return next sibling regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
+ //! \param name_size_ Size of name, in characters, or 0 to have size calculated automatically from string
//! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
//! \return Pointer to found sibling, or 0 if not found.
xml_node<Ch> *next_sibling(const Ch *name_ = 0, std::size_t name_size_ = 0, bool case_sensitive = true) const
@@ -1031,8 +1031,8 @@ namespace rapidxml
}
//! Gets first attribute of node, optionally matching attribute name.
- //! \param name Name of attribute to find, or 0 to return first attribute regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
- //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
+ //! \param name_ Name of attribute to find, or 0 to return first attribute regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
+ //! \param name_size_ Size of name, in characters, or 0 to have size calculated automatically from string
//! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
//! \return Pointer to found attribute, or 0 if not found.
xml_attribute<Ch> *first_attribute(const Ch *name_ = 0, std::size_t name_size_ = 0, bool case_sensitive = true) const
@@ -1074,7 +1074,7 @@ namespace rapidxml
// Node modification
//! Sets type of node.
- //! \param type Type of node to set.
+ //! \param type_ Type of node to set.
void type(node_type type_)
{
m_type = type_;
@@ -1366,7 +1366,7 @@ namespace rapidxml
//! parse() function allocates memory for nodes and attributes by using functions of xml_document,
//! which are inherited from memory_pool.
//! To access root node of the document, use the document itself, as if it was an xml_node.
- //! \param Ch Character type to use.
+ //! \tparam Ch Character type to use.
template<class Ch = char>
class xml_document: public xml_node<Ch>, public memory_pool<Ch>
{
@@ -1527,7 +1527,7 @@ namespace rapidxml
{
// Insert 8-bit ASCII character
// Todo: possibly verify that code is less than 256 and use replacement char otherwise?
- text[0] = static_cast<unsigned char>(code);
+ text[0] = static_cast<Ch>(code);
text += 1;
}
else
@@ -1535,28 +1535,28 @@ namespace rapidxml
// Insert UTF8 sequence
if (code < 0x80) // 1 byte sequence
{
- text[0] = static_cast<unsigned char>(code);
+ text[0] = static_cast<Ch>(code);
text += 1;
}
else if (code < 0x800) // 2 byte sequence
{
- text[1] = static_cast<unsigned char>((code | 0x80) & 0xBF); code >>= 6;
- text[0] = static_cast<unsigned char>(code | 0xC0);
+ text[1] = static_cast<Ch>((code | 0x80) & 0xBF); code >>= 6;
+ text[0] = static_cast<Ch>(code | 0xC0);
text += 2;
}
else if (code < 0x10000) // 3 byte sequence
{
- text[2] = static_cast<unsigned char>((code | 0x80) & 0xBF); code >>= 6;
- text[1] = static_cast<unsigned char>((code | 0x80) & 0xBF); code >>= 6;
- text[0] = static_cast<unsigned char>(code | 0xE0);
+ text[2] = static_cast<Ch>((code | 0x80) & 0xBF); code >>= 6;
+ text[1] = static_cast<Ch>((code | 0x80) & 0xBF); code >>= 6;
+ text[0] = static_cast<Ch>(code | 0xE0);
text += 3;
}
else if (code < 0x110000) // 4 byte sequence
{
- text[3] = static_cast<unsigned char>((code | 0x80) & 0xBF); code >>= 6;
- text[2] = static_cast<unsigned char>((code | 0x80) & 0xBF); code >>= 6;
- text[1] = static_cast<unsigned char>((code | 0x80) & 0xBF); code >>= 6;
- text[0] = static_cast<unsigned char>(code | 0xF0);
+ text[3] = static_cast<Ch>((code | 0x80) & 0xBF); code >>= 6;
+ text[2] = static_cast<Ch>((code | 0x80) & 0xBF); code >>= 6;
+ text[1] = static_cast<Ch>((code | 0x80) & 0xBF); code >>= 6;
+ text[0] = static_cast<Ch>(code | 0xF0);
text += 4;
}
else // Invalid, only codes up to 0x10FFFF are allowed in Unicode
@@ -1812,7 +1812,7 @@ namespace rapidxml
// Create comment node
xml_node<Ch> *comment = this->allocate_node(node_comment);
- comment->value(value_, text - value_);
+ comment->value(value_, static_cast<std::size_t>(text - value_));
// Place zero terminator after comment value
if (!(Flags & parse_no_string_terminators))
@@ -1871,7 +1871,7 @@ namespace rapidxml
{
// Create a new doctype node
xml_node<Ch> *doctype = this->allocate_node(node_doctype);
- doctype->value(value_, text - value_);
+ doctype->value(value_, static_cast<std::size_t>(text - value_));
// Place zero terminator after value
if (!(Flags & parse_no_string_terminators))
@@ -1903,7 +1903,7 @@ namespace rapidxml
skip<node_name_pred, Flags>(text);
if (text == name_)
CEREAL_RAPIDXML_PARSE_ERROR("expected PI target", text);
- pi->name(name_, text - name_);
+ pi->name(name_, static_cast<std::size_t>(text - name_));
// Skip whitespace between pi target and pi
skip<whitespace_pred, Flags>(text);
@@ -1920,7 +1920,7 @@ namespace rapidxml
}
// Set pi value (verbatim, no entity expansion or whitespace normalization)
- pi->value(value_, text - value_);
+ pi->value(value_, static_cast<std::size_t>(text - value_));
// Place zero terminator after name and value
if (!(Flags & parse_no_string_terminators))
@@ -1987,14 +1987,14 @@ namespace rapidxml
if (!(Flags & parse_no_data_nodes))
{
xml_node<Ch> *data = this->allocate_node(node_data);
- data->value(value_, end - value_);
+ data->value(value_, static_cast<std::size_t>(end - value_));
node->append_node(data);
}
// Add data to parent node if no data exists yet
if (!(Flags & parse_no_element_values))
if (*node->value() == Ch('\0'))
- node->value(value_, end - value_);
+ node->value(value_, static_cast<std::size_t>(end - value_));
// Place zero terminator after value
if (!(Flags & parse_no_string_terminators))
@@ -2037,7 +2037,7 @@ namespace rapidxml
// Create new cdata node
xml_node<Ch> *cdata = this->allocate_node(node_cdata);
- cdata->value(value_, text - value_);
+ cdata->value(value_, static_cast<std::size_t>(text - value_));
// Place zero terminator after value
if (!(Flags & parse_no_string_terminators))
@@ -2059,7 +2059,7 @@ namespace rapidxml
skip<node_name_pred, Flags>(text);
if (text == name_)
CEREAL_RAPIDXML_PARSE_ERROR("expected element name", text);
- element->name(name_, text - name_);
+ element->name(name_, static_cast<std::size_t>(text - name_));
// Skip whitespace between element name and attributes or >
skip<whitespace_pred, Flags>(text);
@@ -2216,7 +2216,7 @@ namespace rapidxml
// Skip and validate closing tag name
Ch *closing_name = text;
skip<node_name_pred, Flags>(text);
- if (!internal::compare(node->name(), node->name_size(), closing_name, text - closing_name, true))
+ if (!internal::compare(node->name(), node->name_size(), closing_name, static_cast<std::size_t>(text - closing_name), true))
CEREAL_RAPIDXML_PARSE_ERROR("invalid closing tag name", text);
}
else
@@ -2232,7 +2232,7 @@ namespace rapidxml
if (contents_end && contents_end != contents_start)
{
- node->value(contents_start, contents_end - contents_start);
+ node->value(contents_start, static_cast<std::size_t>(contents_end - contents_start));
node->value()[node->value_size()] = Ch('\0');
}
return; // Node closed, finished parsing contents
@@ -2275,7 +2275,7 @@ namespace rapidxml
// Create new attribute
xml_attribute<Ch> *attribute = this->allocate_attribute();
- attribute->name(name_, text - name_);
+ attribute->name(name_, static_cast<std::size_t>(text - name_));
node->append_attribute(attribute);
// Skip whitespace after attribute name
@@ -2308,7 +2308,7 @@ namespace rapidxml
end = skip_and_expand_character_refs<attribute_value_pred<Ch('"')>, attribute_value_pure_pred<Ch('"')>, AttFlags>(text, false);
// Set attribute value
- attribute->value(value_, end - value_);
+ attribute->value(value_, static_cast<std::size_t>(end - value_));
// Make sure that end quote is present
if (*text != quote)
diff --git a/source/code/Libs/include/cereal/external/rapidxml/rapidxml_print.hpp b/source/code/Libs/include/cereal/external/rapidxml/rapidxml_print.hpp
index ce10dbb..7fbb962 100644
--- a/source/code/Libs/include/cereal/external/rapidxml/rapidxml_print.hpp
+++ b/source/code/Libs/include/cereal/external/rapidxml/rapidxml_print.hpp
@@ -363,10 +363,12 @@ namespace rapidxml
out = print_pi_node(out, node, flags, indent);
break;
+#ifndef __GNUC__
// Unknown
default:
assert(0);
break;
+#endif
}
// If indenting not disabled, add line break after node
diff --git a/source/code/Libs/include/cereal/macros.hpp b/source/code/Libs/include/cereal/macros.hpp
index cfdc14c..96ca751 100644
--- a/source/code/Libs/include/cereal/macros.hpp
+++ b/source/code/Libs/include/cereal/macros.hpp
@@ -132,4 +132,23 @@
#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_
diff --git a/source/code/Libs/include/cereal/specialize.hpp b/source/code/Libs/include/cereal/specialize.hpp
new file mode 100644
index 0000000..b9276db
--- /dev/null
+++ b/source/code/Libs/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
diff --git a/source/code/Libs/include/cereal/types/atomic.hpp b/source/code/Libs/include/cereal/types/atomic.hpp
new file mode 100644
index 0000000..03d8b87
--- /dev/null
+++ b/source/code/Libs/include/cereal/types/atomic.hpp
@@ -0,0 +1,55 @@
+/*! \file atomic.hpp
+ \brief Support for types found in \<atomic\>
+ \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_ATOMIC_HPP_
+#define CEREAL_TYPES_ATOMIC_HPP_
+
+#include <cereal/cereal.hpp>
+#include <atomic>
+
+namespace cereal
+{
+ //! Serializing (save) for std::atomic
+ template <class Archive, class T> inline
+ void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::atomic<T> const & a )
+ {
+ ar( CEREAL_NVP_("atomic_data", a.load()) );
+ }
+
+ //! Serializing (load) for std::atomic
+ template <class Archive, class T> inline
+ void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::atomic<T> & a )
+ {
+ T tmp;
+ ar( CEREAL_NVP_("atomic_data", tmp) );
+ a.store( tmp );
+ }
+} // namespace cereal
+
+#endif // CEREAL_TYPES_ATOMIC_HPP_
diff --git a/source/code/Libs/include/cereal/types/base_class.hpp b/source/code/Libs/include/cereal/types/base_class.hpp
index 37b551e..fd7423e 100644
--- a/source/code/Libs/include/cereal/types/base_class.hpp
+++ b/source/code/Libs/include/cereal/types/base_class.hpp
@@ -63,7 +63,8 @@ namespace cereal
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.
+ 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
@@ -120,7 +121,8 @@ namespace cereal
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.
+ see the documentation on polymorphism. If using a polymorphic class, be sure to include support for
+ polymorphism (cereal/types/polymorphic.hpp).
\sa base_class
diff --git a/source/code/Libs/include/cereal/types/bitset.hpp b/source/code/Libs/include/cereal/types/bitset.hpp
index 12d3a82..22ff534 100644
--- a/source/code/Libs/include/cereal/types/bitset.hpp
+++ b/source/code/Libs/include/cereal/types/bitset.hpp
@@ -67,7 +67,7 @@ namespace cereal
if( bits[i] )
chunk |= mask;
- mask >>= 1;
+ mask = static_cast<std::uint8_t>(mask >> 1);
// output current chunk when mask is empty (8 bits)
if( mask == 0 )
@@ -163,7 +163,7 @@ namespace cereal
if( chunk & mask )
bits[i] = 1;
- mask >>= 1;
+ mask = static_cast<std::uint8_t>(mask >> 1);
}
break;
}
diff --git a/source/code/Libs/include/cereal/types/boost_variant.hpp b/source/code/Libs/include/cereal/types/boost_variant.hpp
index e1863c1..5f64de5 100644
--- a/source/code/Libs/include/cereal/types/boost_variant.hpp
+++ b/source/code/Libs/include/cereal/types/boost_variant.hpp
@@ -30,13 +30,20 @@
#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.hpp>
-#include <boost/mpl/size.hpp>
+#include <boost/variant/variant_fwd.hpp>
+#include <boost/variant/static_visitor.hpp>
namespace cereal
{
- namespace variant_detail
+ namespace boost_variant_detail
{
//! @internal
template <class Archive>
@@ -45,62 +52,113 @@ namespace cereal
variant_save_visitor(Archive & ar_) : ar(ar_) {}
template<class T>
- void operator()(T const & value) const
+ 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)
{
- ar( CEREAL_NVP_("data", value) );
+ construct->~T();
}
+ }
- Archive & ar;
+ 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<int N, class Variant, class ... Args, class Archive>
- typename std::enable_if<N == boost::mpl::size<typename Variant::types>::value, void>::type
- load_variant(Archive & /*ar*/, int /*target*/, Variant & /*variant*/)
+ template <class T> struct load_variant_wrapper;
+
+ //! Avoid serializing variant void_ type
+ /*! @internal */
+ template <>
+ struct load_variant_wrapper<boost::detail::variant::void_>
{
- throw ::cereal::Exception("Error traversing variant during load");
- }
+ template <class Variant, class Archive>
+ static void load_variant( Archive &, Variant & )
+ { }
+ };
//! @internal
- template<int N, class Variant, class H, class ... T, class Archive>
- typename std::enable_if<N < boost::mpl::size<typename Variant::types>::value, void>::type
- load_variant(Archive & ar, int target, Variant & variant)
+ template <class T>
+ struct load_variant_wrapper
{
- if(N == target)
+ // default constructible
+ template <class Archive, class Variant>
+ static void load_variant_impl( Archive & ar, Variant & variant, std::true_type )
{
- H value;
+ T value;
ar( CEREAL_NVP_("data", value) );
- variant = value;
+ variant = std::move(value);
}
- else
- load_variant<N+1, Variant, T...>(ar, target, variant);
- }
- } // namespace variant_detail
+ // 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 VariantType1, typename... VariantTypes> inline
- void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, boost::variant<VariantType1, VariantTypes...> const & 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) );
- variant_detail::variant_save_visitor<Archive> visitor(ar);
+ boost_variant_detail::variant_save_visitor<Archive> visitor(ar);
variant.apply_visitor(visitor);
}
//! Loading for boost::variant
- template <class Archive, typename VariantType1, typename... VariantTypes> inline
- void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, boost::variant<VariantType1, VariantTypes...> & variant )
+ template <class Archive, typename ... VariantTypes> inline
+ void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, boost::variant<VariantTypes...> & variant )
{
- typedef typename boost::variant<VariantType1, VariantTypes...>::types types;
-
int32_t which;
ar( CEREAL_NVP_("which", which) );
- if(which >= boost::mpl::size<types>::value)
+
+ 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");
- variant_detail::load_variant<0, boost::variant<VariantType1, VariantTypes...>, VariantType1, VariantTypes...>(ar, which, variant);
+ loadFuncArray[which](ar, variant);
}
} // namespace cereal
+#undef CEREAL_CONSTEXPR_LAMBDA
+
#endif // CEREAL_TYPES_BOOST_VARIANT_HPP_
diff --git a/source/code/Libs/include/cereal/types/memory.hpp b/source/code/Libs/include/cereal/types/memory.hpp
index 40c965a..59e9da9 100644
--- a/source/code/Libs/include/cereal/types/memory.hpp
+++ b/source/code/Libs/include/cereal/types/memory.hpp
@@ -34,13 +34,6 @@
#include <memory>
#include <cstring>
-// Work around MSVC not having 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
-
namespace cereal
{
namespace memory_detail
@@ -54,6 +47,7 @@ namespace cereal
PtrWrapper(T && p) : ptr(std::forward<T>(p)) {}
T & ptr;
+ PtrWrapper( PtrWrapper const & ) = default;
PtrWrapper & operator=( PtrWrapper const & ) = delete;
};
@@ -110,6 +104,11 @@ namespace cereal
portion of the class and replace it after whatever happens to modify it (e.g. the
user performing construction or the wrapper shared_ptr in saving).
+ Note that this goes into undefined behavior territory, but as of the initial writing
+ of this, all standard library implementations of std::enable_shared_from_this are
+ compatible with this memory manipulation. It is entirely possible that this may someday
+ break or may not work with convoluted use cases.
+
Example usage:
@code{.cpp}
@@ -136,7 +135,7 @@ namespace cereal
using BaseType = typename ::cereal::traits::get_shared_from_this_base<T>::type;
using ParentType = std::enable_shared_from_this<BaseType>;
using StorageType = typename std::aligned_storage<sizeof(ParentType), CEREAL_ALIGNOF(ParentType)>::type;
-
+
public:
//! Saves the state of some type inheriting from enable_shared_from_this
/*! @param ptr The raw pointer held by the shared_ptr */
@@ -153,7 +152,8 @@ namespace cereal
{
if( !itsRestored )
{
- std::memcpy( itsPtr, &itsState, sizeof(ParentType) );
+ // void * cast needed when type has no trivial copy-assignment
+ std::memcpy( static_cast<void *>(itsPtr), &itsState, sizeof(ParentType) );
itsRestored = true;
}
}
@@ -278,8 +278,6 @@ namespace cereal
typename std::enable_if<traits::has_load_and_construct<T, Archive>::value, void>::type
CEREAL_LOAD_FUNCTION_NAME( Archive & ar, memory_detail::PtrWrapper<std::shared_ptr<T> &> & wrapper )
{
- auto & ptr = wrapper.ptr;
-
uint32_t id;
ar( CEREAL_NVP_("id", id) );
@@ -297,8 +295,9 @@ namespace cereal
// Allocate our storage, which we will treat as
// uninitialized until initialized with placement new
- ptr.reset( reinterpret_cast<T *>( new ST() ),
- [=]( T * t )
+ using NonConstT = typename std::remove_const<T>::type;
+ std::shared_ptr<NonConstT> ptr(reinterpret_cast<NonConstT *>(new ST()),
+ [=]( NonConstT * t )
{
if( *valid )
t->~T();
@@ -310,13 +309,14 @@ namespace cereal
ar.registerSharedPointer( id, ptr );
// Perform the actual loading and allocation
- memory_detail::loadAndConstructSharedPtr( ar, ptr.get(), typename ::cereal::traits::has_shared_from_this<T>::type() );
+ memory_detail::loadAndConstructSharedPtr( ar, ptr.get(), typename ::cereal::traits::has_shared_from_this<NonConstT>::type() );
// Mark pointer as valid (initialized)
*valid = true;
+ wrapper.ptr = std::move(ptr);
}
else
- ptr = std::static_pointer_cast<T>(ar.getSharedPointer(id));
+ wrapper.ptr = std::static_pointer_cast<T>(ar.getSharedPointer(id));
}
//! Loading std::shared_ptr, case when no user load and construct (wrapper implementation)
@@ -325,20 +325,20 @@ namespace cereal
typename std::enable_if<!traits::has_load_and_construct<T, Archive>::value, void>::type
CEREAL_LOAD_FUNCTION_NAME( Archive & ar, memory_detail::PtrWrapper<std::shared_ptr<T> &> & wrapper )
{
- auto & ptr = wrapper.ptr;
-
uint32_t id;
ar( CEREAL_NVP_("id", id) );
if( id & detail::msb_32bit )
{
- ptr.reset( detail::Construct<T, Archive>::load_andor_construct() );
+ using NonConstT = typename std::remove_const<T>::type;
+ std::shared_ptr<NonConstT> ptr( detail::Construct<NonConstT, Archive>::load_andor_construct() );
ar.registerSharedPointer( id, ptr );
ar( CEREAL_NVP_("data", *ptr) );
+ wrapper.ptr = std::move(ptr);
}
else
- ptr = std::static_pointer_cast<T>(ar.getSharedPointer(id));
+ wrapper.ptr = std::static_pointer_cast<T>(ar.getSharedPointer(id));
}
//! Saving std::unique_ptr (wrapper implementation)
@@ -374,16 +374,17 @@ namespace cereal
if( isValid )
{
+ using NonConstT = typename std::remove_const<T>::type;
// Storage type for the pointer - since we can't default construct this type,
// we'll allocate it using std::aligned_storage
- using ST = typename std::aligned_storage<sizeof(T), CEREAL_ALIGNOF(T)>::type;
+ using ST = typename std::aligned_storage<sizeof(NonConstT), CEREAL_ALIGNOF(NonConstT)>::type;
// Allocate storage - note the ST type so that deleter is correct if
// an exception is thrown before we are initialized
std::unique_ptr<ST> stPtr( new ST() );
// Use wrapper to enter into "data" nvp of ptr_wrapper
- memory_detail::LoadAndConstructLoadWrapper<Archive, T> loadWrapper( reinterpret_cast<T *>( stPtr.get() ) );
+ memory_detail::LoadAndConstructLoadWrapper<Archive, NonConstT> loadWrapper( reinterpret_cast<NonConstT *>( stPtr.get() ) );
// Initialize storage
ar( CEREAL_NVP_("data", loadWrapper) );
@@ -404,16 +405,16 @@ namespace cereal
uint8_t isValid;
ar( CEREAL_NVP_("valid", isValid) );
- auto & ptr = wrapper.ptr;
-
if( isValid )
{
- ptr.reset( detail::Construct<T, Archive>::load_andor_construct() );
+ using NonConstT = typename std::remove_const<T>::type;
+ std::unique_ptr<NonConstT, D> ptr( detail::Construct<NonConstT, Archive>::load_andor_construct() );
ar( CEREAL_NVP_( "data", *ptr ) );
+ wrapper.ptr = std::move(ptr);
}
else
{
- ptr.reset( nullptr );
+ wrapper.ptr.reset( nullptr );
}
}
} // namespace cereal
@@ -421,5 +422,4 @@ namespace cereal
// automatically include polymorphic support
#include "cereal/types/polymorphic.hpp"
-#undef CEREAL_ALIGNOF
-#endif // CEREAL_TYPES_SHARED_PTR_HPP_
\ No newline at end of file
+#endif // CEREAL_TYPES_SHARED_PTR_HPP_
diff --git a/source/code/Libs/include/cereal/types/optional.hpp b/source/code/Libs/include/cereal/types/optional.hpp
new file mode 100644
index 0000000..3b24446
--- /dev/null
+++ b/source/code/Libs/include/cereal/types/optional.hpp
@@ -0,0 +1,66 @@
+/*! \file optional.hpp
+ \brief Support for std::optional
+ \ingroup STLSupport */
+/*
+ Copyright (c) 2017, Juan Pedro Bolivar Puente
+ 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_STD_OPTIONAL_
+#define CEREAL_TYPES_STD_OPTIONAL_
+
+#include "cereal/cereal.hpp"
+#include <optional>
+
+namespace cereal {
+ //! Saving for std::optional
+ template <class Archive, typename T> inline
+ void CEREAL_SAVE_FUNCTION_NAME(Archive& ar, const std::optional<T>& optional)
+ {
+ if(!optional) {
+ ar(CEREAL_NVP_("nullopt", true));
+ } else {
+ ar(CEREAL_NVP_("nullopt", false),
+ CEREAL_NVP_("data", *optional));
+ }
+ }
+
+ //! Loading for std::optional
+ template <class Archive, typename T> inline
+ void CEREAL_LOAD_FUNCTION_NAME(Archive& ar, std::optional<T>& optional)
+ {
+ bool nullopt;
+ ar(CEREAL_NVP_("nullopt", nullopt));
+
+ if (nullopt) {
+ optional = std::nullopt;
+ } else {
+ T value;
+ ar(CEREAL_NVP_("data", value));
+ optional = std::move(value);
+ }
+ }
+} // namespace cereal
+
+#endif // CEREAL_TYPES_STD_OPTIONAL_
diff --git a/source/code/Libs/include/cereal/types/polymorphic.hpp b/source/code/Libs/include/cereal/types/polymorphic.hpp
index 5acc11f..f3db78f 100644
--- a/source/code/Libs/include/cereal/types/polymorphic.hpp
+++ b/source/code/Libs/include/cereal/types/polymorphic.hpp
@@ -165,17 +165,19 @@
See CEREAL_REGISTER_DYNAMIC_INIT for detailed explanation
of how this macro should be used. The name used should
match that for CEREAL_REGISTER_DYNAMIC_INIT. */
-#define CEREAL_FORCE_DYNAMIC_INIT(LibName) \
- namespace cereal { \
- namespace detail { \
- void dynamic_init_dummy_##LibName(); \
- } /* end detail */ \
- namespace { \
- void dynamic_init_##LibName() \
- { \
- ::cereal::detail::dynamic_init_dummy_##LibName(); \
- } \
- } } /* end namespaces */
+#define CEREAL_FORCE_DYNAMIC_INIT(LibName) \
+ namespace cereal { \
+ namespace detail { \
+ void CEREAL_DLL_EXPORT dynamic_init_dummy_##LibName(); \
+ } /* end detail */ \
+ } /* end cereal */ \
+ namespace { \
+ struct dynamic_init_##LibName { \
+ dynamic_init_##LibName() { \
+ ::cereal::detail::dynamic_init_dummy_##LibName(); \
+ } \
+ } dynamic_init_instance_##LibName; \
+ } /* end anonymous namespace */
namespace cereal
{
diff --git a/source/code/Libs/include/cereal/types/tuple.hpp b/source/code/Libs/include/cereal/types/tuple.hpp
index 7e56f0d..23013cd 100644
--- a/source/code/Libs/include/cereal/types/tuple.hpp
+++ b/source/code/Libs/include/cereal/types/tuple.hpp
@@ -38,7 +38,7 @@ namespace cereal
namespace tuple_detail
{
//! Creates a c string from a sequence of characters
- /*! The c string created will alwas be prefixed by "tuple_element"
+ /*! The c string created will always be prefixed by "tuple_element"
Based on code from: http://stackoverflow/a/20973438/710791
@internal */
template<char...Cs>
@@ -63,7 +63,7 @@ namespace cereal
template <size_t Q, size_t R, char ... C>
struct to_string_impl
{
- using type = typename to_string_impl<Q/10, Q%10, R+'0', C...>::type;
+ 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
@@ -71,7 +71,7 @@ namespace cereal
template <size_t R, char ... C>
struct to_string_impl<0, R, C...>
{
- using type = char_seq_to_c_str<R+'0', 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
@@ -84,7 +84,7 @@ namespace cereal
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; };
+ static const typename type::arr_type c_str(){ return type::str; }
};
// unwinds a tuple to save it
diff --git a/source/code/Libs/include/cereal/types/variant.hpp b/source/code/Libs/include/cereal/types/variant.hpp
new file mode 100644
index 0000000..8bea397
--- /dev/null
+++ b/source/code/Libs/include/cereal/types/variant.hpp
@@ -0,0 +1,109 @@
+/*! \file variant.hpp
+ \brief Support for std::variant
+ \ingroup STLSupport */
+/*
+ Copyright (c) 2014, 2017, Randolph Voorhies, Shane Grant, Juan Pedro
+ Bolivar Puente. 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_STD_VARIANT_HPP_
+#define CEREAL_TYPES_STD_VARIANT_HPP_
+
+#include "cereal/cereal.hpp"
+#include <variant>
+#include <cstdint>
+
+namespace cereal
+{
+ namespace variant_detail
+ {
+ //! @internal
+ template <class Archive>
+ struct variant_save_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<int N, class Variant, class ... Args, class Archive>
+ typename std::enable_if<N == std::variant_size_v<Variant>, void>::type
+ load_variant(Archive & /*ar*/, int /*target*/, Variant & /*variant*/)
+ {
+ throw ::cereal::Exception("Error traversing variant during load");
+ }
+ //! @internal
+ template<int N, class Variant, class H, class ... T, class Archive>
+ typename std::enable_if<N < std::variant_size_v<Variant>, void>::type
+ load_variant(Archive & ar, int target, Variant & variant)
+ {
+ if(N == target)
+ {
+ H value;
+ ar( CEREAL_NVP_("data", value) );
+ variant = std::move(value);
+ }
+ else
+ load_variant<N+1, Variant, T...>(ar, target, variant);
+ }
+
+ } // namespace variant_detail
+
+ //! Saving for std::variant
+ template <class Archive, typename VariantType1, typename... VariantTypes> inline
+ void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::variant<VariantType1, VariantTypes...> const & variant )
+ {
+ std::int32_t index = static_cast<std::int32_t>(variant.index());
+ ar( CEREAL_NVP_("index", index) );
+ variant_detail::variant_save_visitor<Archive> visitor(ar);
+ std::visit(visitor, variant);
+ }
+
+ //! Loading for std::variant
+ template <class Archive, typename... VariantTypes> inline
+ void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::variant<VariantTypes...> & variant )
+ {
+ using variant_t = typename std::variant<VariantTypes...>;
+
+ std::int32_t index;
+ ar( CEREAL_NVP_("index", index) );
+ if(index >= static_cast<std::int32_t>(std::variant_size_v<variant_t>))
+ throw Exception("Invalid 'index' selector when deserializing std::variant");
+
+ variant_detail::load_variant<0, variant_t, VariantTypes...>(ar, index, variant);
+ }
+
+ //! Serializing a std::monostate
+ template <class Archive>
+ void CEREAL_SERIALIZE_FUNCTION_NAME( Archive &, std::monostate const & ) {}
+} // namespace cereal
+
+#endif // CEREAL_TYPES_STD_VARIANT_HPP_
diff --git a/source/code/Libs/include/cereal/types/vector.hpp b/source/code/Libs/include/cereal/types/vector.hpp
index 8302cb9..4984bd3 100644
--- a/source/code/Libs/include/cereal/types/vector.hpp
+++ b/source/code/Libs/include/cereal/types/vector.hpp
@@ -60,8 +60,8 @@ namespace cereal
//! Serialization for non-arithmetic vector types
template <class Archive, class T, class A> inline
- typename std::enable_if<!traits::is_output_serializable<BinaryData<T>, Archive>::value
- || !std::is_arithmetic<T>::value, void>::type
+ typename std::enable_if<(!traits::is_output_serializable<BinaryData<T>, Archive>::value
+ || !std::is_arithmetic<T>::value) && !std::is_same<T, bool>::value, void>::type
CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::vector<T, A> const & vector )
{
ar( make_size_tag( static_cast<size_type>(vector.size()) ) ); // number of elements
@@ -71,8 +71,8 @@ namespace cereal
//! Serialization for non-arithmetic vector types
template <class Archive, class T, class A> inline
- typename std::enable_if<!traits::is_input_serializable<BinaryData<T>, Archive>::value
- || !std::is_arithmetic<T>::value, void>::type
+ typename std::enable_if<(!traits::is_input_serializable<BinaryData<T>, Archive>::value
+ || !std::is_arithmetic<T>::value) && !std::is_same<T, bool>::value, void>::type
CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::vector<T, A> & vector )
{
size_type size;
@@ -88,7 +88,7 @@ namespace cereal
void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::vector<bool, A> const & vector )
{
ar( make_size_tag( static_cast<size_type>(vector.size()) ) ); // number of elements
- for(auto && v : vector)
+ for(const auto v : vector)
ar( static_cast<bool>(v) );
}
@@ -100,7 +100,7 @@ namespace cereal
ar( make_size_tag( size ) );
vector.resize( static_cast<std::size_t>( size ) );
- for(auto && v : vector)
+ for(auto v : vector)
{
bool b;
ar( b );
diff --git a/source/code/Libs/include/cereal/version.hpp b/source/code/Libs/include/cereal/version.hpp
new file mode 100644
index 0000000..2a9dada
--- /dev/null
+++ b/source/code/Libs/include/cereal/version.hpp
@@ -0,0 +1,52 @@
+/*! \file version.hpp
+ \brief Macros to detect cereal version
+
+ These macros can assist in determining the version of cereal. Be
+ warned that cereal is not guaranteed to be compatible across
+ different versions. For more information on releases of cereal,
+ see https://github.com/USCiLab/cereal/releases.
+
+ \ingroup utility */
+/*
+ Copyright (c) 2018, 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_VERSION_HPP_
+#define CEREAL_VERSION_HPP_
+
+//! The major version
+#define CEREAL_VERSION_MAJOR 1
+//! The minor version
+#define CEREAL_VERSION_MINOR 3
+//! The patch version
+#define CEREAL_VERSION_PATCH 0
+
+//! The full version as a single number
+#define CEREAL_VERSION (CEREAL_VERSION_MAJOR * 10000 \
+ + CEREAL_VERSION_MINOR * 100 \
+ + CEREAL_VERSION_PATCH)
+
+#endif // CEREAL_VERSION_HPP_