Removal of boost progress bar, replaced with simple RAII class

CMakeLists.txt

 			add_definitions(-DHAVE_BOOST_SPECIAL_FUNCTIONS)
 		endif()
 	endif()
-	find_path( HAVE_BOOST_PROGRESS "boost/progress.hpp" ) 
-		if(HAVE_BOOST_PROGRESS)
-		add_definitions(-DHAVE_BOOST_PROGRESS)
-	endif()
 endif()
 
 if (LEMMA_PYTHON3_BINDINGS)

Modules/FDEM1D/include/EMEarth1D.h

 #include "QWEKey.h"
 #include "CubicSplineInterpolator.h"
 
-#ifdef HAVE_BOOST_PROGRESS
-#include "boost/progress.hpp"
-#endif
+#include "ProgressBar.h"
 
 namespace Lemma {
 

Modules/FDEM1D/src/EMEarth1D.cpp

     EMEarth1D::EMEarth1D( const ctor_key& key ) : LemmaObject( key ),
             Dipole(nullptr), Earth(nullptr), Receivers(nullptr), Antenna(nullptr),
             FieldsToCalculate(BOTH), HankelType(ANDERSON801), icalcinner(0), icalc(0)
-        //#ifdef HAVE_BOOST_PROGRESS
-        //    , disp(0)
-        //#endif
         {
     }
 
 
     void EMEarth1D::CalculateWireAntennaFields(bool progressbar) {
 
-        #ifdef HAVE_BOOST_PROGRESS
-        boost::progress_display *disp;
-        #endif
+        ProgressBar *mdisp;
 
         if (Earth == nullptr) {
             throw NullEarth();
             if ( Antenna->IsHorizontallyPlanar() && ( HankelType == ANDERSON801 || HankelType == FHTKEY201  || HankelType==FHTKEY101 ||
                                                       HankelType == FHTKEY51    || HankelType == FHTKONG61  || HankelType == FHTKONG121 ||
                                                       HankelType == FHTKONG241  || HankelType == IRONS )) {
-                #ifdef HAVE_BOOST_PROGRESS
                 if (progressbar) {
-                    disp = new boost::progress_display( Receivers->GetNumberOfPoints()*Antenna->GetNumberOfFrequencies() );
+                    mdisp = new ProgressBar( Receivers->GetNumberOfPoints()*Antenna->GetNumberOfFrequencies(), "Progress");
                 }
-                #endif
+
                 for (int ifreq=0; ifreq<Antenna->GetNumberOfFrequencies();++ifreq) {
                     Real wavef = 2.*PI* Antenna->GetFrequency(ifreq);
                     #ifdef LEMMAUSEOMP
                     #endif
                     for (int irec=0; irec<Receivers->GetNumberOfPoints(); ++irec) {
                         SolveLaggedTxRxPair(irec, Hankel.get(), wavef, ifreq, AntCopy.get());
-                        #ifdef HAVE_BOOST_PROGRESS
-                        if (progressbar) ++(*disp);
-                        #endif
+                        if (progressbar) {
+                            ++(*mdisp);
+                        }
                     }
                     #pragma omp barrier
                     #ifdef LEMMAUSEOMP
 
                 //std::cout << "freq parallel #1" << std::endl;
                 //** Progress display bar for long calculations */
-                #ifdef HAVE_BOOST_PROGRESS
                 if (progressbar) {
-                    disp = new boost::progress_display( Receivers->GetNumberOfPoints()*Antenna->GetNumberOfFrequencies() );
+                    mdisp = new ProgressBar( Receivers->GetNumberOfPoints()*Antenna->GetNumberOfFrequencies() );
                 }
-                #endif
+
                 // parallelise across receivers
                 #ifdef LEMMAUSEOMP
                 #pragma omp parallel
                         //std::cout << "Normal Path\n";
                         //std::cout << Receivers->GetHfield(0, irec) << std::endl;
                         //if (irec == 1) exit(0);
-                        #ifdef HAVE_BOOST_PROGRESS
-                        if (progressbar) ++(*disp);
-                        #endif
+                        if (progressbar) {
+                            ++(*mdisp);
+                        }
                     } // receiver loop
                 } // OMP_PARALLEL BLOCK
             } else if (Antenna->GetNumberOfFrequencies() > 8) {
                             } // frequency loop
                         } // OMP_PARALLEL BLOCK
                     } // mask loop
-                    #ifdef HAVE_BOOST_PROGRESS
                     //if (Receivers->GetNumberOfPoints() > 100) {
-                    //    ++ disp;
+                    //    ++ mdisp;
                     //}
-                    #endif
                 } // receiver loop
                 //std::cout << "End freq parallel " << std::endl;
             } // Frequency Parallel
                             } // frequency loop
                         } // OMP_PARALLEL BLOCK
                     } // mask loop
-                    #ifdef HAVE_BOOST_PROGRESS
                     //if (Receivers->GetNumberOfPoints() > 100) {
                     //    ++ disp;
                     //}
-                    #endif
                 } // receiver loop
            } // Polygonal parallel logic
         } else {
             this->Dipole = nullptr;
         }
 
-        #ifdef HAVE_BOOST_PROGRESS
         if (progressbar) {
-            delete disp;
+            delete mdisp;
         }
-        #endif
+
     }
 
     #ifdef KIHALEE_EM1D

Modules/LemmaCore/include/ProgressBar.h

+#ifndef PROGRESS_BAR_H
+#define PROGRESS_BAR_H
+
+#include <string>
+
+/**
+ * RAII implementation of a progress bar.
+ * available from https://stackoverflow.com/questions/46717885/make-boostprogress-display-work-when-more-information-is-being-printed-to-the
+ */
+class ProgressBar
+{
+public:
+    /**
+     * Constructor.
+     * It takes two values: the expected number of iterations whose progress we
+     * want to monitor and an initial message to be displayed on top of the bar
+     * (which can be updated with updateLastPrintedMessage()).
+     */
+    ProgressBar(
+            uint32_t expectedIterations, const std::string& initialMessage="");
+
+    /**
+     * Destructor to guarantee RAII.
+     */
+    ~ProgressBar();
+
+    // Make the object non-copyable
+    ProgressBar(const ProgressBar& o) = delete;
+    ProgressBar& operator=(const ProgressBar& o) = delete;
+
+    /**
+     * Must be invoked when the progress bar is no longer needed to restore the
+     * position of the cursor to the end of the output.
+     * It is automatically invoked when the object is destroyed.
+     */
+    void endProgressBar();
+
+    /**
+     * Prints a new message under the last printed message, without overwriting
+     * it. This moves the progress bar down to be placed under the newly
+     * written message.
+     */
+    void printNewMessage(const std::string& message);
+
+    /**
+     * Prints a message while the progress bar is on the screen on top on the
+     * last printed message. Since the cursor is right at the beginning of the
+     * progress bar, it moves the cursor up by one line before printing, and
+     * then returns it to its original position.
+     */
+    void updateLastPrintedMessage(const std::string& message);
+
+    /**
+     * Overloaded prefix operator, used to indicate that the has been a new
+     * iteration.
+     */
+    void operator++();
+
+private:
+    unsigned int mTotalIterations;
+    unsigned int mNumberOfTicks;
+    bool mEnded;
+    size_t mLengthOfLastPrintedMessage;
+};
+
+#endif /* PROGRESS_BAR_H */
+

Modules/LemmaCore/src/CMakeLists.txt

 set (SOURCE 
 	${SOURCE}
+	${CMAKE_CURRENT_SOURCE_DIR}/ProgressBar.cpp                # external to Lemma
 	${CMAKE_CURRENT_SOURCE_DIR}/helper.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/LemmaObject.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/ASCIIParser.cpp                # key 

Modules/LemmaCore/src/ProgressBar.cpp

+#include "ProgressBar.h"
+#include <iostream>
+#include <iomanip>
+#include <sstream>
+
+#define LENGTH_OF_PROGRESS_BAR 55
+#define PERCENTAGE_BIN_SIZE (100.0/LENGTH_OF_PROGRESS_BAR)
+
+namespace
+{
+    std::string generateProgressBar(unsigned int percentage)
+    {
+        const int progress = static_cast<int>(percentage/PERCENTAGE_BIN_SIZE);
+        std::ostringstream ss;
+        ss << " " << std::setw(3) << std::right << percentage << "% ";
+        std::string bar("[" + std::string(LENGTH_OF_PROGRESS_BAR-2, ' ') + "]");
+
+        unsigned int numberOfSymbols = std::min(
+                std::max(0, progress - 1),
+                LENGTH_OF_PROGRESS_BAR - 2);
+
+        bar.replace(1, numberOfSymbols, std::string(numberOfSymbols, '|'));
+
+        ss << bar;
+        return ss.str();
+    }
+}
+
+ProgressBar::ProgressBar(
+            uint32_t expectedIterations, const std::string& initialMessage)
+    : mTotalIterations(expectedIterations),
+      mNumberOfTicks(0),
+      mEnded(false)
+{
+    std::cout << initialMessage << "\n";
+    mLengthOfLastPrintedMessage = initialMessage.size();
+    std::cout << generateProgressBar(0) << "\r" << std::flush;
+}
+
+ProgressBar::~ProgressBar()
+{
+    endProgressBar();
+}
+
+void ProgressBar::operator++()
+{
+    if (mEnded)
+    {
+        throw std::runtime_error(
+                "Attempted to use progress bar after having terminated it");
+    }
+
+    mNumberOfTicks = std::min(mTotalIterations, mNumberOfTicks+1);
+    const unsigned int percentage = static_cast<unsigned int>(
+            mNumberOfTicks*100.0/mTotalIterations);
+
+    std::cout << generateProgressBar(percentage) << "\r" << std::flush;
+}
+
+void ProgressBar::printNewMessage(const std::string& message)
+{
+    if (mEnded)
+    {
+        throw std::runtime_error(
+                "Attempted to use progress bar after having terminated it");
+    }
+
+    std::cout << "\r"
+        << std::left
+        << std::setw(LENGTH_OF_PROGRESS_BAR + 6)
+        << message << "\n";
+    mLengthOfLastPrintedMessage = message.size();
+    const unsigned int percentage = static_cast<unsigned int>(
+            mNumberOfTicks*100.0/mTotalIterations);
+
+    std::cout << generateProgressBar(percentage) << "\r" << std::flush;
+
+}
+
+void ProgressBar::updateLastPrintedMessage(const std::string& message)
+{
+    if (mEnded)
+    {
+        throw std::runtime_error(
+                "Attempted to use progress bar after having terminated it");
+    }
+
+    std::cout << "\r\033[F"
+        << std::left
+        << std::setw(mLengthOfLastPrintedMessage)
+        << message << "\n";
+    mLengthOfLastPrintedMessage = message.size();
+}
+
+void ProgressBar::endProgressBar()
+{
+    if (!mEnded)
+    {
+        std::cout << std::string(2, '\n');
+    }
+    mEnded = true;
+}
+