[boost] Use C++11 stdlib classes instead of boost.

src/xpcc/architecture/platform/driver/can/canusb/canusb.hpp

@@ -14,8 +14,8 @@
 #include <string>
 
 #include <xpcc/architecture/interface/can.hpp>
-#include <boost/thread/mutex.hpp>
-#include <boost/thread.hpp>
+#include <mutex>
+#include <thread>
 
 namespace xpcc
 {
@@ -83,8 +83,8 @@ class CanUsb : public ::xpcc::Can
 	update();
 
 private:
-	typedef boost::mutex				Mutex;
-	typedef boost::mutex::scoped_lock	MutexGuard;
+	typedef std::mutex				Mutex;
+	typedef std::lock_guard<Mutex>	MutexGuard;
 
 	Mutex stateLock;
 	Mutex readBufferLock;
@@ -97,7 +97,7 @@ class CanUsb : public ::xpcc::Can
 	std::string tmpRead;
 	std::queue<can::Message> readBuffer;
 
-	boost::thread* thread;
+	std::thread* thread;
 };
 
 }	// namespace hosted

src/xpcc/architecture/platform/driver/can/canusb/canusb_impl.hpp

@@ -134,8 +134,7 @@ xpcc::hosted::CanUsb<SerialPort>::open(xpcc::Can::Bitrate canBitrate)
 			MutexGuard stateGuard(this->stateLock);
 			this->active = true;
 		}
-		this->thread = new boost::thread(
-				boost::bind(&xpcc::hosted::CanUsb<SerialPort>::update, this));
+		this->thread = new std::thread(&xpcc::hosted::CanUsb<SerialPort>::update, this);
 
 		busState = BusState::Connected;
 		this->tmpRead.clear();

src/xpcc/communication/xpcc/backend/tipc/receiver.cpp

@@ -50,7 +50,7 @@ xpcc::tipc::Receiver::Receiver(
 	isAlive_(true)
 {
 	// The start of the thread has to be placed _after_ the initialization of isAlive_
-	this->receiverThread_.reset(new Thread(boost::bind(&Receiver::runReceiver, this)));
+	this->receiverThread_.reset(new Thread(&Receiver::runReceiver, this));
 }
 
 // ----------------------------------------------------------------------------

src/xpcc/communication/xpcc/backend/tipc/receiver.hpp

@@ -33,9 +33,9 @@
 
 #include <queue>
 
-#include <boost/thread/mutex.hpp>
-#include <boost/thread/thread.hpp>
-#include <boost/scoped_ptr.hpp>
+#include <mutex>
+#include <thread>
+#include <memory>
 
 #include <xpcc/container/smart_pointer.hpp>
 
@@ -95,10 +95,10 @@ namespace xpcc
 			dropPacket();
 
 		private:
-			typedef xpcc::SmartPointer			Payload;
-			typedef boost::mutex				Mutex;
-			typedef boost::mutex::scoped_lock	MutexGuard;
-			typedef	boost::thread				Thread;
+			typedef xpcc::SmartPointer		Payload;
+			typedef std::mutex				Mutex;
+			typedef std::lock_guard<Mutex>	MutexGuard;
+			typedef	std::thread				Thread;
 
 			bool
 			isAlive();
@@ -115,7 +115,7 @@ namespace xpcc
 
 			std::queue<Payload>	packetQueue_;
 
-			boost::scoped_ptr<Thread> receiverThread_;
+			std::unique_ptr<Thread> receiverThread_;
 			mutable Mutex receiverSocketLock_;
 			mutable Mutex packetQueueLock_;
 

src/xpcc/communication/xpcc/backend/tipc/receiver_socket.cpp

@@ -33,8 +33,9 @@
 #include <linux/tipc.h>
 #include <errno.h>
 #include <cstring>
+#include <unistd.h>
 
-#include <boost/scoped_array.hpp>
+#include <memory>
 
 #include <iostream>
 
@@ -144,7 +145,8 @@ xpcc::tipc::ReceiverSocket::receivePayload(uint8_t* payloadPointer, size_t paylo
 	int result = 0;
 
 	// Allocate memory for the whole packet inclusive header
-	boost::scoped_array<uint8_t> packetPointer ( new uint8_t[ sizeof(Header) + payloadLength ] );
+
+	std::unique_ptr<uint8_t[]> packetPointer ( new uint8_t[ sizeof(Header) + payloadLength ] );
 
 	result = recv(	this->socketDescriptor_,
 					packetPointer.get(),

src/xpcc/communication/xpcc/backend/tipc/receiver_socket.hpp

@@ -32,7 +32,6 @@
 
 #include "header.hpp"
 
-#include <boost/scoped_array.hpp>
 #include <stdint.h>
 
 namespace xpcc {

src/xpcc/processing/rtos/mutex.hpp

@@ -34,7 +34,7 @@
 #include <xpcc/architecture/utils.hpp>
 
 #ifdef XPCC__OS_HOSTED
-#	include "boost/mutex.hpp"
+#	include "stdlib/mutex.hpp"
 #elif defined(XPCC__CPU_CORTEX_M3) || defined(XPCC__CPU_CORTEX_M4)
 #	include "freertos/mutex.hpp"
 #endif

src/xpcc/processing/rtos/queue.hpp

@@ -34,7 +34,7 @@
 #include <xpcc/architecture/utils.hpp>
 
 #ifdef XPCC__OS_HOSTED
-#	include "boost/queue.hpp"
+#	include "stdlib/queue.hpp"
 #elif defined(XPCC__CPU_CORTEX_M3) || defined(XPCC__CPU_CORTEX_M4)
 #	include "freertos/queue.hpp"
 #endif

src/xpcc/processing/rtos/scheduler.hpp

@@ -34,7 +34,7 @@
 #include <xpcc/architecture/utils.hpp>
 
 #ifdef XPCC__OS_HOSTED
-#	include "boost/scheduler.hpp"
+#	include "stdlib/scheduler.hpp"
 #elif defined(XPCC__CPU_CORTEX_M3) || defined(XPCC__CPU_CORTEX_M4)
 #	include "freertos/scheduler.hpp"
 #endif

src/xpcc/processing/rtos/semaphore.hpp

@@ -34,7 +34,7 @@
 #include <xpcc/architecture/utils.hpp>
 
 #ifdef XPCC__OS_HOSTED
-#	include "boost/semaphore.hpp"
+#	include "stdlib/semaphore.hpp"
 #elif defined(XPCC__CPU_CORTEX_M3) || defined(XPCC__CPU_CORTEX_M4)
 #	include "freertos/semaphore.hpp"
 #endif

src/xpcc/processing/rtos/boost/mutex.cpp → src/xpcc/processing/rtos/stdlib/mutex.cpp

@@ -29,6 +29,7 @@
 // ----------------------------------------------------------------------------
 
 #include "../mutex.hpp"
+#include <chrono>
 
 // ----------------------------------------------------------------------------
 xpcc::rtos::Mutex::Mutex()
@@ -43,6 +44,5 @@ xpcc::rtos::Mutex::~Mutex()
 bool
 xpcc::rtos::Mutex::acquire(uint32_t timeout)
 {
-	return mutex.timed_lock(
-			boost::posix_time::milliseconds(timeout));
+	return mutex.try_lock_for(std::chrono::milliseconds(timeout));
 }

src/xpcc/processing/rtos/boost/mutex.hpp → src/xpcc/processing/rtos/stdlib/mutex.hpp

@@ -35,8 +35,7 @@
 #	error "Don't include this file directly, use <xpcc/processing/rtos/mutex.hpp>"
 #endif
 
-#include <boost/thread/mutex.hpp>
-#include <boost/thread/locks.hpp>
+#include <mutex>
 
 namespace xpcc
 {
@@ -48,7 +47,7 @@ namespace xpcc
 		/**
 		 * \brief	Mutex
 		 * 
-		 * \ingroup	boost_rtos
+		 * \ingroup	stdlib_rtos
 		 */
 		class Mutex
 		{
@@ -85,19 +84,19 @@ namespace xpcc
 			Mutex&
 			operator = (const Mutex& other);
 
-			boost::timed_mutex mutex;
+			std::timed_mutex mutex;
 		};
 
 		/**
 		 * Implements a RAII-style locking.
 		 * 
 		 * Locks the Mutex when created and unlocks it on destruction.
 		 */
-		class MutexGuard : boost::lock_guard<boost::timed_mutex>
+		class MutexGuard : std::lock_guard<std::timed_mutex>
 		{
 		public:
 			MutexGuard(Mutex& m) :
-				boost::lock_guard<boost::timed_mutex>(m.mutex)
+				std::lock_guard<std::timed_mutex>(m.mutex)
 			{
 			}
 

src/xpcc/processing/rtos/boost/queue.hpp → src/xpcc/processing/rtos/stdlib/queue.hpp

@@ -38,7 +38,7 @@
 #include <stdint.h>
 #include <deque>
 
-#include <boost/thread/mutex.hpp>
+#include <mutex>
 #include <xpcc/container/deque.hpp>
 
 namespace xpcc
@@ -101,7 +101,7 @@ namespace xpcc
 			Queue&
 			operator = (const Queue& other);
 
-			mutable boost::timed_mutex mutex;
+			mutable std::timed_mutex mutex;
 
 			uint32_t maxSize;
 			std::deque<T> deque;

src/xpcc/processing/rtos/boost/queue_impl.hpp → src/xpcc/processing/rtos/stdlib/queue_impl.hpp

@@ -32,6 +32,8 @@
 #	error "Don't use this file directly, use 'queue.hpp' instead!"
 #endif
 
+#include <chrono>
+
 template <typename T>
 xpcc::rtos::Queue<T>::Queue(uint32_t length) :
 	maxSize(length)
@@ -47,15 +49,15 @@ template <typename T>
 std::size_t
 xpcc::rtos::Queue<T>::getSize() const
 {
-	boost::lock_guard<boost::timed_mutex> lock(mutex);
+	std::lock_guard<std::timed_mutex> lock(mutex);
 	deque.size();
 }
 
 template <typename T>
 bool
 xpcc::rtos::Queue<T>::append(const T& item, uint32_t timeout = -1)
 {
-	if (!mutex.timed_lock(boost::posix_time::milliseconds(timeout)) ||
+	if (!mutex.try_lock_for(std::chrono::milliseconds(timeout)) ||
 			deque.size() >= maxSize) {
 		return false;
 	}
@@ -68,7 +70,7 @@ template <typename T>
 bool
 xpcc::rtos::Queue<T>::prepend(const T& item, uint32_t timeout = -1)
 {
-	if (!mutex.timed_lock(boost::posix_time::milliseconds(timeout))) {
+	if (!mutex.try_lock_for(std::chrono::milliseconds(timeout))) {
 		return false;
 	}
 
@@ -88,7 +90,7 @@ template <typename T>
 bool
 xpcc::rtos::Queue<T>::peek(T& item, uint32_t timeout = -1) const
 {
-	if (!mutex.timed_lock(boost::posix_time::milliseconds(timeout))) {
+	if (!mutex.try_lock_for(std::chrono::milliseconds(timeout))) {
 		return false;
 	}
 
@@ -107,7 +109,7 @@ template <typename T>
 bool
 xpcc::rtos::Queue<T>::get(T& item, uint32_t timeout = -1)
 {
-	if (!mutex.timed_lock(boost::posix_time::milliseconds(timeout))) {
+	if (!mutex.try_lock_for(std::chrono::milliseconds(timeout))) {
 		return false;
 	}
 

src/xpcc/processing/rtos/boost/scheduler.cpp → src/xpcc/processing/rtos/stdlib/scheduler.cpp

@@ -45,6 +45,6 @@ xpcc::rtos::Scheduler::schedule()
 	{
 		// Threads are started and will do all the work. Just
 		// sleep a bit here when there is nothing else to do. 
-		boost::this_thread::sleep(boost::posix_time::milliseconds(1000));
+		std::this_thread::sleep_for(std::chrono::milliseconds(1000));
 	}
 }

src/xpcc/processing/rtos/boost/scheduler.hpp → src/xpcc/processing/rtos/stdlib/scheduler.hpp

@@ -35,7 +35,7 @@
 #	error "Don't include this file directly, use <xpcc/processing/rtos/scheduler.hpp>"
 #endif
 
-#include <boost/thread/thread.hpp>
+#include <thread>
 
 namespace xpcc
 {

src/xpcc/processing/rtos/boost/semaphore.cpp → src/xpcc/processing/rtos/stdlib/semaphore.cpp

@@ -29,6 +29,7 @@
 // ----------------------------------------------------------------------------
 
 #include "../semaphore.hpp"
+#include <chrono>
 
 // ----------------------------------------------------------------------------
 xpcc::rtos::Semaphore::Semaphore(uint32_t max, uint32_t initial) :
@@ -40,11 +41,10 @@ xpcc::rtos::Semaphore::Semaphore(uint32_t max, uint32_t initial) :
 bool
 xpcc::rtos::Semaphore::acquire(uint32_t timeout)
 {
-	boost::unique_lock<boost::mutex> lock(mutex);
+	std::unique_lock<std::mutex> lock(mutex);
 	while (count == 0)
 	{
-		 if (!condition.timed_wait(lock,
-				 boost::posix_time::milliseconds(timeout))) {
+		 if (condition.wait_for(lock, std::chrono::milliseconds(timeout)) == std::cv_status::timeout) {
 			 return false;
 		 }
 	}
@@ -56,7 +56,7 @@ xpcc::rtos::Semaphore::acquire(uint32_t timeout)
 void
 xpcc::rtos::Semaphore::release()
 {
-	boost::unique_lock<boost::mutex> lock(mutex);
+	std::unique_lock<std::mutex> lock(mutex);
 
 	if (count < maxCount) {
 		++count;

src/xpcc/processing/rtos/boost/semaphore.hpp → src/xpcc/processing/rtos/stdlib/semaphore.hpp

@@ -35,8 +35,8 @@
 #	error "Don't include this file directly, use <xpcc/processing/rtos/semaphore.hpp>"
 #endif
 
-#include <boost/thread/mutex.hpp>    
-#include <boost/thread/condition_variable.hpp>
+#include <mutex>
+#include <condition_variable>
 
 namespace xpcc
 {
@@ -125,10 +125,10 @@ namespace xpcc
 			// 
 			// Any code that reads or writes the count_ data must hold a lock
 			// on the mutex.
-			mutable boost::mutex mutex;
+			mutable std::mutex mutex;
 
 			// Code that increments count_ must notify the condition variable.
-			mutable boost::condition_variable condition;
+			mutable std::condition_variable condition;
 
 		};
 

src/xpcc/processing/rtos/boost/thread.cpp → src/xpcc/processing/rtos/stdlib/thread.cpp

@@ -63,5 +63,5 @@ xpcc::rtos::Thread::~Thread()
 void
 xpcc::rtos::Thread::start()
 {
-	this->thread.reset(new boost::thread(boost::bind(&Thread::run, this)));
+	this->thread.reset(new std::thread(&Thread::run, this));
 }