Remove clang warnings and reactivate clang compilation in travis

anokl · anokl · commit 45f967f77401 · 2017-12-11T10:22:46.000+01:00
diff --git a/.travis.yml b/.travis.yml
@@ -30,24 +30,24 @@ matrix:
           packages:
             - g++-6
       env: COMPILER=g++-6
-#    - compiler: clang
-#      addons:
-#        apt:
-#          sources:
-#            - ubuntu-toolchain-r-test
-#            - llvm-toolchain-precise-3.6
-#          packages:
-#            - clang-3.6
-#      env: COMPILER=clang++-3.6
-#    - compiler: clang
-#      addons:
-#        apt:
-#          sources:
-#            - ubuntu-toolchain-r-test
-#            - llvm-toolchain-precise-3.7
-#          packages:
-#            - clang-3.7
-#      env: COMPILER=clang++-3.7
+    - compiler: clang
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.7
+          packages:
+            - clang-3.7
+      env: COMPILER=clang++-3.7
+    - compiler: clang
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.8
+          packages:
+            - clang-3.8
+      env: COMPILER=clang++-3.8
       
 before_install:
     - if [ "$TRAVIS_OS_NAME" == "linux" ]; then
diff --git a/Disruptor.PerfTests/OneToOneRawThroughputTest.cpp b/Disruptor.PerfTests/OneToOneRawThroughputTest.cpp
@@ -25,12 +25,12 @@ namespace PerfTests
         const auto expectedCount = m_myRunnable->sequence->value() + m_iterations;
         m_myRunnable->reset(latch, expectedCount);
 
-        auto consumerTask = m_taskScheduler->scheduleAndStart(std::move(std::packaged_task< void() >([this] { m_myRunnable->run(); })));
+        auto consumerTask = m_taskScheduler->scheduleAndStart(std::packaged_task< void() >([this] { m_myRunnable->run(); }));
         stopwatch.start();
 
         auto sequencer = m_sequencer;
 
-        auto producerTask = m_taskScheduler->scheduleAndStart(std::move(std::packaged_task< void() >([this, sequencer, latch]
+        auto producerTask = m_taskScheduler->scheduleAndStart(std::packaged_task< void() >([this, sequencer, latch]
         {
             auto& s = *sequencer;
             for (std::int64_t i = 0; i < m_iterations; ++i)
@@ -40,7 +40,7 @@ namespace PerfTests
             }
 
             latch->waitOne();
-        })));
+        }));
 
         producerTask.wait();
         stopwatch.stop();
diff --git a/Disruptor.PerfTests/OneToThreeSequencedThroughputTest.cpp b/Disruptor.PerfTests/OneToThreeSequencedThroughputTest.cpp
@@ -58,7 +58,7 @@ namespace PerfTests
         for (auto i = 0; i < m_numEventProcessors; ++i)
         {
             m_handlers[i]->reset(latch, m_batchEventProcessors[i]->sequence()->value() + m_iterations);
-            processorTasks.push_back(std::move(m_executor->execute([this, i] { m_batchEventProcessors[i]->run(); })));
+            processorTasks.push_back(m_executor->execute([this, i] { m_batchEventProcessors[i]->run(); }));
         }
 
         auto& rb = *m_ringBuffer;
diff --git a/Disruptor.PerfTests/PingPongSequencedLatencyTest.cpp b/Disruptor.PerfTests/PingPongSequencedLatencyTest.cpp
@@ -79,7 +79,6 @@ namespace PerfTests
     {
         auto t1 = Stopwatch::getTimestamp();
 
-        auto nano = std::chrono::nanoseconds(t1 - m_t0);
         m_latencyRecorder->record(LatencyTestSession::convertStopwatchTicksToNano((double)(t1 - m_t0)));
 
         if (data.value < m_maxEvents)
diff --git a/Disruptor.PerfTests/ThreeToOneSequencedThroughputTest.cpp b/Disruptor.PerfTests/ThreeToOneSequencedThroughputTest.cpp
@@ -38,9 +38,9 @@ namespace PerfTests
         for (auto i = 0; i < m_numPublishers; ++i)
         {
             auto index = i;
-            futures[i] = m_scheduler->scheduleAndStart(std::move(std::packaged_task< void() >([this, index] { m_valuePublishers[index](m_cyclicBarrier, m_ringBuffer, m_iterations); })));
+            futures[i] = m_scheduler->scheduleAndStart(std::packaged_task< void() >([this, index] { m_valuePublishers[index](m_cyclicBarrier, m_ringBuffer, m_iterations); }));
         }
-        auto processorTask = m_scheduler->scheduleAndStart(std::move(std::packaged_task< void() >([this] { m_batchEventProcessor->run(); })));
+        auto processorTask = m_scheduler->scheduleAndStart(std::packaged_task< void() >([this] { m_batchEventProcessor->run(); }));
 
         stopwatch.start();
         m_cyclicBarrier->signal();
diff --git a/Disruptor.PerfTests/TwoToTwoWorkProcessorThroughputTest.cpp b/Disruptor.PerfTests/TwoToTwoWorkProcessorThroughputTest.cpp
@@ -35,7 +35,7 @@ namespace PerfTests
         for (auto i = 0; i < m_numPublishers; ++i)
         {
             auto index = i;
-            futures[i] = std::move(std::async(std::launch::async, [this, index] { m_valuePublishers[index]->run(); }));
+            futures[i] = std::async(std::launch::async, [this, index] { m_valuePublishers[index]->run(); });
         }
 
         for (auto&& processor : m_workProcessors)
diff --git a/Disruptor.Tests/EventPublisherTests.cpp b/Disruptor.Tests/EventPublisherTests.cpp
@@ -15,8 +15,7 @@ namespace Tests
     {
         struct Translator : public IEventTranslator< LongEvent >
         {
-            explicit Translator(EventPublisherFixture& fixture)
-                : m_fixture(fixture)
+            explicit Translator(EventPublisherFixture&)
             {
             }
 
@@ -25,8 +24,6 @@ namespace Tests
                 eventData.value = sequence + 29;
             }
 
-        private:
-            EventPublisherFixture& m_fixture;
         };
 
         EventPublisherFixture()
diff --git a/Disruptor.Tests/StubExecutor.cpp b/Disruptor.Tests/StubExecutor.cpp
@@ -16,10 +16,10 @@ namespace Tests
         if (!m_ignoreExecutions)
         {
             std::packaged_task< void() > task(command);
-            result = std::move(task.get_future());
+            result = task.get_future();
 
             std::lock_guard< decltype(m_mutex) > lock(m_mutex);
-            m_threads.push_back(std::move(boost::thread(std::move(task))));
+            m_threads.push_back(boost::thread(std::move(task)));
         }
 
         return result;
diff --git a/Disruptor/RingBuffer.h b/Disruptor/RingBuffer.h
@@ -539,7 +539,7 @@ namespace Disruptor
             if (batchStartsAt + batchSize > argumentCount)
             {
                 DISRUPTOR_THROW_ARGUMENT_EXCEPTION("A batchSize of: " << batchSize <<
-                    " with batchStartsAt of: " + batchStartsAt <<
+                    " with batchStartsAt of: " << batchStartsAt <<
                     " will overrun the available number of arguments: " << (argumentCount - batchStartsAt));
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ namespace PerfTests`
`58`	`58`	`for (auto i = 0; i < m_numEventProcessors; ++i)`
`59`	`59`	`{`
`60`	`60`	`m_handlers[i]->reset(latch, m_batchEventProcessors[i]->sequence()->value() + m_iterations);`
`61`		`- processorTasks.push_back(std::move(m_executor->execute([this, i] { m_batchEventProcessors[i]->run(); })));`
	`61`	`+ processorTasks.push_back(m_executor->execute([this, i] { m_batchEventProcessors[i]->run(); }));`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`auto& rb = *m_ringBuffer;`
Original file line number	Diff line number	Diff line change
`@@ -79,7 +79,6 @@ namespace PerfTests`
`79`	`79`	`{`
`80`	`80`	`auto t1 = Stopwatch::getTimestamp();`
`81`	`81`
`82`		`- auto nano = std::chrono::nanoseconds(t1 - m_t0);`
`83`	`82`	`m_latencyRecorder->record(LatencyTestSession::convertStopwatchTicksToNano((double)(t1 - m_t0)));`
`84`	`83`
`85`	`84`	`if (data.value < m_maxEvents)`
Original file line number	Diff line number	Diff line change
`@@ -38,9 +38,9 @@ namespace PerfTests`
`38`	`38`	`for (auto i = 0; i < m_numPublishers; ++i)`
`39`	`39`	`{`
`40`	`40`	`auto index = i;`
`41`		`- futures[i] = m_scheduler->scheduleAndStart(std::move(std::packaged_task< void() >([this, index] { m_valuePublishers[index](m_cyclicBarrier, m_ringBuffer, m_iterations); })));`
	`41`	`+ futures[i] = m_scheduler->scheduleAndStart(std::packaged_task< void() >([this, index] { m_valuePublishers[index](m_cyclicBarrier, m_ringBuffer, m_iterations); }));`
`42`	`42`	`}`
`43`		`- auto processorTask = m_scheduler->scheduleAndStart(std::move(std::packaged_task< void() >([this] { m_batchEventProcessor->run(); })));`
	`43`	`+ auto processorTask = m_scheduler->scheduleAndStart(std::packaged_task< void() >([this] { m_batchEventProcessor->run(); }));`
`44`	`44`
`45`	`45`	`stopwatch.start();`
`46`	`46`	`m_cyclicBarrier->signal();`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ namespace PerfTests`
`35`	`35`	`for (auto i = 0; i < m_numPublishers; ++i)`
`36`	`36`	`{`
`37`	`37`	`auto index = i;`
`38`		`- futures[i] = std::move(std::async(std::launch::async, [this, index] { m_valuePublishers[index]->run(); }));`
	`38`	`+ futures[i] = std::async(std::launch::async, [this, index] { m_valuePublishers[index]->run(); });`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`for (auto&& processor : m_workProcessors)`
Original file line number	Diff line number	Diff line change
`@@ -15,8 +15,7 @@ namespace Tests`
`15`	`15`	`{`
`16`	`16`	`struct Translator : public IEventTranslator< LongEvent >`
`17`	`17`	`{`
`18`		`- explicit Translator(EventPublisherFixture& fixture)`
`19`		`- : m_fixture(fixture)`
	`18`	`+ explicit Translator(EventPublisherFixture&)`
`20`	`19`	`{`
`21`	`20`	`}`
`22`	`21`
`@@ -25,8 +24,6 @@ namespace Tests`
`25`	`24`	`eventData.value = sequence + 29;`
`26`	`25`	`}`
`27`	`26`
`28`		`- private:`
`29`		`- EventPublisherFixture& m_fixture;`
`30`	`27`	`};`
`31`	`28`
`32`	`29`	`EventPublisherFixture()`
Original file line number	Diff line number	Diff line change
`@@ -16,10 +16,10 @@ namespace Tests`
`16`	`16`	`if (!m_ignoreExecutions)`
`17`	`17`	`{`
`18`	`18`	`std::packaged_task< void() > task(command);`
`19`		`- result = std::move(task.get_future());`
	`19`	`+ result = task.get_future();`
`20`	`20`
`21`	`21`	`std::lock_guard< decltype(m_mutex) > lock(m_mutex);`
`22`		`- m_threads.push_back(std::move(boost::thread(std::move(task))));`
	`22`	`+ m_threads.push_back(boost::thread(std::move(task)));`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`return result;`
Original file line number	Diff line number	Diff line change
`@@ -539,7 +539,7 @@ namespace Disruptor`
`539`	`539`	`if (batchStartsAt + batchSize > argumentCount)`
`540`	`540`	`{`
`541`	`541`	`DISRUPTOR_THROW_ARGUMENT_EXCEPTION("A batchSize of: " << batchSize <<`
`542`		`- " with batchStartsAt of: " + batchStartsAt <<`
	`542`	`+ " with batchStartsAt of: " << batchStartsAt <<`
`543`	`543`	`" will overrun the available number of arguments: " << (argumentCount - batchStartsAt));`
`544`	`544`	`}`
`545`	`545`	`}`