Merge branch 'develop' for release 1.1.2

include/cereal/archives/json.hpp

@@ -491,11 +491,15 @@ namespace cereal
             const auto len = std::strlen( searchName );
             size_t index = 0;
             for( auto it = itsMemberItBegin; it != itsMemberItEnd; ++it, ++index )
-              if( std::strncmp( searchName, it->name.GetString(), len ) == 0 )
+            {
+              const auto currentName = it->name.GetString();
+              if( ( std::strncmp( searchName, currentName, len ) == 0 ) &&
+                  ( std::strlen( currentName ) == len ) )
               {
                 itsIndex = index;
                 return;
               }
+            }
 
             throw Exception("JSON Parsing failed - provided NVP not found");
           }

include/cereal/types/valarray.hpp

@@ -0,0 +1,89 @@
+/*! \file valarray.hpp
+\brief Support for types found in \<valarray\>
+\ingroup STLSupport */
+
+/*
+Copyright (c) 2014, Randolph Voorhies, Shane Grant
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+* Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+* Neither the name of cereal nor the
+names of its contributors may be used to endorse or promote products
+derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef CEREAL_TYPES_VALARRAY_HPP_
+#define CEREAL_TYPES_VALARRAY_HPP_
+
+#include <cereal/cereal.hpp>
+#include <valarray>
+
+namespace cereal
+{
+  //! Saving for std::valarray arithmetic types, using binary serialization, if supported
+  template <class Archive, class T> inline
+  typename std::enable_if<traits::is_output_serializable<BinaryData<T>, Archive>::value
+                          && std::is_arithmetic<T>::value, void>::type
+  CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::valarray<T> const & valarray )
+  {
+    ar( make_size_tag( static_cast<size_type>(valarray.size()) ) ); // number of elements
+    ar( binary_data( &valarray[0], valarray.size() * sizeof(T) ) ); // &valarray[0] ok since guaranteed contiguous
+  }
+
+  //! Loading for std::valarray arithmetic types, using binary serialization, if supported
+  template <class Archive, class T> inline
+  typename std::enable_if<traits::is_input_serializable<BinaryData<T>, Archive>::value
+                          && std::is_arithmetic<T>::value, void>::type
+  CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::valarray<T> & valarray )
+  {
+    size_type valarraySize;
+    ar( make_size_tag( valarraySize ) );
+
+    valarray.resize( static_cast<std::size_t>( valarraySize ) );
+    ar( binary_data( &valarray[0], static_cast<std::size_t>( valarraySize ) * sizeof(T) ) );
+  }
+
+  //! Saving for std::valarray all other types
+  template <class Archive, class T> inline
+  typename std::enable_if<!traits::is_output_serializable<BinaryData<T>, Archive>::value
+                          || !std::is_arithmetic<T>::value, void>::type
+  CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::valarray<T> const & valarray )
+  {
+    ar( make_size_tag( static_cast<size_type>(valarray.size()) ) ); // number of elements
+    for(auto && v : valarray)
+      ar(v);
+  }
+
+  //! Loading for std::valarray all other types
+  template <class Archive, class T> inline
+  typename std::enable_if<!traits::is_input_serializable<BinaryData<T>, Archive>::value
+                          || !std::is_arithmetic<T>::value, void>::type
+  CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::valarray<T> & valarray )
+  {
+    size_type valarraySize;
+    ar( make_size_tag( valarraySize ) );
+
+    valarray.resize( static_cast<size_t>( valarraySize ) );
+    for(auto && v : valarray)
+      ar(v);
+  }
+} // namespace cereal
+
+#endif // CEREAL_TYPES_VALARRAY_HPP_

unittests/common.hpp

@@ -29,6 +29,7 @@
 
 #include <cereal/types/memory.hpp>
 #include <cereal/types/array.hpp>
+#include <cereal/types/valarray.hpp>
 #include <cereal/types/vector.hpp>
 #include <cereal/types/deque.hpp>
 #include <cereal/types/forward_list.hpp>

unittests/unordered_loads.cpp

@@ -30,6 +30,7 @@
 struct unordered_naming
 {
   int x;
+  int xx;
   int y;
   int z;
 
@@ -38,26 +39,28 @@ struct unordered_naming
   {
     ar( CEREAL_NVP(x),
         CEREAL_NVP(z),
-        CEREAL_NVP(y) );
+        CEREAL_NVP(y),
+        CEREAL_NVP(xx) );
   }
 
   template <class Archive>
   void load( Archive & ar )
   {
     ar( x,
         CEREAL_NVP(y),
-        CEREAL_NVP(z) );
+        CEREAL_NVP(z),
+        CEREAL_NVP(xx) );
   }
 
   bool operator==( unordered_naming const & other ) const
   {
-    return x == other.x && y == other.y && z == other.z;
+    return x == other.x && xx == other.xx && y == other.y && z == other.z;
   }
 };
 
 std::ostream& operator<<(std::ostream& os, unordered_naming const & s)
 {
-  os << "[x: " << s.x << " y: " << s.y << " z: " << s.z << "]";
+  os << "[x: " << s.x << " xx: " << s.xx << " y: " << s.y << " z: " << s.z << "]";
   return os;
 }
 
@@ -92,6 +95,7 @@ void test_unordered_loads()
     std::pair<float, unordered_naming> o_un7;
     o_un7.first = rngF();
     o_un7.second.x = rngI();
+    o_un7.second.xx = rngI();
     o_un7.second.y = rngI();
     o_un7.second.z = rngI();
 

unittests/valarray.cpp

@@ -0,0 +1,119 @@
+/*
+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 AND 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.
+*/
+
+#include "common.hpp"
+#include <boost/test/unit_test.hpp>
+
+template <class IArchive, class OArchive>
+void test_valarray()
+{
+  std::random_device rd;
+  std::mt19937 gen(rd());
+
+  for (int ii = 0; ii<100; ++ii)
+  {
+    std::valarray<int> o_podvalarray(100);
+    for (auto & elem : o_podvalarray)
+      elem = random_value<int>(gen);
+
+    std::valarray<StructInternalSerialize> o_iservalarray(100);
+    for (auto & elem : o_iservalarray)
+      elem = StructInternalSerialize(random_value<int>(gen), random_value<int>(gen));
+
+    std::valarray<StructInternalSplit> o_isplvalarray(100);
+    for (auto & elem : o_isplvalarray)
+      elem = StructInternalSplit(random_value<int>(gen), random_value<int>(gen));
+
+    std::valarray<StructExternalSerialize> o_eservalarray(100);
+    for (auto & elem : o_eservalarray)
+      elem = StructExternalSerialize(random_value<int>(gen), random_value<int>(gen));
+
+    std::valarray<StructExternalSplit> o_esplvalarray(100);
+    for (auto & elem : o_esplvalarray)
+      elem = StructExternalSplit(random_value<int>(gen), random_value<int>(gen));
+
+    std::ostringstream os;
+    {
+      OArchive oar(os);
+
+      oar(o_podvalarray);
+      oar(o_iservalarray);
+      oar(o_isplvalarray);
+      oar(o_eservalarray);
+      oar(o_esplvalarray);
+    }
+
+    std::valarray<int> i_podvalarray;
+    std::valarray<StructInternalSerialize> i_iservalarray;
+    std::valarray<StructInternalSplit>     i_isplvalarray;
+    std::valarray<StructExternalSerialize> i_eservalarray;
+    std::valarray<StructExternalSplit>     i_esplvalarray;
+
+    std::istringstream is(os.str());
+    {
+      IArchive iar(is);
+
+      iar(i_podvalarray);
+      iar(i_iservalarray);
+      iar(i_isplvalarray);
+      iar(i_eservalarray);
+      iar(i_esplvalarray);
+    }
+
+    BOOST_CHECK_EQUAL(i_podvalarray.size(), o_podvalarray.size());
+    BOOST_CHECK_EQUAL(i_iservalarray.size(), o_iservalarray.size());
+    BOOST_CHECK_EQUAL(i_isplvalarray.size(), o_isplvalarray.size());
+    BOOST_CHECK_EQUAL(i_eservalarray.size(), o_eservalarray.size());
+    BOOST_CHECK_EQUAL(i_esplvalarray.size(), o_esplvalarray.size());
+
+    BOOST_CHECK_EQUAL_COLLECTIONS(std::begin(i_podvalarray), std::end(i_podvalarray), std::begin(o_podvalarray), std::end(o_podvalarray));
+    BOOST_CHECK_EQUAL_COLLECTIONS(std::begin(i_iservalarray), std::end(i_iservalarray), std::begin(o_iservalarray), std::end(o_iservalarray));
+    BOOST_CHECK_EQUAL_COLLECTIONS(std::begin(i_isplvalarray), std::end(i_isplvalarray), std::begin(o_isplvalarray), std::end(o_isplvalarray));
+    BOOST_CHECK_EQUAL_COLLECTIONS(std::begin(i_eservalarray), std::end(i_eservalarray), std::begin(o_eservalarray), std::end(o_eservalarray));
+    BOOST_CHECK_EQUAL_COLLECTIONS(std::begin(i_esplvalarray), std::end(i_esplvalarray), std::begin(o_esplvalarray), std::end(o_esplvalarray));
+  }
+}
+
+BOOST_AUTO_TEST_CASE(binary_valarray)
+{
+  test_valarray<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
+}
+
+BOOST_AUTO_TEST_CASE(portable_binary_valarray)
+{
+  test_valarray<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
+}
+
+BOOST_AUTO_TEST_CASE(xml_valarray)
+{
+  test_valarray<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
+}
+
+BOOST_AUTO_TEST_CASE(json_valarray)
+{
+  test_valarray<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
+}

vs2013/unittests/unittests.vcxproj

@@ -52,6 +52,7 @@
     <ClCompile Include="..\..\unittests\unordered_set.cpp" />
     <ClCompile Include="..\..\unittests\user_data_adapters.cpp" />
     <ClCompile Include="..\..\unittests\vector.cpp" />
+    <ClCompile Include="..\..\unittests\valarray.cpp" />
     <ClCompile Include="..\..\unittests\versioning.cpp" />
     <ClCompile Include="main.cpp" />
   </ItemGroup>

vs2013/unittests/unittests.vcxproj.filters

@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup>
     <Filter Include="Source Files">
@@ -110,6 +110,9 @@
     </ClCompile>
     <ClCompile Include="..\..\unittests\vector.cpp">
       <Filter>Source Files</Filter>
+    </ClCompile>
+     <ClCompile Include="..\..\unittests\valarray.cpp">
+      <Filter>Source Files</Filter>
     </ClCompile>
     <ClCompile Include="..\..\unittests\versioning.cpp">
       <Filter>Source Files</Filter>