Removed the shared_ptr because they were actually useless

Author: Avi SZYCHTER

include/CANDatabase.h

@@ -40,8 +40,16 @@ class CANDatabase {
   static CANDatabase fromString(const std::string& src_string);
 
 public:
-  using container_type = std::map<unsigned long long, std::shared_ptr<CANFrame>>;
-  using str_container_type = std::map<std::string, std::shared_ptr<CANFrame>>;
+  struct IDKey {
+    std::string str_key;
+    unsigned long long int_key;
+  };
+
+  struct IntIDKeyCompare {
+    bool operator()(const IDKey& k1, const IDKey& k2) const;
+  };
+
+  using container_type = std::map<IDKey, CANFrame, IntIDKeyCompare>;
 
   using iterator = container_type::iterator;
   using const_iterator = container_type::const_iterator;
@@ -64,46 +72,63 @@ class CANDatabase {
    * Creates a copy of the database: the individual frames are deep copied so there is no
    * shared memory betwwen the two databases.
    */
-  CANDatabase(const CANDatabase&);
+  CANDatabase(const CANDatabase&) = default;
 
   /**
    * @brief Makes a copy of the given database
-   * Note: the source database is passed-by-value for RVO
-   *       (see https://stackoverflow.com/a/3279550/8147455 for more info)
    */
-  CANDatabase& operator=(const CANDatabase&);
+  CANDatabase& operator=(const CANDatabase&) = default;
 
   /**
    * @brief Moves a CANDatabase object. The CANFrame objects are NOT deep copied.
    */
-  CANDatabase(CANDatabase&&);
+  CANDatabase(CANDatabase&&) = default;
 
   /**
    * @see CANDatabase(const CANDatabase&&)
    */
-  CANDatabase& operator=(CANDatabase&&);
+  CANDatabase& operator=(CANDatabase&&) = default;
 
 public:
   /**
    * @brief Get the frame with the given frame name
    */
-  std::shared_ptr<CANFrame> at(unsigned long long frame_name) const;
+  const CANFrame& at(unsigned long long frame_id) const;
+  
+  /**
+   * @brief Get the frame with the given frame name
+   */
+  CANFrame& at(unsigned long long frame_id);
+  
+  /**
+   * @brief Get the frame with the given frame id
+   */
+  const CANFrame& at(const std::string& frame_name) const;
 
   /**
    * @brief Get the frame with the given frame id
    */
-  std::shared_ptr<CANFrame> at(const std::string& frame_name) const;
+  CANFrame& at(const std::string& frame_name);
 
   /**
    * @brief Get the frame with the given frame id
-   * @see getFrame
    */
-  std::shared_ptr<CANFrame> operator[](unsigned long long frame_idx) const;
+  const CANFrame& operator[](unsigned long long frame_idx) const;
+  
+  /**
+   * @brief Get the frame with the given frame id
+   */
+   CANFrame& operator[](unsigned long long frame_idx);
 
   /**
    * @brief Get the frame with the given frame name
    */
-  std::shared_ptr<CANFrame> operator[](const std::string& frame_name) const;
+  const CANFrame& operator[](const std::string& frame_name) const;
+  
+  /**
+   * @brief Get the frame with the given frame name
+   */
+  CANFrame& operator[](const std::string& frame_name);
 
   /**
    * @return true if the CANDatabase contains a frame with the given frame id
@@ -152,14 +177,16 @@ class CANDatabase {
 
   void clear();
 
-  void addFrame(std::shared_ptr<CANFrame> frame);
+  void addFrame(const CANFrame& frame);
   void removeFrame(unsigned int idx);
   void removeFrame(const std::string& name);
 
 private:
   std::string filename_;
-  str_container_type strIndex_; // Index by frame name
-  container_type intIndex_; // Index by CAN ID
+  container_type map_; // Index by CAN ID
+
+  std::map<unsigned long long, IDKey> intKeyIndex_;
+  std::map<std::string, IDKey> strKeyIndex_;
 };
 
 #endif

include/CANFrame.h

@@ -13,8 +13,17 @@
  */
 class CANFrame {
 public:
-  using container_type = std::map<unsigned int, std::shared_ptr<CANSignal>>;
-  using str_container_type = std::map<std::string, std::shared_ptr<CANSignal>>;
+  struct IDKey {
+    std::string str_key;
+    unsigned long long int_key;
+  };
+
+  struct IntIDKeyCompare {
+    bool operator()(const IDKey& k1, const IDKey& k2) const;
+  };
+
+
+  using container_type = std::map<IDKey, CANSignal, IntIDKeyCompare>;
   using iterator = container_type::iterator;
   using const_iterator = container_type::const_iterator;
   using reverse_iterator = container_type::reverse_iterator;
@@ -31,12 +40,13 @@ class CANFrame {
    * @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 std::string& name, unsigned long long can_id, unsigned int dlc, 
+           unsigned int period = 0, const std::string& comment = "");
 
-  CANFrame(const CANFrame&);
-  CANFrame& operator=(CANFrame);
-  CANFrame(CANFrame&&);
-  CANFrame& operator=(CANFrame&&);
+  CANFrame(const CANFrame&) = default;
+  CANFrame& operator=(const CANFrame&) = default;
+  CANFrame(CANFrame&&) = default;
+  CANFrame& operator=(CANFrame&&) = default;
 
 public:
   /**
@@ -77,41 +87,36 @@ class CANFrame {
 
 public:
   /**
-   * @brief Fetches the signal with the given start bit.
+   * @brief Fetches the signal with the given name.
    * @see at
    */
-  std::shared_ptr<CANSignal> operator[](unsigned int start_bit) const;
-
+  const CANSignal& operator[](const std::string& name) const;
+  
   /**
    * @brief Fetches the signal with the given name.
    * @see at
    */
-  std::shared_ptr<CANSignal> operator[](const std::string& name) const;
+  CANSignal& operator[](const std::string& name);
 
   /**
    * @brief Fetches the signal with the given name.
    */
-  std::shared_ptr<CANSignal> at(const std::string& name) const;
-
+  const CANSignal& at(const std::string& name) const;
+  
   /**
-   * @brief Fetches the signal with the given start bit.
+   * @brief Fetches the signal with the given name.
    */
-  std::shared_ptr<CANSignal> at(unsigned int start_bit) const;
+  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;
 
-  /**
-   * @return true if a signal with the given start bit is already registered with the current frame.
-   */
-  bool contains(unsigned int start_bit) const;
-
   /**
    * @brief Registers the given signal with the frame.
    */
-  void addSignal(std::shared_ptr<CANSignal> signal);
+  void addSignal(const CANSignal& signal);
 
   /**
    * @brief Removes the signal with the given start bit 
@@ -151,9 +156,11 @@ class CANFrame {
   unsigned long long can_id_;
   unsigned int dlc_;
   unsigned int period_;
-  std::map<unsigned int, std::shared_ptr<CANSignal>> intIndex_; // Index by start bit
-  std::map<std::string, std::shared_ptr<CANSignal>> strIndex_; // Index by name
   std::string comment_;
+  
+  container_type map_;
+  std::map<unsigned, IDKey> intKeyIdx_; // Index by start bit
+  std::map<std::string, IDKey> strKeyIdx_; // Index by name
 };
 
 #endif

src/analysis/CANFrameAnalysis.cpp

@@ -75,7 +75,7 @@ std::vector<SignalLayoutEntry> compute_layout(const CANFrame& src) {
     std::vector<SignalLayoutEntry> result;
 
     for(const auto& signal: src) {
-        const CANSignal& sig = *signal.second; 
+        const CANSignal& sig = signal.second; 
         int lr_start_bit, lr_end_bit;
 
         if(sig.endianness() == CANSignal::BigEndian) {