Merge branch 'develop'

1.66.0 release notes
2017-11-11 18:40:05 +00:00 · 2017-11-10 15:16:39 +00:00 · 2017-10-27 11:06:13 +01:00 · 2017-10-02 23:31:54 +01:00 · 2017-10-02 13:42:23 +01:00 · 2017-09-19 12:42:01 +01:00
10 changed files with 346 additions and 24 deletions
--- a/.travis.yml
+++ b/.travis.yml
@@ -11,29 +11,61 @@ language: c++
 addons:
    apt:
        packages:
-            - libboost-dev
            - libboost-tools-dev

 matrix:
    include:
      - compiler: gcc
-        env: BJAM_TOOLSET=gcc-std03
+        env: |
+            USER_CONFIG="using gcc : : g++-4.8 -Werror --std=c++03 ;"
      - compiler: gcc
-        env: BJAM_TOOLSET=gcc-std11
+        env: |
+            USER_CONFIG="using gcc : : g++-4.8 -Werror --std=c++11 ;"
      - compiler: clang
-        env: BJAM_TOOLSET=clang-std03
+        env: |
+            USER_CONFIG="using clang : : clang++ -Werror --std=c++03 ;"
      - compiler: clang
-        env: BJAM_TOOLSET=clang-std11
+        env: |
+            USER_CONFIG="using clang : : clang++ -Werror --std=c++11 ;"
+      - compiler: clang
+        env: |
+            USER_CONFIG="using clang : : clang++ -Werror --std=c++11 -D_HAS_AUTO_PTR_ETC=0 ;"

 before_script:
-    - |
-        echo "using gcc : std03 : g++-4.8 -Werror --std=c++03 ;" > ~/user-config.jam
-        echo "using gcc : std11 : g++-4.8 -Werror --std=c++11 ;" >> ~/user-config.jam
-        echo "using clang : std03 : clang++ -Werror --std=c++03 ;" >> ~/user-config.jam
-        echo "using clang : std11 : clang++ -Werror --std=c++11 ;" >> ~/user-config.jam
-    - cat ~/user-config.jam
+    - export BOOST_VERSION=1.65.1
+    - export BOOST_FILENAME=boost_1_65_1
+    - export BOOST_ROOT=${HOME}/boost
+    - cd ${TRAVIS_BUILD_DIR}
    - touch Jamroot.jam
+    - cd $HOME
+    - echo $USER_CONFIG > ~/user-config.jam
+    - cat ~/user-config.jam
+    - |
+        mkdir $HOME/download
+        mkdir $HOME/extract
+        cd $HOME/download
+        if [ "$TRAVIS_EVENT_TYPE" == "cron" ]
+        then
+            if [ "$TRAVIS_BRANCH" == "master" ]
+            then
+                snapshot_branch=master
+            else
+                snapshot_branch=develop
+            fi
+            download_url=$(curl https://api.bintray.com/packages/boostorg/$snapshot_branch/snapshot/files |
+                    python -c "import os.path, sys, json; x = json.load(sys.stdin); print '\n'.join(a['path'] for a in x if os.path.splitext(a['path'])[1] == '.bz2')" |
+                    head -n 1 |
+                    sed "s/^/http:\/\/dl.bintray.com\/boostorg\/$snapshot_branch\//")
+        else
+            download_url=https://sourceforge.net/projects/boost/files/boost/${BOOST_VERSION}/${BOOST_FILENAME}.tar.bz2/download
+        fi
+        echo "Downloading ${download_url}"
+        wget -O boost.tar.bz2 $download_url
+        cd $HOME/extract
+        tar -xjf $HOME/download/boost.tar.bz2
+        mv * ${BOOST_ROOT}
+    - rm -r ${BOOST_ROOT}/boost/functional

 script:
    - cd ${TRAVIS_BUILD_DIR}/test
-    - bjam -q ${BJAM_TOOLSET} include=${TRAVIS_BUILD_DIR}/include
+    - bjam -q ${BJAM_TOOLSET} include=${BOOST_ROOT} include=${TRAVIS_BUILD_DIR}/include
--- a/doc/changes.qbk
+++ b/doc/changes.qbk
@@ -186,4 +186,19 @@
  Otherwise there's a compile error as there's no overload for hashing
  the characters in wide strings ([ticket 8552]).

+[h2 Boost 1.64.0]
+
+* Fix for recent versions of Visual C++ which have removed `std::unary_function`
+  and `std::binary_function` ([ticket 12353]).
+
+[h2 Boost 1.65.0]
+
+* Support for `char16_t`, `char32_t`, `u16string`, `u32string`
+
+[h2 Boost 1.66.0]
+
+* Avoid float comparison warning when using Clang - this workaround was
+  already in place for GCC, and was used when Clang pretends to be GCC,
+  but the warning was appearing when running Clang in other contexts.
+
 [endsect]
--- a/doc/ref.xml
+++ b/doc/ref.xml
@@ -162,6 +162,42 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
        </method>
      </struct-specialization>

+      <struct-specialization name="hash">
+        <template></template>
+        <specialization>
+          <template-arg>char16_t</template-arg>
+        </specialization>
+        <method name="operator()" cv="const">
+          <type>std::size_t</type>
+          <parameter name="val">
+            <paramtype>char16_t</paramtype>
+          </parameter>
+          <returns>
+            <para>Unspecified in TR1, except that equal arguments yield the same result.</para>
+            <para><functionname>hash_value</functionname>(val) in Boost.</para>
+          </returns>
+          <throws><para>Doesn't throw</para></throws>
+        </method>
+      </struct-specialization>
+
+      <struct-specialization name="hash">
+        <template></template>
+        <specialization>
+          <template-arg>char32_t</template-arg>
+        </specialization>
+        <method name="operator()" cv="const">
+          <type>std::size_t</type>
+          <parameter name="val">
+            <paramtype>char32_t</paramtype>
+          </parameter>
+          <returns>
+            <para>Unspecified in TR1, except that equal arguments yield the same result.</para>
+            <para><functionname>hash_value</functionname>(val) in Boost.</para>
+          </returns>
+          <throws><para>Doesn't throw</para></throws>
+        </method>
+      </struct-specialization>
+
      <struct-specialization name="hash">
        <template></template>
        <specialization>
@@ -396,6 +432,42 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
        </method>
      </struct-specialization>

+      <struct-specialization name="hash">
+        <template></template>
+        <specialization>
+          <template-arg>std::u16string</template-arg>
+        </specialization>
+        <method name="operator()" cv="const">
+          <type>std::size_t</type>
+          <parameter name="val">
+            <paramtype>std::u16string const&amp;</paramtype>
+          </parameter>
+          <returns>
+            <para>Unspecified in TR1, except that equal arguments yield the same result.</para>
+            <para><functionname>hash_value</functionname>(val) in Boost.</para>
+          </returns>
+          <throws><para>Doesn't throw</para></throws>
+        </method>
+      </struct-specialization>
+
+      <struct-specialization name="hash">
+        <template></template>
+        <specialization>
+          <template-arg>std::u32string</template-arg>
+        </specialization>
+        <method name="operator()" cv="const">
+          <type>std::size_t</type>
+          <parameter name="val">
+            <paramtype>std::u32string const&amp;</paramtype>
+          </parameter>
+          <returns>
+            <para>Unspecified in TR1, except that equal arguments yield the same result.</para>
+            <para><functionname>hash_value</functionname>(val) in Boost.</para>
+          </returns>
+          <throws><para>Doesn't throw</para></throws>
+        </method>
+      </struct-specialization>
+
      <struct-specialization name="hash">
        <template>
          <template-type-parameter name="T"/>
@@ -597,6 +669,16 @@ for(; first != last; ++first)
          <parameter name="val"><paramtype>wchar_t</paramtype></parameter>
        </signature>

+        <signature>
+          <type>std::size_t</type>
+          <parameter name="val"><paramtype>char16_t</paramtype></parameter>
+        </signature>
+
+        <signature>
+          <type>std::size_t</type>
+          <parameter name="val"><paramtype>char32_t</paramtype></parameter>
+        </signature>
+
        <signature>
          <type>std::size_t</type>
          <parameter name="val"><paramtype>short</paramtype></parameter>
@@ -833,7 +915,8 @@ for(; first != last; ++first)
              <tbody>
                <row>
                  <entry><code>bool</code>,
-                    <code>char</code>, <code>signed char</code>, <code>unsigned char</code>, <code>wchar_t</code>,
+                    <code>char</code>, <code>signed char</code>, <code>unsigned char</code>,
+                    <code>wchar_t</code>, <code>char16_t</code>, <code>char32_t</code>,
                    <code>short</code>, <code>unsigned short</code>,
                    <code>int</code>, <code>unsigned int</code>, <code>long</code>, <code>unsigned long</code>
                  </entry>
--- a/include/boost/functional/hash/detail/hash_float.hpp
+++ b/include/boost/functional/hash/detail/hash_float.hpp
@@ -241,7 +241,7 @@ namespace boost
        template <class T>
        inline bool is_zero(T v)
        {
-#if !defined(__GNUC__)
+#if !defined(__GNUC__) && !defined(__clang__)
            return v == 0;
 #else
            // GCC's '-Wfloat-equal' will complain about comparing
--- a/include/boost/functional/hash/extensions.hpp
+++ b/include/boost/functional/hash/extensions.hpp
@@ -254,7 +254,7 @@ namespace boost
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)

    template <class T> struct hash
-        : std::unary_function<T, std::size_t>
+        : boost::hash_detail::hash_base<T>
    {
 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
        std::size_t operator()(T const& val) const
@@ -271,7 +271,7 @@ namespace boost

 #if BOOST_WORKAROUND(__DMC__, <= 0x848)
    template <class T, unsigned int n> struct hash<T[n]>
-        : std::unary_function<T[n], std::size_t>
+        : boost::hash_detail::hash_base<T[n]>
    {
        std::size_t operator()(const T* val) const
        {
@@ -296,7 +296,7 @@ namespace boost
        {
            template <class T>
            struct inner
-                : std::unary_function<T, std::size_t>
+                : boost::hash_detail::hash_base<T>
            {
 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
                std::size_t operator()(T const& val) const
--- a/include/boost/functional/hash/hash.hpp
+++ b/include/boost/functional/hash/hash.hpp
@@ -62,6 +62,18 @@ namespace boost
 {
    namespace hash_detail
    {
+#if defined(_HAS_AUTO_PTR_ETC) && !_HAS_AUTO_PTR_ETC
+        template <typename T>
+        struct hash_base
+        {
+            typedef T argument_type;
+            typedef std::size_t result_type;
+        };
+#else
+        template <typename T>
+        struct hash_base : std::unary_function<T, std::size_t> {};
+#endif
+
        struct enable_hash_value { typedef std::size_t type; };

        template <typename T> struct basic_numbers {};
@@ -95,6 +107,16 @@ namespace boost
            boost::hash_detail::enable_hash_value {};
 #endif

+#if !defined(BOOST_NO_CXX11_CHAR16_T)
+        template <> struct basic_numbers<char16_t> :
+            boost::hash_detail::enable_hash_value {};
+#endif
+
+#if !defined(BOOST_NO_CXX11_CHAR32_T)
+        template <> struct basic_numbers<char32_t> :
+            boost::hash_detail::enable_hash_value {};
+#endif
+
        // long_numbers is defined like this to allow for separate
        // specialization for long_long and int128_type, in case
        // they conflict.
@@ -419,7 +441,7 @@ namespace boost

 #define BOOST_HASH_SPECIALIZE(type) \
    template <> struct hash<type> \
-         : public std::unary_function<type, std::size_t> \
+         : public boost::hash_detail::hash_base<type> \
    { \
        std::size_t operator()(type v) const \
        { \
@@ -429,7 +451,7 @@ namespace boost

 #define BOOST_HASH_SPECIALIZE_REF(type) \
    template <> struct hash<type> \
-         : public std::unary_function<type, std::size_t> \
+         : public boost::hash_detail::hash_base<type> \
    { \
        std::size_t operator()(type const& v) const \
        { \
@@ -443,6 +465,12 @@ namespace boost
    BOOST_HASH_SPECIALIZE(unsigned char)
 #if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
    BOOST_HASH_SPECIALIZE(wchar_t)
+#endif
+#if !defined(BOOST_NO_CXX11_CHAR16_T)
+    BOOST_HASH_SPECIALIZE(char16_t)
+#endif
+#if !defined(BOOST_NO_CXX11_CHAR32_T)
+    BOOST_HASH_SPECIALIZE(char32_t)
 #endif
    BOOST_HASH_SPECIALIZE(short)
    BOOST_HASH_SPECIALIZE(unsigned short)
@@ -459,6 +487,12 @@ namespace boost
 #if !defined(BOOST_NO_STD_WSTRING) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
    BOOST_HASH_SPECIALIZE_REF(std::wstring)
 #endif
+#if !defined(BOOST_NO_CXX11_CHAR16_T)
+    BOOST_HASH_SPECIALIZE_REF(std::basic_string<char16_t>)
+#endif
+#if !defined(BOOST_NO_CXX11_CHAR32_T)
+    BOOST_HASH_SPECIALIZE_REF(std::basic_string<char32_t>)
+#endif

 #if !defined(BOOST_NO_LONG_LONG)
    BOOST_HASH_SPECIALIZE(boost::long_long_type)
@@ -483,7 +517,7 @@ namespace boost

    template <class T>
    struct hash<T*>
-        : public std::unary_function<T*, std::size_t>
+        : public boost::hash_detail::hash_base<T*>
    {
        std::size_t operator()(T* v) const
        {
@@ -516,7 +550,7 @@ namespace boost
        {
            template <class T>
            struct inner
-                : public std::unary_function<T, std::size_t>
+                : public boost::hash_detail::hash_base<T>
            {
                std::size_t operator()(T val) const
                {
--- a/meta/explicit-failures-markup.xml
+++ b/meta/explicit-failures-markup.xml
@@ -0,0 +1,90 @@
+<?xml version="1.0" encoding="utf-8"?>
+<explicit-failures-markup>
+    <!-- functional/hash -->
+    <library name="functional/hash">
+        <mark-expected-failures>
+            <test name="hash_value_array_test"/>
+            <toolset name="msvc-6.5*"/>
+            <toolset name="msvc-7.0*"/>
+            <note author="Daniel James">
+              hash_value is not overloaded for arrays for older versions
+              of Visual C++. There is a work around so that
+              boost::hash&lt;T[N]&gt;, boost::hash_combine and boost::hash_range
+              work.
+            </note>
+        </mark-expected-failures>
+
+        <mark-expected-failures>
+            <test name="hash_function_pointer_test"/>
+            <toolset name="msvc-6.5*"/>
+            <toolset name="msvc-7.0*"/>
+            <note refid="2" author="Daniel James"/>
+        </mark-expected-failures>
+
+        <mark-expected-failures>
+            <test name="hash_function_pointer_test"/>
+            <toolset name="sun-5.7"/>
+            <toolset name="sun-5.8"/>
+            <toolset name="sun-5.9"/>
+            <note author="Daniel James">
+                On these compilers the wrong overload of hash_value is called
+                when the argument is a hash function pointer. So calling
+                hash_value doesn't work but boost::hash does work (and it's
+                recommended that user never call hash_value directly so this
+                shouldn't be a problem).
+            </note>
+        </mark-expected-failures>
+
+        <mark-expected-failures>
+            <test name="hash_long_double_test"/>
+            <toolset name="gcc-3.4.3_sunos"/>
+            <toolset name="*pa_risc"/>
+            <note author="Daniel James">
+                This platform has poor support for <code>long double</code> so
+                the hash function perform poorly for values out of the range
+                of <code>double</code> or if they differ at a greater precision
+                that <code>double</code> is capable of representing.
+            </note>
+        </mark-expected-failures>
+
+        <mark-expected-failures>
+            <test name="point" />
+            <test name="books" />
+            <toolset name="msvc-6.5*"/>
+            <toolset name="msvc-7.0*"/>
+            <note author="Daniel James">
+                These examples only work on compilers with support for ADL.
+                It is possible to work around this, but I wanted to keep the
+                example code as clean as possible.
+            </note>
+        </mark-expected-failures>
+
+        <mark-expected-failures>
+            <test name="point" />
+            <toolset name="borland-*"/>
+            <note author="Daniel James">
+                It appears that Borland doesn't find friend functions defined
+                in a class by ADL. This is easily fixed but this example is
+                meant to show the typical way of customising boost::hash, not
+                the portable way.
+            </note>
+        </mark-expected-failures>
+
+        <mark-expected-failures>
+            <test name="hash_global_namespace_test" />
+            <toolset name="borland-*"/>
+            <note author="Daniel James">
+                The test demonstrates a Borland bug - functions that aren't
+                in a namespace don't appear to be found by ADL.
+            </note>
+        </mark-expected-failures>
+
+        <mark-expected-failures>
+            <test name="container_fwd_gcc_debug"/>
+            <toolset name="darwin-4.2"/>
+            <note author="Daniel James">
+              Debug containers aren't supported on Apple's version of gcc 4.2.
+            </note>
+        </mark-expected-failures>
+    </library>
+</explicit-failures-markup>
--- a/test/compile_time.hpp
+++ b/test/compile_time.hpp
@@ -10,7 +10,9 @@
 template <class T>
 void compile_time_tests(T*)
 {
+#if !defined(_HAS_AUTO_PTR_ETC) || _HAS_AUTO_PTR_ETC
    BOOST_STATIC_ASSERT((boost::is_base_and_derived<
        std::unary_function<T, std::size_t>, BOOST_HASH_TEST_NAMESPACE::hash<T> >::value));
+#endif
 }

--- a/test/hash_number_test.cpp
+++ b/test/hash_number_test.cpp
@@ -127,9 +127,13 @@ void poor_quality_tests(T*)
        BOOST_TEST(x1(T(1)) !=  x2(T(-1)));
    if(T(1) != T(2))
        BOOST_TEST(x1(T(1)) !=  x2(T(2)));
-    if((limits::max)() != (limits::max)() - 1)
-        BOOST_TEST(x1(static_cast<T>((limits::max)()))
-            != x2(static_cast<T>((limits::max)() - 1)));
+
+    // TODO: This test is useless for floating point numbers.
+    T max_number = static_cast<T>((limits::max)());
+    T max_minus_one = static_cast<T>(max_number - 1);
+    if (max_number != max_minus_one) {
+        BOOST_TEST(x1(max_number) != x1(max_minus_one));
+    }
 }

 void bool_test()
@@ -160,6 +164,12 @@ int main()
    NUMERIC_TEST(unsigned char, uchar)
 #ifndef BOOST_NO_INTRINSIC_WCHAR_T
    NUMERIC_TEST(wchar_t, wchar)
+#endif
+#ifndef BOOST_NO_CXX11_CHAR16_T
+    NUMERIC_TEST(char16_t, char16)
+#endif
+#ifndef BOOST_NO_CXX11_CHAR32_T
+    NUMERIC_TEST(char32_t, char32)
 #endif
    NUMERIC_TEST(short, short)
    NUMERIC_TEST(unsigned short, ushort)
--- a/test/hash_string_test.cpp
+++ b/test/hash_string_test.cpp
@@ -80,12 +80,68 @@ void wstring_tests()
 }
 #endif

+#if !defined(BOOST_NO_CXX11_CHAR16_T)
+void u16string_tests()
+{
+    compile_time_tests((std::u16string*) 0);
+
+    BOOST_HASH_TEST_NAMESPACE::hash<std::u16string> x1;
+    BOOST_HASH_TEST_NAMESPACE::hash<std::u16string> x2;
+
+    BOOST_TEST(x1(u"Hello") == x2(std::u16string(u"Hel") + u"lo"));
+    BOOST_TEST(x1(u"") == x2(std::u16string()));
+
+#if defined(BOOST_HASH_TEST_EXTENSIONS)
+    std::u16string value1;
+    std::u16string value2(u"Hello");
+
+    BOOST_TEST(x1(value1) == BOOST_HASH_TEST_NAMESPACE::hash_value(value1));
+    BOOST_TEST(x1(value2) == BOOST_HASH_TEST_NAMESPACE::hash_value(value2));
+    BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(value1) ==
+            BOOST_HASH_TEST_NAMESPACE::hash_range(value1.begin(), value1.end()));
+    BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(value2) ==
+            BOOST_HASH_TEST_NAMESPACE::hash_range(value2.begin(), value2.end()));
+#endif
+}
+#endif
+
+#if !defined(BOOST_NO_CXX11_CHAR32_T)
+void u32string_tests()
+{
+    compile_time_tests((std::u32string*) 0);
+
+    BOOST_HASH_TEST_NAMESPACE::hash<std::u32string> x1;
+    BOOST_HASH_TEST_NAMESPACE::hash<std::u32string> x2;
+
+    BOOST_TEST(x1(U"Hello") == x2(std::u32string(U"Hel") + U"lo"));
+    BOOST_TEST(x1(U"") == x2(std::u32string()));
+
+#if defined(BOOST_HASH_TEST_EXTENSIONS)
+    std::u32string value1;
+    std::u32string value2(U"Hello");
+
+    BOOST_TEST(x1(value1) == BOOST_HASH_TEST_NAMESPACE::hash_value(value1));
+    BOOST_TEST(x1(value2) == BOOST_HASH_TEST_NAMESPACE::hash_value(value2));
+    BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(value1) ==
+            BOOST_HASH_TEST_NAMESPACE::hash_range(value1.begin(), value1.end()));
+    BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(value2) ==
+            BOOST_HASH_TEST_NAMESPACE::hash_range(value2.begin(), value2.end()));
+#endif
+}
+#endif
+
 int main()
 {
    string_tests();
    string0_tests();
 #if !defined(BOOST_NO_STD_WSTRING) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
    wstring_tests();
+#endif
+#if !defined(BOOST_NO_CXX11_CHAR16_T)
+    u16string_tests();
+#endif
+#if !defined(BOOST_NO_CXX11_CHAR32_T)
+    u32string_tests();
 #endif
    return boost::report_errors();
 }
Author	SHA1	Message	Date
Daniel James	dfa8fa5d91	Merge branch 'develop'	2017-11-11 18:40:05 +00:00
Daniel James	8098c5b302	1.66.0 release notes	2017-11-10 15:16:39 +00:00
Daniel James	7f3a063064	Merge branch 'develop'	2017-10-27 11:06:13 +01:00
Daniel James	d803b3bdc0	Remove schema stuff, as it doesn't work	2017-10-02 23:31:54 +01:00
Daniel James	170558e4fa	Initial explicit-failures-markup.xml	2017-10-02 13:42:23 +01:00
Daniel James	4a4cb9f7a4	Use is_zero workaround on clang The same warning appears on clang for windows, but the workaround wasn't used because the gcc macro wasn't defined.	2017-09-19 12:42:01 +01:00
Daniel James	7a6c0f20d5	Merge branch 'develop' Travis improvements.	2017-09-19 11:08:15 +01:00
Daniel James	8bdfb0cf90	Use 1.65.1 in travis	2017-09-08 21:40:16 +01:00
Daniel James	3ee110f82c	Download branch snapshot from cron jobs	2017-08-24 22:03:19 +01:00
Daniel James	f7ad177dae	Use boost 1.65 in travis Also copied some other things that I've found to work well.	2017-08-24 10:24:52 +01:00
Daniel James	955cdaed3d	Merge branch 'develop'	2017-06-11 20:49:34 +01:00
Daniel James	9c82e48bc9	Support for char16_t, char32_t, u16string, u32string	2017-05-31 22:19:54 +01:00
Daniel James	1b3bed82aa	Initial support for char32_t	2017-05-31 10:17:34 +01:00
Daniel James	6dd58674aa	Add ticket link to changelog entry	2017-02-03 08:41:31 +00:00
Daniel James	4a530f85d0	Merge branch 'develop'	2017-01-01 18:25:51 +00:00
Daniel James	babb4f8f73	Hash changelog entry	2017-01-01 16:04:24 +00:00
Daniel James	01b81754cf	Hash changelog entry	2017-01-01 16:03:48 +00:00
Daniel James	4b99dbdb64	Link to ticket in changelog	2016-12-05 23:00:20 +00:00
Daniel James	a489b08e27	Add changelog entry for 1.63.0	2016-12-05 22:42:44 +00:00
Daniel James	ab9f98455a	Fix cast issue in poor_quality_tests The comparison in the if statement and the test didn't match, which I think is why this test was sometimes failling. But should still try to write something that will work for floats.	2016-11-18 15:14:04 +00:00
Daniel James	7159a86166	Only support std::wstring when wchar_t is available This hopefuly fixes #8552. https://svn.boost.org/trac/boost/ticket/8552	2016-11-18 15:13:46 +00:00
Daniel James	d0ee8e13bd	Support for removed function objects in C++17 std::unary_function and std::binary_function are removed in C++17, and Visual C++ is the first compiler to do this (when the appropriate macro is defined). I'm not sure what the long term solution should be, but hopefully this will work for now.	2016-11-01 16:31:21 +00:00