Use boost from hunter

.travis.yml

@@ -12,7 +12,7 @@ matrix:
 cache:
     ccache: true
 install:
-    - if [ "$TRAVIS_OS_NAME" = "linux" ]; then sudo add-apt-repository -y ppa:ethereum/ethereum; sudo apt-get update; sudo apt-get install -y --no-install-recommends --allow-unauthenticated libjson-rpc-cpp-dev libjsoncpp-dev libboost-all-dev libcurl4-openssl-dev libmicrohttpd-dev mesa-common-dev ocl-icd-libopencl1 opencl-headers; fi
+    - if [ "$TRAVIS_OS_NAME" = "linux" ]; then sudo add-apt-repository -y ppa:ethereum/ethereum; sudo apt-get update; sudo apt-get install -y --no-install-recommends --allow-unauthenticated libjson-rpc-cpp-dev libjsoncpp-dev libcurl4-openssl-dev libmicrohttpd-dev mesa-common-dev ocl-icd-libopencl1 opencl-headers; fi
     - if [ "$TRAVIS_OS_NAME" = "osx"   ]; then brew install libjson-rpc-cpp jsoncpp; fi
 script:
     - cmake -DETHASHCUDA=Off -DETHSTRATUM=On -DETHASHCL=On -H. -Bbuild

CMakeLists.txt

@@ -1,6 +1,13 @@
 cmake_minimum_required(VERSION 3.0)
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
 
+if (NOT DEFINED CMAKE_TOOLCHAIN_FILE)
+	# The default toolchain file configures compilers and build environment.
+	# This configuration is also used by hunter to build dependencies.
+	# CMake will cache this value, not need to explictly specify CACHE param.
+	set(CMAKE_TOOLCHAIN_FILE ${CMAKE_SOURCE_DIR}/cmake/toolchain.cmake)
+endif()
+
 include(HunterGate)
 HunterGate(
 	URL "https://github.com/ruslo/hunter/archive/v0.18.44.tar.gz"
@@ -131,6 +138,9 @@ if ("x${TARGET_PLATFORM}" STREQUAL "x")
 	set(TARGET_PLATFORM ${CMAKE_SYSTEM_NAME})
 endif ()
 
+hunter_add_package(Boost COMPONENTS system)
+find_package(Boost CONFIG REQUIRED COMPONENTS system)
+
 include(EthDependencies)
 
 configureProject()

cmake/EthCompilerSettings.cmake

@@ -3,7 +3,7 @@
 # C++11 check and activation
 if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
 
-	set(CMAKE_CXX_FLAGS "-std=c++11 -Wall -Wno-unknown-pragmas -Wextra -Wno-error=parentheses -pedantic${CMAKE_CXX_FLAGS}")
+	set(CMAKE_CXX_FLAGS "-Wall -Wno-unknown-pragmas -Wextra -Wno-error=parentheses -pedantic${CMAKE_CXX_FLAGS}")
 	set(CMAKE_CXX_FLAGS_DEBUG          "-O0 -g -DETH_DEBUG")
 	set(CMAKE_CXX_FLAGS_MINSIZEREL     "-Os -DNDEBUG -DETH_RELEASE")
 	set(CMAKE_CXX_FLAGS_RELEASE        "-O3 -DNDEBUG -DETH_RELEASE")
@@ -17,15 +17,14 @@ if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
 
 elseif ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
 
-	set(CMAKE_CXX_FLAGS "-std=c++11 -Wall -Wno-unknown-pragmas -Wextra")
+	set(CMAKE_CXX_FLAGS "-Wall -Wno-unknown-pragmas -Wextra")
 	set(CMAKE_CXX_FLAGS_DEBUG          "-O0 -g -DETH_DEBUG")
-	set(CMAKE_CXX_FLAGS_DEBUGSAN       "-O1 -g -fsanitize=address,integer,undefined -fsanitize-blacklist=${CMAKE_SOURCE_DIR}/sanitizer-blacklist.txt -fno-omit-frame-pointer -DETH_DEBUG")
 	set(CMAKE_CXX_FLAGS_MINSIZEREL     "-Os -DNDEBUG -DETH_RELEASE")
 	set(CMAKE_CXX_FLAGS_RELEASE        "-O3 -DNDEBUG -DETH_RELEASE")
 	set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g -DETH_RELEASE")
 
 	if ("${CMAKE_SYSTEM_NAME}" MATCHES "Linux")
-		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libstdc++ -fcolor-diagnostics -Qunused-arguments -DBOOST_ASIO_HAS_CLANG_LIBCXX")
+		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libstdc++ -fcolor-diagnostics -Qunused-arguments")
 	endif()
 
 elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")

cmake/EthDependencies.cmake

@@ -19,23 +19,6 @@ include_directories(${ETH_GENERATED_DIR})
 # custom cmake scripts
 set(ETH_SCRIPTS_DIR ${CMAKE_CURRENT_LIST_DIR}/scripts)
 
-# Qt5 requires opengl
-# TODO use proper version of windows SDK (32 vs 64)
-# TODO make it possible to use older versions of windows SDK (7.0+ should also work)
-# TODO it windows SDK is NOT FOUND, throw ERROR
-# from https://github.com/rpavlik/cmake-modules/blob/master/FindWindowsSDK.cmake
-if (WIN32)
-	find_package(WINDOWSSDK REQUIRED)
-	message(" - WindowsSDK dirs: ${WINDOWSSDK_DIRS}")
-	set (CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} ${WINDOWSSDK_DIRS})
-endif()
-
-# homebrew installs qts in opt
-if (APPLE)
-	set (CMAKE_PREFIX_PATH "/usr/local/opt/qt5" ${CMAKE_PREFIX_PATH})
-	set (CMAKE_PREFIX_PATH "/usr/local/opt/v8-315" ${CMAKE_PREFIX_PATH})
-endif()
-
 find_program(CTEST_COMMAND ctest)
 message(STATUS "ctest path: ${CTEST_COMMAND}")
 
@@ -72,32 +55,6 @@ endif()
 find_program(ETH_JSON_RPC_STUB jsonrpcstub)
 message(" - jsonrpcstub location    : ${ETH_JSON_RPC_STUB}")
 
-# use multithreaded boost libraries, with -mt suffix
-set(Boost_USE_MULTITHREADED ON)
-
-if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-
-# TODO hanlde other msvc versions or it will fail find them
-	set(Boost_COMPILER -vc120)
-# use static boost libraries *.lib
-	set(Boost_USE_STATIC_LIBS ON)
-
-elseif (APPLE)
-
-# use static boost libraries *.a
-	set(Boost_USE_STATIC_LIBS ON)
-
-elseif (UNIX)
-# use dynamic boost libraries .dll
-	set(Boost_USE_STATIC_LIBS OFF)
-
-endif()
-
-find_package(Boost 1.54.0 REQUIRED COMPONENTS system)
-
-message(" - boost header: ${Boost_INCLUDE_DIRS}")
-message(" - boost lib   : ${Boost_LIBRARIES}")
-
 if (APPLE)
 	link_directories(/usr/local/lib)
 	include_directories(/usr/local/include)

cmake/scripts/runtest.cmake

@@ -1,15 +0,0 @@
-# Should be used to run ctest
-# 
-# example usage:
-# cmake -DETH_TEST_NAME=TestInterfaceStub -DCTEST_COMMAND=/path/to/ctest -P scripts/runtest.cmake
-
-if (NOT CTEST_COMMAND)
-	message(FATAL_ERROR "ctest could not be found!")
-endif()
-
-# verbosity is off, cause BOOST_MESSAGE is not thread safe and output is a trash
-# see https://codecrafter.wordpress.com/2012/11/01/c-unit-test-framework-adapter-part-3/
-#
-# output might not be usefull cause of thread safety issue 
-execute_process(COMMAND ${CTEST_COMMAND} --force-new-ctest-process -C Debug --output-on-failure -j 4 -R "${ETH_TEST_NAME}[.].*")
-

cmake/toolchain.cmake

@@ -0,0 +1,3 @@
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED True)
+set(CMAKE_CXX_EXTENSIONS Off)

ethminer/CMakeLists.txt

@@ -4,7 +4,6 @@ set(CMAKE_AUTOMOC OFF)
 aux_source_directory(. SRC_LIST)
 
 include_directories(BEFORE ..)
-include_directories(${Boost_INCLUDE_DIRS})
 
 if (JSONRPC)
 	include_directories(BEFORE ${JSONCPP_INCLUDE_DIRS})

ethminer/MinerAux.h

@@ -800,7 +800,7 @@ private:
 		else if (_m == MinerType::CUDA)
 			f.start("cuda", false);
 		EthashProofOfWork::WorkPackage current, previous;
-		boost::mutex x_current;
+		std::mutex x_current;
 		EthashAux::FullType dag;
 		while (m_running)
 			try

libdevcore/CMakeLists.txt

@@ -4,7 +4,6 @@ aux_source_directory(. SOURCES)
 
 include_directories(BEFORE ${JSONCPP_INCLUDE_DIRS})
 include_directories(BEFORE ..)
-include_directories(${Boost_INCLUDE_DIRS})
 
 set(EXECUTABLE devcore)
 
@@ -12,24 +11,14 @@ file(GLOB HEADERS "*.h")
 
 add_library(devcore ${SOURCES} ${HEADERS})
 
-target_link_libraries(devcore ${Boost_THREAD_LIBRARIES})
+target_link_libraries(devcore PUBLIC ${JSONCPP_LIBRARIES} Boost::boost)
-target_link_libraries(devcore ${Boost_RANDOM_LIBRARIES})
-target_link_libraries(devcore ${Boost_FILESYSTEM_LIBRARIES})
-target_link_libraries(devcore ${Boost_SYSTEM_LIBRARIES})
-target_link_libraries(devcore ${JSONCPP_LIBRARIES})
-
-# transitive dependencies for windows executables
-if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-	target_link_libraries(${EXECUTABLE} ${Boost_CHRONO_LIBRARIES})
-	target_link_libraries(${EXECUTABLE} ${Boost_DATE_TIME_LIBRARIES})
-endif()
 
 if (APPLE)
 	find_package(Threads REQUIRED)
-	target_link_libraries(${EXECUTABLE} ${CMAKE_THREAD_LIBS_INIT})
+	target_link_libraries(${EXECUTABLE} PRIVATE ${CMAKE_THREAD_LIBS_INIT})
 elseif (UNIX)
 	find_package(Threads REQUIRED)
-	target_link_libraries(${EXECUTABLE} ${CMAKE_THREAD_LIBS_INIT})
+	target_link_libraries(${EXECUTABLE} PRIVATE ${CMAKE_THREAD_LIBS_INIT})
 endif()
 
 install( TARGETS ${EXECUTABLE} RUNTIME DESTINATION bin ARCHIVE DESTINATION lib LIBRARY DESTINATION lib )

libdevcore/Common.h

@@ -41,18 +41,8 @@
 #include <functional>
 #include <string>
 #include <chrono>
-#include <boost/current_function.hpp>
 #include <boost/functional/hash.hpp>
-#pragma warning(push)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-#include <boost/version.hpp>
-#if (BOOST_VERSION == 105800)
-	#include "boost_multiprecision_number_compare_bug_workaround.hpp"
-#endif
 #include <boost/multiprecision/cpp_int.hpp>
-#pragma warning(pop)
-#pragma GCC diagnostic pop
 #include "vector_ref.h"
 
 // CryptoPP defines byte in the global namespace, so must we.

libdevcore/Guards.h

@@ -24,12 +24,6 @@
 #include <mutex>
 #include <condition_variable>
 #include <atomic>
-#pragma warning(push)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-#include <boost/thread.hpp>
-#pragma warning(pop)
-#pragma GCC diagnostic pop
 
 namespace dev
 {

libdevcore/Log.h

@@ -25,12 +25,6 @@
 
 #include <ctime>
 #include <chrono>
-#pragma warning(push)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-#include <boost/thread.hpp>
-#pragma warning(pop)
-#pragma GCC diagnostic pop
 #include "vector_ref.h"
 #include "Common.h"
 #include "CommonData.h"

libdevcore/Worker.h

@@ -24,6 +24,7 @@
 #include <string>
 #include <thread>
 #include <atomic>
+#include <cassert>
 #include "Guards.h"
 
 namespace dev

libdevcore/boost_multiprecision_number_compare_bug_workaround.hpp

@@ -1,520 +0,0 @@
-
-// This is a copy of boost/multiprecision/detail/number_compare.hpp from boost 1.59 to replace buggy version from 1.58. 
-
-#ifdef BOOST_MP_COMPARE_HPP
-#error This bug workaround header must be included before original boost/multiprecision/detail/number_compare.hpp 
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-//  Copyright 2012 John Maddock. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_MP_COMPARE_HPP
-#define BOOST_MP_COMPARE_HPP
-
-// A copy of boost/multiprecision/traits/is_backend.hpp
-#ifndef BOOST_MP_IS_BACKEND_HPP
-#define BOOST_MP_IS_BACKEND_HPP
-
-#include <boost/mpl/has_xxx.hpp>
-#include <boost/type_traits/conditional.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-#include <boost/multiprecision/detail/number_base.hpp>
-#include <boost/multiprecision/detail/generic_interconvert.hpp>
-
-namespace boost{ namespace multiprecision{  namespace detail{
-
-   BOOST_MPL_HAS_XXX_TRAIT_DEF(signed_types)
-   BOOST_MPL_HAS_XXX_TRAIT_DEF(unsigned_types)
-   BOOST_MPL_HAS_XXX_TRAIT_DEF(float_types)
-
-   template <class T>
-   struct is_backend
-   {
-      static const bool value = has_signed_types<T>::value && has_unsigned_types<T>::value && has_float_types<T>::value;
-   };
-
-   template <class Backend>
-   struct other_backend
-   {
-      typedef typename boost::conditional<
-         boost::is_same<number<Backend>, number<Backend, et_on> >::value,
-         number<Backend, et_off>, number<Backend, et_on> >::type type;
-   };
-
-   template <class B, class V>
-   struct number_from_backend
-   {
-      typedef typename boost::conditional <
-         boost::is_convertible<V, number<B> >::value,
-         number<B>,
-         typename other_backend<B>::type > ::type type;
-   };
-
-   template <bool b, class T, class U>
-   struct is_first_backend_imp{ static const bool value = false; };
-   template <class T, class U>
-   struct is_first_backend_imp<true, T, U>{ static const bool value = is_convertible<U, number<T, et_on> >::value || is_convertible<U, number<T, et_off> >::value; };
-
-   template <class T, class U>
-   struct is_first_backend : is_first_backend_imp<is_backend<T>::value, T, U> {};
-
-   template <bool b, class T, class U>
-   struct is_second_backend_imp{ static const bool value = false; };
-   template <class T, class U>
-   struct is_second_backend_imp<true, T, U>{ static const bool value = is_convertible<T, number<U> >::value || is_convertible<T, number<U, et_off> >::value; };
-
-   template <class T, class U>
-   struct is_second_backend : is_second_backend_imp<is_backend<U>::value, T, U> {};
-
-}
-}
-}
-
-#endif // BOOST_MP_IS_BACKEND_HPP
-
-//
-// Comparison operators for number.
-//
-
-namespace boost{ namespace multiprecision{
-
-namespace default_ops{
-
-template <class B>
-inline bool eval_eq(const B& a, const B& b)
-{
-   return a.compare(b) == 0;
-}
-template <class T, class U>
-inline typename enable_if_c<boost::multiprecision::detail::is_first_backend<T, U>::value, bool>::type eval_eq(const T& a, const U& b)
-{
-   typename boost::multiprecision::detail::number_from_backend<T, U>::type t(b);
-   return eval_eq(a, t.backend());
-}
-template <class T, class U>
-inline typename enable_if_c<boost::multiprecision::detail::is_second_backend<T, U>::value, bool>::type eval_eq(const T& a, const U& b)
-{
-   typename boost::multiprecision::detail::number_from_backend<U, T>::type t(a);
-   return eval_eq(t.backend(), b);
-}
-
-template <class B>
-inline bool eval_lt(const B& a, const B& b)
-{
-   return a.compare(b) < 0;
-}
-template <class T, class U>
-inline typename enable_if_c<boost::multiprecision::detail::is_first_backend<T, U>::value, bool>::type eval_lt(const T& a, const U& b)
-{
-   typename boost::multiprecision::detail::number_from_backend<T, U>::type t(b);
-   return eval_lt(a, t.backend());
-}
-template <class T, class U>
-inline typename enable_if_c<boost::multiprecision::detail::is_second_backend<T, U>::value, bool>::type eval_lt(const T& a, const U& b)
-{
-   typename boost::multiprecision::detail::number_from_backend<U, T>::type t(a);
-   return eval_lt(t.backend(), b);
-}
-
-template <class B>
-inline bool eval_gt(const B& a, const B& b)
-{
-   return a.compare(b) > 0;
-}
-template <class T, class U>
-inline typename enable_if_c<boost::multiprecision::detail::is_first_backend<T, U>::value, bool>::type eval_gt(const T& a, const U& b)
-{
-   typename boost::multiprecision::detail::number_from_backend<T, U>::type t(b);
-   return eval_gt(a, t.backend());
-}
-template <class T, class U>
-inline typename enable_if_c<boost::multiprecision::detail::is_second_backend<T, U>::value, bool>::type eval_gt(const T& a, const U& b)
-{
-   typename boost::multiprecision::detail::number_from_backend<U, T>::type t(a);
-   return eval_gt(t.backend(), b);
-}
-
-} // namespace default_ops
-
-namespace detail{
-
-template <class Num, class Val>
-struct is_valid_mixed_compare : public mpl::false_ {};
-
-template <class B, expression_template_option ET, class Val>
-struct is_valid_mixed_compare<number<B, ET>, Val> : public is_convertible<Val, number<B, ET> > {};
-
-template <class B, expression_template_option ET>
-struct is_valid_mixed_compare<number<B, ET>, number<B, ET> > : public mpl::false_ {};
-
-template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-struct is_valid_mixed_compare<number<B, ET>, expression<tag, Arg1, Arg2, Arg3, Arg4> > 
-   : public mpl::bool_<is_convertible<expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::value> {};
-
-template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
-struct is_valid_mixed_compare<expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> > 
-   : public mpl::bool_<is_convertible<expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::value> {};
-
-template <class Backend, expression_template_option ExpressionTemplates>
-inline BOOST_CONSTEXPR typename boost::enable_if_c<number_category<Backend>::value != number_kind_floating_point, bool>::type is_unordered_value(const number<Backend, ExpressionTemplates>&)
-{
-   return false;
-}
-template <class Backend, expression_template_option ExpressionTemplates>
-inline BOOST_CONSTEXPR typename boost::enable_if_c<number_category<Backend>::value == number_kind_floating_point, bool>::type is_unordered_value(const number<Backend, ExpressionTemplates>& a)
-{
-   using default_ops::eval_fpclassify;
-   return eval_fpclassify(a.backend()) == FP_NAN;
-}
-
-template <class Arithmetic>
-inline BOOST_CONSTEXPR typename boost::enable_if_c<number_category<Arithmetic>::value != number_kind_floating_point, bool>::type is_unordered_value(const Arithmetic&)
-{
-   return false;
-}
-template <class Arithmetic>
-inline BOOST_CONSTEXPR typename boost::enable_if_c<number_category<Arithmetic>::value == number_kind_floating_point, bool>::type is_unordered_value(const Arithmetic& a)
-{
-   return (boost::math::isnan)(a);
-}
-
-template <class T, class U>
-inline BOOST_CONSTEXPR bool is_unordered_comparison(const T& a, const U& b)
-{
-   return is_unordered_value(a) || is_unordered_value(b);
-}
-
-}
-
-template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
-inline bool operator == (const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b)
-{
-   using default_ops::eval_eq;
-   if(detail::is_unordered_comparison(a, b)) return false;
-   return eval_eq(a.backend(), b.backend());
-}
-template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
-inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type 
-   operator == (const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
-{
-   using default_ops::eval_eq;
-   if(detail::is_unordered_comparison(a, b)) return false;
-   return eval_eq(a.backend(), number<Backend, ExpressionTemplates>::canonical_value(b));
-}
-template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
-inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type 
-   operator == (const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
-{
-   using default_ops::eval_eq;
-   if(detail::is_unordered_comparison(a, b)) return false;
-   return eval_eq(b.backend(), number<Backend, ExpressionTemplates>::canonical_value(a));
-}
-template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type 
-   operator == (const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
-{
-   typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
-   using default_ops::eval_eq;
-   result_type t(b);
-   if(detail::is_unordered_comparison(a, t)) return false;
-   return eval_eq(t.backend(), result_type::canonical_value(a));
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
-inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type 
-   operator == (const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
-{
-   typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
-   using default_ops::eval_eq;
-   result_type t(a);
-   if(detail::is_unordered_comparison(t, b)) return false;
-   return eval_eq(t.backend(), result_type::canonical_value(b));
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
-inline typename enable_if<is_same<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type 
-   operator == (const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
-{
-   using default_ops::eval_eq;
-   typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
-   typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
-   if(detail::is_unordered_comparison(t, t2)) return false;
-   return eval_eq(t.backend(), t2.backend());
-}
-
-template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
-inline bool operator != (const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b)
-{
-   using default_ops::eval_eq;
-   if(detail::is_unordered_comparison(a, b)) return true;
-   return !eval_eq(a.backend(), b.backend());
-}
-template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
-inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type 
-   operator != (const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
-{
-   using default_ops::eval_eq;
-   if(detail::is_unordered_comparison(a, b)) return true;
-   return !eval_eq(a.backend(), number<Backend, et_on>::canonical_value(b));
-}
-template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
-inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type 
-   operator != (const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
-{
-   using default_ops::eval_eq;
-   if(detail::is_unordered_comparison(a, b)) return true;
-   return !eval_eq(b.backend(), number<Backend, et_on>::canonical_value(a));
-}
-template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type 
-   operator != (const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
-{
-   typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
-   using default_ops::eval_eq;
-   result_type t(b);
-   if(detail::is_unordered_comparison(a, t)) return true;
-   return !eval_eq(t.backend(), result_type::canonical_value(a));
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
-inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type 
-   operator != (const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
-{
-   typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
-   using default_ops::eval_eq;
-   result_type t(a);
-   if(detail::is_unordered_comparison(t, b)) return true;
-   return !eval_eq(t.backend(), result_type::canonical_value(b));
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
-inline typename enable_if<is_same<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type 
-   operator != (const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
-{
-   using default_ops::eval_eq;
-   typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
-   typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
-   if(detail::is_unordered_comparison(t, t2)) return true;
-   return !eval_eq(t.backend(), t2.backend());
-}
-
-template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
-inline bool operator < (const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b)
-{
-   using default_ops::eval_lt;
-   if(detail::is_unordered_comparison(a, b)) return false;
-   return eval_lt(a.backend(), b.backend());
-}
-template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
-inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type 
-   operator < (const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
-{
-   using default_ops::eval_lt;
-   if(detail::is_unordered_comparison(a, b)) return false;
-   return eval_lt(a.backend(), number<Backend, ExpressionTemplates>::canonical_value(b));
-}
-template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
-inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type 
-   operator < (const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
-{
-   using default_ops::eval_gt;
-   if(detail::is_unordered_comparison(a, b)) return false;
-   return eval_gt(b.backend(), number<Backend, ExpressionTemplates>::canonical_value(a));
-}
-template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type 
-   operator < (const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
-{
-   typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
-   using default_ops::eval_gt;
-   result_type t(b);
-   if(detail::is_unordered_comparison(a, t)) return false;
-   return eval_gt(t.backend(), result_type::canonical_value(a));
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
-inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type 
-   operator < (const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
-{
-   typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
-   using default_ops::eval_lt;
-   result_type t(a);
-   if(detail::is_unordered_comparison(t, b)) return false;
-   return eval_lt(t.backend(), result_type::canonical_value(b));
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
-inline typename enable_if<is_same<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type 
-   operator < (const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
-{
-   using default_ops::eval_lt;
-   typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
-   typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
-   if(detail::is_unordered_comparison(t, t2)) return false;
-   return eval_lt(t.backend(), t2.backend());
-}
-
-template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
-inline bool operator > (const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b)
-{
-   using default_ops::eval_gt;
-   if(detail::is_unordered_comparison(a, b)) return false;
-   return eval_gt(a.backend(), b.backend());
-}
-template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
-inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type 
-   operator > (const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
-{
-   using default_ops::eval_gt;
-   if(detail::is_unordered_comparison(a, b)) return false;
-   return eval_gt(a.backend(), number<Backend, ExpressionTemplates>::canonical_value(b));
-}
-template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
-inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type 
-   operator > (const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
-{
-   using default_ops::eval_lt;
-   if(detail::is_unordered_comparison(a, b)) return false;
-   return eval_lt(b.backend(), number<Backend, ExpressionTemplates>::canonical_value(a));
-}
-template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type 
-   operator > (const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
-{
-   typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
-   using default_ops::eval_lt;
-   result_type t(b);
-   if(detail::is_unordered_comparison(a, t)) return false;
-   return a > t;
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
-inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type 
-   operator > (const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
-{
-   typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
-   using default_ops::eval_gt;
-   result_type t(a);
-   if(detail::is_unordered_comparison(t, b)) return false;
-   return t > b;
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
-inline typename enable_if<is_same<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type 
-   operator > (const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
-{
-   using default_ops::eval_gt;
-   typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
-   typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
-   if(detail::is_unordered_comparison(t, t2)) return false;
-   return t > t2;
-}
-
-template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
-inline bool operator <= (const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b)
-{
-   using default_ops::eval_gt;
-   if(detail::is_unordered_comparison(a, b)) return false;
-   return !eval_gt(a.backend(), b.backend());
-}
-template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
-inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type 
-   operator <= (const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
-{
-   using default_ops::eval_gt;
-   if(detail::is_unordered_comparison(a, b)) return false;
-   return !eval_gt(a.backend(), number<Backend, ExpressionTemplates>::canonical_value(b));
-}
-template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
-inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type 
-   operator <= (const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
-{
-   using default_ops::eval_lt;
-   if(detail::is_unordered_comparison(a, b)) return false;
-   return !eval_lt(b.backend(), number<Backend, ExpressionTemplates>::canonical_value(a));
-}
-template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type 
-   operator <= (const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
-{
-   typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
-   using default_ops::eval_lt;
-   if(detail::is_unordered_value(a) || detail::is_unordered_value(b))
-      return false;
-   result_type t(b);
-   if(detail::is_unordered_comparison(a, t)) return false;
-   return !eval_lt(t.backend(), result_type::canonical_value(a));
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
-inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type 
-   operator <= (const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
-{
-   typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
-   using default_ops::eval_gt;
-   result_type t(a);
-   if(detail::is_unordered_comparison(t, b)) return false;
-   return !eval_gt(t.backend(), result_type::canonical_value(b));
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
-inline typename enable_if<is_same<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type 
-   operator <= (const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
-{
-   using default_ops::eval_gt;
-   typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
-   typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
-   if(detail::is_unordered_comparison(t, t2)) return false;
-   return !eval_gt(t.backend(), t2.backend());
-}
-
-template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
-inline bool operator >= (const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b)
-{
-   using default_ops::eval_lt;
-   if(detail::is_unordered_comparison(a, b)) return false;
-   return !eval_lt(a.backend(), b.backend());
-}
-template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
-inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type 
-   operator >= (const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
-{
-   using default_ops::eval_lt;
-   if(detail::is_unordered_comparison(a, b)) return false;
-   return !eval_lt(a.backend(), number<Backend, ExpressionTemplates>::canonical_value(b));
-}
-template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
-inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type 
-   operator >= (const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
-{
-   using default_ops::eval_gt;
-   if(detail::is_unordered_comparison(a, b)) return false;
-   return !eval_gt(b.backend(), number<Backend, ExpressionTemplates>::canonical_value(a));
-}
-template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type 
-   operator >= (const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
-{
-   typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
-   using default_ops::eval_gt;
-   result_type t(b);
-   if(detail::is_unordered_comparison(a, t)) return false;
-   return !eval_gt(t.backend(), result_type::canonical_value(a));
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
-inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type 
-   operator >= (const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
-{
-   typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
-   using default_ops::eval_lt;
-   result_type t(a);
-   if(detail::is_unordered_comparison(t, b)) return false;
-   return !eval_lt(t.backend(), result_type::canonical_value(b));
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
-inline typename enable_if<is_same<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type 
-   operator >= (const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
-{
-   using default_ops::eval_lt;
-   typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
-   typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
-   if(detail::is_unordered_comparison(t, t2)) return false;
-   return !eval_lt(t.backend(), t2.backend());
-}
-
-
-}} // namespaces
-
-#endif // BOOST_MP_COMPARE_HPP

libethash-cl/CMakeLists.txt

@@ -20,7 +20,6 @@ file(GLOB OUR_HEADERS "*.h")
 set(HEADERS ${OUR_HEADERS} ${CMAKE_CURRENT_BINARY_DIR}/ethash_cl_miner_kernel.h)
 
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
-include_directories(${Boost_INCLUDE_DIRS})
 include_directories(..)
 add_library(${EXECUTABLE} ${SRC_LIST} ${HEADERS})
 target_include_directories(${EXECUTABLE} PUBLIC SYSTEM ${OpenCL_INCLUDE_DIR})

libethcore/CMakeLists.txt

@@ -1,17 +1,14 @@
-cmake_policy(SET CMP0015 NEW)
-
 file(GLOB SOURCES "*.cpp")
 file(GLOB HEADERS "*.h")
 
 include_directories(BEFORE ..)
-include_directories(${Boost_INCLUDE_DIRS})
 
 if (ETHASHCUDA)
 	include_directories(${CUDA_INCLUDE_DIRS})
 endif ()
 
 add_library(ethcore ${SOURCES} ${HEADERS})
-target_link_libraries(ethcore ethash pthread)
+target_link_libraries(ethcore ethash devcore pthread)
 
 if (ETHASHCL)
 	target_link_libraries(ethcore ethash-cl)

libstratum/CMakeLists.txt

@@ -1,15 +1,11 @@
-set(EXECUTABLE ethstratum)
-
-aux_source_directory(. SRC_LIST)
-
 include_directories(..)
-include_directories(${Boost_INCLUDE_DIRS})
 include_directories(${JSONCPP_INCLUDE_DIRS})
 
-file(GLOB HEADERS "*.h")
+set(SOURCES
-
+    EthStratumClient.h EthStratumClient.cpp
-add_library(${EXECUTABLE} ${SRC_LIST} ${HEADERS})
+    EthStratumClientV2.h EthStratumClientV2.cpp
-target_link_libraries(${EXECUTABLE} ${Boost_SYSTEM_LIBRARY} ${Boost_THREAD_LIBRARY} ${Boost_REGEX_LIBRARY} pthread) 
+)
 
-install( TARGETS ${EXECUTABLE} RUNTIME DESTINATION bin ARCHIVE DESTINATION lib LIBRARY DESTINATION lib )
+add_library(ethstratum ${SOURCES})
-install( FILES ${HEADERS} DESTINATION include/${EXECUTABLE} )
+target_link_libraries(ethstratum PUBLIC Boost::system)
+target_include_directories(ethstratum PUBLIC SYSTEM ${JSONCPP_INCLUDE_DIRS})

libstratum/EthStratumClient.h

@@ -65,11 +65,11 @@ private:
 
 	int m_waitState = MINER_WAIT_STATE_WORK;
 
-	boost::mutex x_pending;
+	std::mutex x_pending;
 	int m_pending;
 
 	GenericFarm<EthashProofOfWork> * p_farm;
-	boost::mutex x_current;
+	std::mutex x_current;
 	EthashProofOfWork::WorkPackage m_current;
 	EthashProofOfWork::WorkPackage m_previous;