Update: Made the namespaces of the functions/classes consistent + moved the private headers into the src directory

Author: xatavian

CMakeLists.txt

@@ -10,6 +10,10 @@ set(CPPPARSER_INCLUDE_DIRECTORY
 	${CMAKE_CURRENT_LIST_DIR}/include
 )
 
+set(CPPPARSER_INCLUDE_DIRECTORY_PRIVATE 
+	${CMAKE_CURRENT_LIST_DIR}/src/parsing
+)
+
 set(CPPPARSER_SRC_FILES
 	src/models/CANDatabase.cpp
 	src/models/CANFrame.cpp
@@ -30,7 +34,8 @@ add_library(cpp-can-parser
 	${CPPPARSER_SRC_FILES})
 target_include_directories(cpp-can-parser 
 	PUBLIC ${CPPPARSER_INCLUDE_DIRECTORY}
-		   ${CMAKE_CURRENT_BINARY_DIR}/exports/)
+		   ${CMAKE_CURRENT_BINARY_DIR}/exports/
+	PRIVATE ${CPPPARSER_INCLUDE_DIRECTORY_PRIVATE})
 generate_export_header(cpp-can-parser
 	BASE_NAME cpp_can_parser
 	EXPORT_FILE_NAME ${CMAKE_CURRENT_BINARY_DIR}/exports/cpp_can_parser_export.h)

include/CANDatabase.h

@@ -3,12 +3,259 @@
 
 #include <string>
 #include <memory>
-#include <exception>
+#include <stdexcept>
 #include <map>
+#include <vector>
 
 #include "cpp_can_parser_export.h"
-#include "CANFrame.h"
-#include "CANDatabaseException.h"
+
+namespace CppCAN {
+
+/**
+ * @brief A CAN signal of a frame in the CAN Database
+ * A CANSignal is represented by the following attributes:
+ * - Name
+ * - Start bit
+ * - Length
+ * - Scale
+ * - Offset
+ * - Endianness
+ * - Signedness
+ * - Minimum (optional)
+ * - Maximum (optional)
+ * - Comment (optional)
+ * - Choices (optional) : map of unsigned int -> std::string (so one can associate 
+ *                        a string value to an integer value)
+ * 
+ * All the attributes except for the comment and choices must be defined at the instanciation
+ * and are immutable.
+ */
+class CPP_CAN_PARSER_EXPORT CANSignal {
+public:
+  struct CPP_CAN_PARSER_EXPORT Range {
+    static Range fromString(const std::string& minstr, const std::string& maxstr);
+
+    Range() = default; 
+    Range(long m, long mm);
+
+    bool defined;
+    long min;
+    long max;
+  };
+
+  enum Signedness {
+    Unsigned, Signed
+  };
+
+  enum Endianness {
+    BigEndian, LittleEndian
+  };
+
+public:
+  CANSignal() = delete;
+  CANSignal(const std::string& name, unsigned int start_bit, unsigned int length,
+            double scale, double offset, Signedness signedness, Endianness endianness, Range range = Range());
+  CANSignal(const CANSignal&) = default;
+  CANSignal(CANSignal&&) = default;
+  CANSignal& operator=(const CANSignal&) = default;
+  CANSignal& operator=(CANSignal&&) = default;
+
+  const std::string& name() const;
+
+  unsigned int start_bit() const;
+
+  unsigned int length() const;
+
+  const std::string& comment() const;
+
+  double scale() const;
+
+  double offset() const;
+
+  const Range& range() const;
+
+  Signedness signedness() const;
+
+  Endianness endianness() const;
+
+  const std::map<unsigned int, std::string>& choices() const;
+
+  void setComment(const std::string& comment);
+
+  void setChoices(const std::map<unsigned int, std::string>& choices);
+
+private:
+  std::string name_;
+  unsigned int start_bit_;
+  unsigned int length_;
+  double scale_;
+  double offset_;
+  Signedness signedness_;
+  Endianness endianness_;
+  Range range_;
+  std::string comment_;
+  std::map<unsigned int, std::string> choices_;
+};
+
+/**
+ * @brief Object that gathers all the properties of a single frame. 
+ * 
+ * A CANFrame instance is characterized by the following properties:
+ * - Name
+ * - CAN ID
+ * - DLC
+ * - Period (optional)
+ * - Comment (optional)
+ * - List of signals
+ * 
+ * The name, CAN ID and DLC must be defined at the instanciation and are immutable.
+ * The comment and period can respectivelly be changed with setComment() and setPeriod().
+ * The list of signals can be modified with addSignal() and removeSignal(). Use clear()
+ * to empty the signals' list.
+ * 
+ * One can access the CANSignal with at() or operator[]. **Be careful as both will throw
+ * a CANDatabaseException if the given key does noy match any signal in the frame.** To check
+ * if a signal is present, use contains(). Signals can be found both by their start bit 
+ * or their name.
+ * 
+ * CANFrame also behaves like a regular iterable: it defines the functions begin(), end(), 
+ * cbegin(), cend(), ... You can traverse all the signals of the frame in a range-for loop
+ * or use the standard library's algorithms !
+ */
+class CPP_CAN_PARSER_EXPORT CANFrame {
+public:
+  using container_type = std::map<std::string, CANSignal>;
+  using iterator = container_type::iterator;
+  using const_iterator = container_type::const_iterator;
+  using reverse_iterator = container_type::reverse_iterator;
+  using const_reverse_iterator = container_type::const_reverse_iterator;
+
+public:
+  // You cannot construct an empty frame.
+  CANFrame() = delete;
+
+  /**
+   * @brief Construct a new frame.
+   * @param name Name of the frame
+   * @param can_id CAN ID of the frame
+   * @param dlc DLC of the frame
+   * @param comment Optional comment for the frame
+   */
+  CANFrame(const std::string& name, unsigned long long can_id, unsigned int dlc, 
+           unsigned int period = 0, const std::string& comment = "");
+
+  CANFrame(const CANFrame&) = default;
+  CANFrame& operator=(const CANFrame&) = default;
+  CANFrame(CANFrame&&) = default;
+  CANFrame& operator=(CANFrame&&) = default;
+
+public:
+  /**
+   * @return The name of the frame
+   */
+  const std::string& name() const;
+
+  /**
+   * @return The CAN ID of the frame
+   */
+  unsigned long long can_id() const;
+
+  /**
+   * @return The DLC of the frame
+   */
+  unsigned int dlc() const;
+
+  /**
+   * @return The period of the frame (If unspecified, then return 0)
+   */
+  unsigned int period() const;
+
+  /**
+   * @return The comment associated with the frame (if unspecified, return an empty string)
+   */
+  const std::string& comment() const;
+
+public:
+  /**
+   * @brief Sets a new value for the frame's period.
+   */
+  void setPeriod(unsigned int val);
+
+  /**
+   * @brief Updates the frame's associated comment.
+   */
+  void setComment(const std::string& comment);
+
+public:
+  /**
+   * @brief Fetches the signal with the given name.
+   * @see at
+   */
+  const CANSignal& operator[](const std::string& name) const;
+  
+  /**
+   * @brief Fetches the signal with the given name.
+   * @see at
+   */
+  CANSignal& operator[](const std::string& name);
+
+  /**
+   * @brief Fetches the signal with the given name.
+   */
+  const CANSignal& at(const std::string& name) const;
+  
+  /**
+   * @brief Fetches the signal with the given name.
+   */
+  CANSignal& at(const std::string& name);
+  
+  /**
+   * @return true if a signal with the given name is already registered with the current frame.
+   */
+  bool contains(const std::string& name) const;
+
+  /**
+   * @brief Registers the given signal with the frame.
+   */
+  void addSignal(const CANSignal& signal);
+
+  /**
+   * @brief Removes the signal associated with the given name
+   */
+  void removeSignal(const std::string& name);
+
+public:
+  iterator begin();
+  const_iterator begin() const;
+  const_iterator cbegin() const;
+
+  iterator end();
+  const_iterator end() const;
+  const_iterator cend() const;
+
+  reverse_iterator rbegin();
+  const_reverse_iterator rbegin() const;
+  const_reverse_iterator crbegin() const;
+
+  reverse_iterator rend();
+  const_reverse_iterator rend() const;
+  const_reverse_iterator crend() const;
+
+  std::size_t size() const;
+
+  void clear();
+
+  friend void swap(CANFrame& first, CANFrame& second);
+
+private:
+  std::string name_;
+  unsigned long long can_id_;
+  unsigned int dlc_;
+  unsigned int period_;
+  std::string comment_;
+  
+  container_type map_;
+};
 
 /**
  * @brief A CAN database object
@@ -29,7 +276,7 @@ class CPP_CAN_PARSER_EXPORT CANDatabase {
   /**
    * @brief A parsing warning and its location
    */
-  struct parsing_warning {
+  struct CPP_CAN_PARSER_EXPORT parsing_warning {
     unsigned long long line;
     std::string description;
   };
@@ -54,12 +301,12 @@ class CPP_CAN_PARSER_EXPORT CANDatabase {
     const std::string& src_string, std::vector<parsing_warning>* warnings = nullptr);
 
 public:
-  struct IDKey {
+  struct CPP_CAN_PARSER_EXPORT IDKey {
     std::string str_key;
     unsigned long long int_key;
   };
 
-  struct IntIDKeyCompare {
+  struct CPP_CAN_PARSER_EXPORT IntIDKeyCompare {
     bool operator()(const IDKey& k1, const IDKey& k2) const;
   };
 
@@ -104,6 +351,7 @@ class CPP_CAN_PARSER_EXPORT CANDatabase {
   CANDatabase& operator=(CANDatabase&&);
 
   ~CANDatabase();
+
 public:
   /**
    * @brief Get the frame with the given frame name
@@ -201,4 +449,13 @@ class CPP_CAN_PARSER_EXPORT CANDatabase {
   CANDatabaseImpl* impl;
 };
 
+/**
+ * @brief Exception type for the library's operations
+ */
+class CANDatabaseException : public std::runtime_error {
+public:
+  using std::runtime_error::runtime_error;
+};
+
+}
 #endif

include/CANDatabaseAnalysis.h

@@ -1,7 +1,9 @@
 #ifndef CANDATABASE_ANALYSIS_H
 #define CANDATABASE_ANALYSIS_H
 
-#include "CANFrame.h"
+#include "CANDatabase.h"
+#include <vector>
+#include "cpp_can_parser_export.h"
 
 namespace CppCAN {
 namespace analysis {
@@ -10,7 +12,7 @@ namespace analysis {
      * @param src The CANFrame instance to inspect
      * @return true if no overlapping is detected, false otherwise
      */
-    bool is_frame_layout_ok(const CANFrame& src);
+    CPP_CAN_PARSER_EXPORT bool is_frame_layout_ok(const CANFrame& src);
 
     /**
      * @brief Overload of is_frame_layout_ok() that outputs a diagnosis of the
@@ -19,12 +21,12 @@ namespace analysis {
      * @param diagnosis Filled with the names of all the overlapping signals
      * @return true if no overlapping is detected, false otherwise
      */
-    bool is_frame_layout_ok(const CANFrame& src, std::vector<std::string>& diagnosis);
+    CPP_CAN_PARSER_EXPORT bool is_frame_layout_ok(const CANFrame& src, std::vector<std::string>& diagnosis);
 
     /**
      * @brief Like is_frame_layout_ok() but throws a CANDatabaseException if the layout is ill-formed
      */
-    void assert_frame_layout(const CANFrame& src);
+    CPP_CAN_PARSER_EXPORT void assert_frame_layout(const CANFrame& src);
 }    
 } // namespace CppCAN