Finishing up the CMDP implementation

Details:
 - Making the types accessible in DataLine
 - Making the types accessible in DataPoint
 - Making the types accessible in Diagram
 - Removing the DataLineId feature from DataLine
 - Switching to using OrderedDict as the container in Diagram
 - Not removing the whitespaces from the data to fix messing up the titles with spaces
 - Added checks for duplicate DataLine IDs
 - Added checks for not-existing DataLine IDs
 - Updating the MDP with DataLine IDs (not used in MDP)
 - Adding copy and move constructors and operators to OrderedDict
 - Adding duplicate key check for push_back() and emplace_back() in OrderedDict
 - Fixing the push_back() signature in OrderedDict
 - Adding begin() and end() to OrderedDict
 - Adding new tests for the rest of the CMDP test files
 - Updating the DataLine unit tests
 - Updating the OrderedDict unit tests

Author: KGergo88

application/sources/continous_measurement_data_protocol.cpp

@@ -38,17 +38,12 @@ std::string ContinousMeasurementDataProtocol::GetProtocolName(void)
 std::vector<DiagramSpecialized> ContinousMeasurementDataProtocol::ProcessData(std::istream& input_data)
 {
     std::vector<DiagramSpecialized> assembled_diagrams;
-    std::string received_data;
     std::string actual_line_std_string;
-    QString actual_line;
 
     while(std::getline(input_data, actual_line_std_string))
     {
         QRegularExpressionMatch match;
-
-        // Removing the whitespaces from the actual line
-        actual_line_std_string.erase(std::remove_if(actual_line_std_string.begin(), actual_line_std_string.end(), isspace), actual_line_std_string.end());
-        actual_line = QString::fromStdString(actual_line_std_string);
+        QString actual_line = QString::fromStdString(actual_line_std_string);
 
         switch(state)
         {
@@ -98,9 +93,14 @@ std::vector<DiagramSpecialized> ContinousMeasurementDataProtocol::ProcessData(st
                     while(regex_iterator.hasNext())
                     {
                         auto match = regex_iterator.next();
-                        auto y_index = match.captured("id");
+                        auto y_id = match.captured("id");
                         auto y_title = match.captured("title");
-                        actual_diagram.AddNewDataLine(y_index.toStdString(), y_title.toStdString());
+
+                        // Adding the new dataline to the diagram, if we fail (because of duplicate IDs) then we drop this diagram
+                        if(!actual_diagram.AddNewDataLine(y_id.toStdString(), y_title.toStdString()))
+                        {
+                            state = Constants::States::WaitingForHeaderMessageStart;
+                        }
                     }
 
                     state = Constants::States::WaitingForHeaderMessageEnd;
@@ -147,9 +147,18 @@ std::vector<DiagramSpecialized> ContinousMeasurementDataProtocol::ProcessData(st
                     while(regex_iterator.hasNext())
                     {
                         auto match = regex_iterator.next();
-                        auto y_index = match.captured("id");
+                        auto y_id = match.captured("id");
                         auto y_value = match.captured("value");
-                        actual_diagram.AddNewDataPoint(y_index.toStdString(), DataPointSpecialized(x_value.toDouble(), y_value.toDouble()));
+
+                        // Checking whether the dataline existsm if not we are dropping this diagram
+                        if(actual_diagram.HasDataLine(y_id.toStdString()))
+                        {
+                            actual_diagram.AddNewDataPoint(y_id.toStdString(), DataPointSpecialized(x_value.toDouble(), y_value.toDouble()));
+                        }
+                        else
+                        {
+                            state = Constants::States::WaitingForHeaderMessageStart;
+                        }
                     }
                 }
                 else

application/sources/data_line.hpp

@@ -40,8 +40,10 @@ template <typename T_DATA_POINT, typename T_INDEX >
 class DataLine
 {
 public:
-    explicit DataLine(const std::string& newDataLineId = invalid_id,
-                      const std::string& newDataLineTitle = "") : DataLineId(newDataLineId), DataLineTitle(newDataLineTitle) {}
+    using coordinate_t = T_DATA_POINT;
+    using index_t = T_INDEX;
+
+    explicit DataLine(const std::string& newDataLineTitle = "") : DataLineTitle(newDataLineTitle) {}
 
     DataLine(const DataLine& newDataLine) = default;
     DataLine(DataLine&& newDataLine) = default;
@@ -61,48 +63,38 @@ class DataLine
         DataLineTitle = newDataLineTitle;
     }
 
-    inline std::string GetId(void) const
-    {
-        return DataLineId;
-    }
-
-    inline void SetId(const std::string& newDataLineId)
-    {
-        DataLineId = newDataLineId;
-    }
-
-    inline void AddNewDataPoint(const DataPoint<T_DATA_POINT>& newDataPoint)
+    inline void AddNewDataPoint(const DataPoint<coordinate_t>& newDataPoint)
     {
         Data.push_back(newDataPoint);
     }
 
-    inline DataLine<T_DATA_POINT, T_INDEX>& operator<<(const DataPoint<T_DATA_POINT>& newDataPoint)
+    inline DataLine<coordinate_t, index_t>& operator<<(const DataPoint<coordinate_t>& newDataPoint)
     {
         AddNewDataPoint(newDataPoint);
         return *this;
     }
 
-    inline T_INDEX GetTheNumberOfDataPoints(void) const
+    inline index_t GetTheNumberOfDataPoints(void) const
     {
         return Data.size();
     }
 
-    inline const DataPoint<T_DATA_POINT> GetDataPoint(const T_INDEX& dataPointIndex) const
+    inline const DataPoint<coordinate_t> GetDataPoint(const index_t& dataPointIndex) const
     {
         CheckDataPointIndex(dataPointIndex);
 
         return Data[dataPointIndex];
     }  
 
-    inline void SetDataPoint(const T_INDEX& dataPointIndex, const DataPoint<T_DATA_POINT>& newDataPoint)
+    inline void SetDataPoint(const index_t& dataPointIndex, const DataPoint<coordinate_t>& newDataPoint)
     {
         CheckDataPointIndex(dataPointIndex);
 
         Data[dataPointIndex] = newDataPoint;
     }
 
-    inline const DataPoint<T_DATA_POINT> GetDataPointWithMinValue(const std::function<bool(DataPoint<T_DATA_POINT>,
-                                                                                           DataPoint<T_DATA_POINT>)>& compare) const
+    inline const DataPoint<coordinate_t> GetDataPointWithMinValue(const std::function<bool(DataPoint<coordinate_t>,
+                                                                                           DataPoint<coordinate_t>)>& compare) const
     {
         auto min_value = std::min_element(Data.begin(), Data.end(), compare);
 
@@ -115,8 +107,8 @@ class DataLine
         return *min_value;
     }
 
-    inline const DataPoint<T_DATA_POINT> GetDataPointWithMaxValue(const std::function<bool(DataPoint<T_DATA_POINT>,
-                                                                                           DataPoint<T_DATA_POINT>)>& compare) const
+    inline const DataPoint<coordinate_t> GetDataPointWithMaxValue(const std::function<bool(DataPoint<coordinate_t>,
+                                                                                           DataPoint<coordinate_t>)>& compare) const
     {
         auto max_value = std::max_element(Data.begin(), Data.end(), compare);
 
@@ -129,10 +121,8 @@ class DataLine
         return *max_value;
     }
 
-    static constexpr char invalid_id[] = "invalid_id";
-
 private:
-    void CheckDataPointIndex(const T_INDEX& dataPointIndex) const
+    void CheckDataPointIndex(const index_t& dataPointIndex) const
     {
         if(Data.size() <= dataPointIndex)
         {
@@ -144,9 +134,8 @@ class DataLine
         }
     }
 
-    std::string DataLineId;
     std::string DataLineTitle;
-    std::vector<DataPoint<T_DATA_POINT> > Data;
+    std::vector<DataPoint<coordinate_t> > Data;
 };
 
 

application/sources/data_point.hpp

@@ -34,7 +34,9 @@ template <typename T_DATA_POINT>
 class DataPoint
 {
 public:
-    DataPoint(const T_DATA_POINT& newX = 0, const T_DATA_POINT& newY = 0) : x(newX), y(newY) {}
+    using coordinate_t = T_DATA_POINT;
+
+    DataPoint(const coordinate_t& newX = 0, const coordinate_t& newY = 0) : x(newX), y(newY) {}
     DataPoint(const DataPoint&  newDataPoint) : x(newDataPoint.x), y(newDataPoint.y) {}
     DataPoint(DataPoint&& newDataPoint) : x(newDataPoint.x), y(newDataPoint.y) {}
 
@@ -45,24 +47,24 @@ class DataPoint
     bool operator==(const DataPoint& other) const {return ((x == other.x) && (y == other.y));}
     bool operator!=(const DataPoint& other) const {return !(*this == other);}
 
-    inline const T_DATA_POINT GetX(void) const {return x;}
-    inline const T_DATA_POINT GetY(void) const {return y;}
+    inline const coordinate_t GetX(void) const {return x;}
+    inline const coordinate_t GetY(void) const {return y;}
 
-    inline static const T_DATA_POINT GetXValueOf(const DataPoint& object) {return object.GetX();}
-    inline static const T_DATA_POINT GetYValueOf(const DataPoint& object) {return object.GetY();}
+    inline static const coordinate_t GetXValueOf(const DataPoint& object) {return object.GetX();}
+    inline static const coordinate_t GetYValueOf(const DataPoint& object) {return object.GetY();}
 
-    inline void SetX(const T_DATA_POINT newX = 0) {x = newX;}
-    inline void SetY(const T_DATA_POINT newY = 0) {y = newY;}
+    inline void SetX(const coordinate_t newX = 0) {x = newX;}
+    inline void SetY(const coordinate_t newY = 0) {y = newY;}
 
-    inline static void SetXValueOf(DataPoint& object, const T_DATA_POINT newX = 0) {object.SetX(newX);}
-    inline static void SetYValueOf(DataPoint& object, const T_DATA_POINT newY = 0) {object.SetY(newY);}
+    inline static void SetXValueOf(DataPoint& object, const coordinate_t newX = 0) {object.SetX(newX);}
+    inline static void SetYValueOf(DataPoint& object, const coordinate_t newY = 0) {object.SetY(newY);}
 
     inline static bool CompareXValues(const DataPoint& object_A, const DataPoint& object_B) {return (GetXValueOf(object_A) < GetXValueOf(object_B));}
     inline static bool CompareYValues(const DataPoint& object_A, const DataPoint& object_B) {return (GetYValueOf(object_A) < GetYValueOf(object_B));}
 
 private:
-    T_DATA_POINT x;
-    T_DATA_POINT y;
+    coordinate_t x;
+    coordinate_t y;
 };
 
 

application/sources/diagram.hpp

@@ -22,10 +22,10 @@
 
 
 #include <string>
-#include <vector>
 #include <algorithm>
 
 #include "global.hpp"
+#include "ordered_dict.h"
 #include "data_point.hpp"
 #include "data_line.hpp"
 
@@ -39,8 +39,11 @@
 template <typename T_DATA_POINT, typename T_INDEX >
 class Diagram {
 public:
-    using DataLine_t = DataLine<T_DATA_POINT, T_INDEX>;
-    using DataPoint_t = DataPoint<T_DATA_POINT>;
+    using coordinate_t = T_DATA_POINT;
+    using index_t = T_INDEX;
+    using DataPoint_t = DataPoint<coordinate_t>;
+    using DataLine_t = DataLine<coordinate_t, index_t>;
+    using DataContainer_t = OrderedDict<DataLine_t>;
 
     Diagram(const std::string& newDiagramTitle = "", const std::string& newAxisXTitle = "") : DiagramTitle(newDiagramTitle), AxisXTitle(newAxisXTitle) {}
 
@@ -72,102 +75,75 @@ class Diagram {
         AxisXTitle = newAxisXTitle;
     }
 
-    void AddNewDataLine(const std::string& newDataLineId = DataLine_t::invalid_id,
+    bool AddNewDataLine(const std::string& newDataLineId,
                         const std::string& newDataLineTitle = "")
     {
-        Data.push_back(DataLine_t(newDataLineId, newDataLineTitle));
+        return Data.emplace_back(newDataLineId, DataLine_t(newDataLineTitle));
     }
 
-    inline const T_INDEX GetTheNumberOfDataLines(void) const
+    inline bool HasDataLine(const index_t& dataLineIndex) const
     {
-        return Data.size();
+        return (!Data.empty() && (dataLineIndex <= GetTheNumberOfDataLines()));
     }
 
-    inline const std::string GetDataLineTitle(const T_INDEX& dataLineIndex) const
+    inline bool HasDataLine(const std::string& dataLineId) const
     {
-        CheckDataLineIndex(dataLineIndex);
-
-        return Data[dataLineIndex].GetTitle();
+        return Data.hasKey(dataLineId);
     }
 
-    inline void SetDataLineTitle(const T_INDEX& dataLineIndex, const std::string& newDataLineTitle)
+    inline const index_t GetTheNumberOfDataLines(void) const
     {
-        CheckDataLineIndex(dataLineIndex);
-
-        Data[dataLineIndex].SetTitle(newDataLineTitle);
+        return Data.size();
     }
 
-    inline std::string GetDataLineId(const T_INDEX& dataLineIndex) const
+    inline const std::string GetDataLineTitle(const index_t& dataLineIndex) const
     {
         CheckDataLineIndex(dataLineIndex);
 
-        return Data[dataLineIndex].GetId();
+        return Data[dataLineIndex].GetTitle();
     }
 
-    inline void SetDataLineId(const T_INDEX& dataLineIndex, const std::string& newDataLineId)
+    inline void SetDataLineTitle(const index_t& dataLineIndex, const std::string& newDataLineTitle)
     {
         CheckDataLineIndex(dataLineIndex);
 
-        Data[dataLineIndex].SetId(newDataLineId);
-    }
-
-    inline bool GetDataLineIndex(const std::string& dataLineId, T_INDEX& dataLineIndex) const
-    {
-        bool result = false;
-        dataLineIndex = 0;
-
-        for(auto const& dataLine : Data)
-        {
-            if(dataLine.GetId() == dataLineId)
-            {
-                result = true;
-                break;
-            }
-            dataLineIndex++;
-        }
-
-        return result;
+        Data[dataLineIndex].SetTitle(newDataLineTitle);
     }
 
-    void AddNewDataPoint(T_INDEX dataLineIndex, const DataPoint_t& newDataPoint)
+    void AddNewDataPoint(const index_t& dataLineIndex, const DataPoint_t& newDataPoint)
     {
         CheckDataLineIndex(dataLineIndex);
 
         Data[dataLineIndex].AddNewDataPoint(newDataPoint);
     }
 
-    void AddNewDataPoint(std::string dataLineId, const DataPoint_t& newDataPoint)
+    void AddNewDataPoint(const std::string& dataLineId, const DataPoint_t& newDataPoint)
     {
-        T_INDEX data_line_index = 0;
-
-        if(GetDataLineIndex(dataLineId, data_line_index))
-        {
-            Data[data_line_index].AddNewDataPoint(newDataPoint);
-        }
+        Data[dataLineId].AddNewDataPoint(newDataPoint);
     }
 
-    inline const T_INDEX GetTheNumberOfDataPoints(const T_INDEX& dataLineIndex) const
+    inline const index_t GetTheNumberOfDataPoints(const index_t& dataLineIndex) const
     {
         CheckDataLineIndex(dataLineIndex);
 
         return Data[dataLineIndex].GetTheNumberOfDataPoints();
     }
 
-    inline const DataPoint_t GetDataPoint(const T_INDEX& dataLineIndex, const T_INDEX& dataPointIndex) const
+    inline const DataPoint_t GetDataPoint(const index_t& dataLineIndex, const index_t& dataPointIndex) const
     {
         CheckDataLineIndex(dataLineIndex);
 
         return Data[dataLineIndex].GetDataPoint(dataPointIndex);
     }
 
-    void SetDataPoint(const T_INDEX& dataLineIndex, const T_INDEX& dataPointIndex, const DataPoint_t& newDataPoint)
+    void SetDataPoint(const index_t& dataLineIndex, const index_t& dataPointIndex, const DataPoint_t& newDataPoint)
     {
         CheckDataLineIndex(dataLineIndex);
 
         Data[dataLineIndex].SetDataPoint(dataPointIndex, newDataPoint);
     }    
 
-    std::pair<DataPoint_t, DataPoint_t> GetExtremeValues(const T_INDEX& dataLineIndex) const
+    std::pair<DataPoint_t, DataPoint_t> GetExtremeValues(const index_t& dataLineIndex) const
     {
         CheckDataLineIndex(dataLineIndex);
 
@@ -192,10 +168,10 @@ class Diagram {
 
             for(const auto& i : Data)
             {
-                data_points_with_min_x_values.AddNewDataPoint(i.GetDataPointWithMinValue(DataPoint_t::CompareXValues));
-                data_points_with_max_x_values.AddNewDataPoint(i.GetDataPointWithMaxValue(DataPoint_t::CompareXValues));
-                data_points_with_min_y_values.AddNewDataPoint(i.GetDataPointWithMinValue(DataPoint_t::CompareYValues));
-                data_points_with_max_y_values.AddNewDataPoint(i.GetDataPointWithMaxValue(DataPoint_t::CompareYValues));
+                data_points_with_min_x_values.AddNewDataPoint(i.second.GetDataPointWithMinValue(DataPoint_t::CompareXValues));
+                data_points_with_max_x_values.AddNewDataPoint(i.second.GetDataPointWithMaxValue(DataPoint_t::CompareXValues));
+                data_points_with_min_y_values.AddNewDataPoint(i.second.GetDataPointWithMinValue(DataPoint_t::CompareYValues));
+                data_points_with_max_y_values.AddNewDataPoint(i.second.GetDataPointWithMaxValue(DataPoint_t::CompareYValues));
             }
 
             auto min_x_value = data_points_with_min_x_values.GetDataPointWithMinValue(DataPoint_t::CompareXValues).GetX();
@@ -222,7 +198,7 @@ class Diagram {
     }
 
 private:
-    void CheckDataLineIndex(const T_INDEX& dataLineIndex) const
+    void CheckDataLineIndex(const index_t& dataLineIndex) const
     {
         if(Data.size() <= dataLineIndex)
         {
@@ -236,7 +212,7 @@ class Diagram {
 
     std::string DiagramTitle;
     std::string AxisXTitle;
-    std::vector<DataLine_t> Data;
+    DataContainer_t Data;
 };