chore(velodyne): fix compiler and clang-tidy errors after rebase

Signed-off-by: Max SCHMELLER <max.schmeller@tier4.jp>

Author: mojomex

nebula_decoders/include/nebula_decoders/nebula_decoders_velodyne/decoders/velodyne_generic_decoder.hpp

@@ -1,41 +1,51 @@
+// Copyright 2024 TIER IV, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 #pragma once
 
 #include <cstddef>
 #include <cstdint>
 #include <ctime>
 
-namespace nebula
-{
-namespace drivers
-{
-namespace velodyne_packet
+namespace nebula::drivers::velodyne_packet
 {
 
 /**
  * Raw Velodyne packet constants and structures.
  */
-static const int RAW_SCAN_SIZE = 3;  // TODO: remove
-static const int SCANS_PER_BLOCK = 32;  // TODO: remove
-static const int CHANNELS_PER_BLOCK = 32;
+static const int g_raw_scan_size = 3;     // TODO(ike-kazu): remove
+static const int g_scans_per_block = 32;  // TODO(ike-kazu): remove
+static const int g_channels_per_block = 32;
 
-static const double ROTATION_RESOLUTION = 0.01;     // [deg]
-static const uint16_t ROTATION_MAX_UNITS = 360 * 100u;  // [deg/100]
+static const double g_rotation_resolution = 0.01;         // [deg]
+static const uint16_t g_rotation_max_units = 360 * 100u;  // [deg/100]
 
-static const size_t RETURN_MODE_INDEX = 1204;
+static const size_t g_return_mode_index = 1204;
 
 /** @todo make this work for both big and little-endian machines */
-static const uint16_t UPPER_BANK = 0xeeff;
-static const uint16_t LOWER_BANK = 0xddff;
+static const uint16_t g_upper_bank = 0xeeff;
+static const uint16_t g_lower_bank = 0xddff;
 
 /** Return Modes **/
-static const uint16_t RETURN_MODE_STRONGEST = 55;
-static const uint16_t RETURN_MODE_LAST = 56;
-static const uint16_t RETURN_MODE_DUAL = 57;
+static const uint16_t g_return_mode_strongest = 55;
+static const uint16_t g_return_mode_last = 56;
+static const uint16_t g_return_mode_dual = 57;
 
-const int BLOCKS_PER_PACKET = 12;
-const int PACKET_STATUS_SIZE = 4;
-const int SCANS_PER_PACKET = (SCANS_PER_BLOCK * BLOCKS_PER_PACKET);
-const int POINTS_PER_PACKET = (SCANS_PER_PACKET * RAW_SCAN_SIZE);
+const int g_blocks_per_packet = 12;
+const int g_packet_status_size = 4;
+const int g_scans_per_packet = (g_scans_per_block * g_blocks_per_packet);
+const int g_points_per_packet = (g_scans_per_packet * g_raw_scan_size);
 
 #pragma pack(push, 1)
 /** \brief Raw Velodyne data block.
@@ -45,16 +55,17 @@ const int POINTS_PER_PACKET = (SCANS_PER_PACKET * RAW_SCAN_SIZE);
  *
  *  use stdint.h types, so things work with both 64 and 32-bit machines
  */
-struct raw_units{
+struct raw_units
+{
   uint16_t distance;
   uint8_t reflectivity;
 };
 
 struct raw_block_t
 {
-  uint16_t flag;    ///< UPPER_BANK or LOWER_BANK
+  uint16_t flag;      ///< UPPER_BANK or LOWER_BANK
   uint16_t rotation;  ///< 0-35999, divide by 100 to get degrees
-  raw_units units[SCANS_PER_BLOCK];
+  raw_units units[g_scans_per_block];
 };
 
 /** \brief Raw Velodyne packet.
@@ -71,7 +82,7 @@ struct raw_block_t
  */
 struct raw_packet_t
 {
-  raw_block_t blocks[BLOCKS_PER_PACKET];
+  raw_block_t blocks[g_blocks_per_packet];
   uint32_t timestamp;
   uint16_t factory;
 };
@@ -89,6 +100,4 @@ enum RETURN_TYPE {
   DUAL_ONLY = 7
 };
 
-}  // namespace hesai_packet
-}  // namespace drivers
-}  // namespace nebula
+}  // namespace nebula::drivers::velodyne_packet

nebula_decoders/include/nebula_decoders/nebula_decoders_velodyne/decoders/velodyne_packet.hpp

@@ -32,7 +32,6 @@
 #include <cmath>
 #include <cstdint>
 #include <memory>
-#include <string>
 #include <tuple>
 #include <vector>
 
@@ -44,9 +43,13 @@ class VelodyneScanDecoder
 private:
   size_t processed_packets_{0};
   uint32_t prev_packet_first_azm_phased_{0};
-  bool has_scanned_{false};
+
+  static const size_t g_offset_first_azimuth = 2;
+  static const size_t g_offset_last_azimuth = 1102;
+  static const uint32_t g_degree_subdivisions = 100;
 
 protected:
+  bool has_scanned_{false};
   /// @brief Checks if the current packet completes the ongoing scan.
   /// TODO: this has been moved from velodyne_hw_interface.cpp and is a temporary solution until
   /// the Velodyne decoder uses the same structure as Hesai/Robosense
@@ -115,7 +118,7 @@ class VelodyneScanDecoder
 
   /// @brief Virtual function for getting the flag indicating whether one cycle is ready
   /// @return Readied
-  virtual bool hasScanned() = 0;
+  virtual bool has_scanned() = 0;
 
   /// @brief Virtual function for getting the constructed point cloud
   /// @return tuple of Point cloud and timestamp

nebula_decoders/include/nebula_decoders/nebula_decoders_velodyne/decoders/velodyne_scan_decoder.hpp

@@ -1,39 +1,60 @@
+// Copyright 2024 TIER IV, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 #pragma once
-#include "nebula_decoders/nebula_decoders_velodyne/decoders/velodyne_scan_decoder.hpp"
 
 #include <cstdint>
 
-namespace nebula
-{
-namespace drivers
+namespace nebula::drivers
 {
 class VelodyneSensor
 {
 public:
-  /// @brief each VLP lidars packat structure in user manual. If you know details, see commens in each <vlp_list>.hpp file.
-  /// To ignore an empty data blocks which is created by only VLS128 dual return mode case
-  virtual int getNumPaddingBlocks(bool /* dual_return */) { return 0; }
-
-  /// @brief each VLP lidar laser timing in user manual. If you know details, see commens in each <vlp_list>.hpp file.
-  /// calculate and stack the firing timing for each laser timeing used in getAzimuthCorrected to calculate the corrected azimuth
-  virtual bool fillAzimuthCache() { return false; }
+  VelodyneSensor() = default;
+  VelodyneSensor(const VelodyneSensor &) = default;
+  VelodyneSensor(VelodyneSensor &&) = default;
+  VelodyneSensor & operator=(const VelodyneSensor &) = default;
+  VelodyneSensor & operator=(VelodyneSensor &&) = default;
+  virtual ~VelodyneSensor() = default;
+
+  /// @brief each VLP lidars packat structure in user manual. If you know details, see commens in
+  /// each <vlp_list>.hpp file. To ignore an empty data blocks which is created by only VLS128 dual
+  /// return mode case
+  virtual int get_num_padding_blocks(bool /* dual_return */) { return 0; }
+
+  /// @brief each VLP lidar laser timing in user manual. If you know details, see commens in each
+  /// <vlp_list>.hpp file. calculate and stack the firing timing for each laser timeing used in
+  /// getAzimuthCorrected to calculate the corrected azimuth
+  virtual bool fill_azimuth_cache() { return false; }
 
   /// @brief VSL128User manual p. Packet structure
-  virtual uint getBank(uint bank, uint /* header */) { return bank; }
+  virtual uint32_t get_bank(uint32_t bank, uint32_t /* header */) { return bank; }
 
-  /// @brief each VLP calculating sample code and formula in user manual. If you know details, see commens in each <vlp_list>.hpp file.
-  /// calculate the corrected azimuth from each firing timing.
-  virtual uint16_t getAzimuthCorrected(
+  /// @brief each VLP calculating sample code and formula in user manual. If you know details, see
+  /// commens in each <vlp_list>.hpp file. calculate the corrected azimuth from each firing timing.
+  virtual uint16_t get_azimuth_corrected(
     uint16_t azimuth, float azimuth_diff, int firing_sequence, int firing_order) = 0;
 
   /// @brief each VLP calculating sample code and formula in user manual. Check packet structure.
   /// Get a correct firing order
-  virtual int getFiringOrder(int /* channels_per_block */, int /* scans_per_firing */) { return 0; }
+  virtual int get_firing_order(int /* channels_per_block */, int /* scans_per_firing */)
+  {
+    return 0;
+  }
 
   /// @brief each VLP calculating sample code and formula in user manual. Check packet structure.
   /// Get a correct channel number
-  virtual int getChannelNumber(int /* unit_idx */) { return 0; }
-
+  virtual int get_channel_number(int /* unit_idx */) { return 0; }
 };
-}  // namespace drivers
-}  // namespace nebula
+}  // namespace nebula::drivers

nebula_decoders/include/nebula_decoders/nebula_decoders_velodyne/decoders/velodyne_sensor.hpp

@@ -1,9 +1,24 @@
+// Copyright 2024 TIER IV, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 #pragma once
+
 #include "nebula_decoders/nebula_decoders_velodyne/decoders/velodyne_sensor.hpp"
 
-namespace nebula
-{
-namespace drivers
+#include <cmath>
+
+namespace nebula::drivers
 {
 
 class VLP16 : public VelodyneSensor
@@ -15,33 +30,31 @@ class VLP16 : public VelodyneSensor
   /// @param firing_sequence Firing sequence
   /// @param firing_order Firing order
   /// @return Corrected azimuth
-  uint16_t getAzimuthCorrected(
-    uint16_t azimuth, float azimuth_diff, int firing_sequence, int firing_order)
+  uint16_t get_azimuth_corrected(
+    uint16_t azimuth, float azimuth_diff, int firing_sequence, int firing_order) override
   {
     float azimuth_corrected =
       azimuth + (azimuth_diff *
-                 ((firing_order * VLP16_DSR_TOFFSET) + (firing_sequence * VLP16_FIRING_TOFFSET)) /
-                 VLP16_BLOCK_DURATION);
+                 ((firing_order * vlp16_dsr_toffset) + (firing_sequence * vlp16_firing_toffset)) /
+                 vlp16_block_duration);
 
     return static_cast<uint16_t>(round(azimuth_corrected)) % 36000;
   }
 
   // Not succeed nebula_test on only VLP32 so add this function
   // Choose the correct azimuth from the 2 azimuths
-  uint16_t getTrueRotation(uint16_t azimuth_corrected, uint16_t /* current_block_rotation */)
+  static uint16_t get_true_rotation(
+    uint16_t azimuth_corrected, uint16_t /* current_block_rotation */)
   {
     return azimuth_corrected;
   }
 
-  int getFiringOrder(int channels, int scans_per_firing)
+  int get_firing_order(int channels, int scans_per_firing) override
   {
     return channels / scans_per_firing;
   }
 
-  int getChannelNumber(int unit_idx)
-  {
-    return unit_idx % channels_per_firing_sequence;
-  }
+  int get_channel_number(int unit_idx) override { return unit_idx % channels_per_firing_sequence; }
 
   constexpr static int num_maintenance_periods = 0;
 
@@ -60,11 +73,10 @@ class VLP16 : public VelodyneSensor
   constexpr static double offset_packet_time = 0;
 
   /** Special Defines for VLP16 support **/
-  constexpr static const int VLP16_FIRINGS_PER_BLOCK = 2;
-  constexpr static const int VLP16_SCANS_PER_FIRING = 16;
-  constexpr static const float VLP16_BLOCK_DURATION = 110.592f;  // [µs]
-  constexpr static const float VLP16_DSR_TOFFSET = 2.304f;       // [µs]
-  constexpr static const float VLP16_FIRING_TOFFSET = 55.296f;   // [µs]
+  constexpr static const int vlp16_firings_per_block = 2;
+  constexpr static const int vlp16_scans_per_firing = 16;
+  constexpr static const float vlp16_block_duration = 110.592f;  // [µs]
+  constexpr static const float vlp16_dsr_toffset = 2.304f;       // [µs]
+  constexpr static const float vlp16_firing_toffset = 55.296f;   // [µs]
 };
-}  // namespace drivers
-}  // namespace nebula
+}  // namespace nebula::drivers

nebula_decoders/include/nebula_decoders/nebula_decoders_velodyne/decoders/vlp_16.hpp

@@ -1,20 +1,34 @@
+// Copyright 2024 TIER IV, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 #pragma once
 
 #include "nebula_decoders/nebula_decoders_velodyne/decoders/velodyne_sensor.hpp"
 
-namespace nebula
-{
-namespace drivers
+#include <cmath>
+
+namespace nebula::drivers
 {
 class VLP32 : public VelodyneSensor
 {
 public:
-// calculate and stack the firing timing for each laser timeing
-/// @brief laser timing for VLP32 from VLP32 User manual in p.61
-  bool fillAzimuthCache()
+  // calculate and stack the firing timing for each laser timeing
+  /// @brief laser timing for VLP32 from VLP32 User manual in p.61
+  bool fill_azimuth_cache() override
   {
     for (uint8_t i = 0; i < 16; i++) {
-      laser_azimuth_cache_[i] = (VLP32_CHANNEL_DURATION / VLP32_SEQ_DURATION) * (i + i / 2);
+      laser_azimuth_cache_[i] = (vlp32_channel_duration / vlp32_seq_duration) * (i + i / 2);
     }
     return true;
   }
@@ -24,8 +38,8 @@ class VLP32 : public VelodyneSensor
   /// @param azimuth_diff Azimuth difference between a current azimuth and a next azimuth
   /// @param firing_order Firing order
   /// @return Corrected azimuth
-  uint16_t getAzimuthCorrected(
-    uint16_t azimuth, float azimuth_diff, int /* firing_sequence */, int firing_order)
+  uint16_t get_azimuth_corrected(
+    uint16_t azimuth, float azimuth_diff, int /* firing_sequence */, int firing_order) override
   {
     float azimuth_corrected = azimuth + (azimuth_diff * laser_azimuth_cache_[firing_order]);
 
@@ -34,20 +48,17 @@ class VLP32 : public VelodyneSensor
 
   // Not succeed nebula_test on only VLP32 so add this function
   // Choose the correct azimuth from the 2 azimuths
-  uint16_t getTrueRotation(uint16_t /* azimuth_corrected */, uint16_t current_block_rotation)
+  uint16_t get_true_rotation(uint16_t /* azimuth_corrected */, uint16_t current_block_rotation)
   {
     return current_block_rotation;
   }
 
-  int getFiringOrder(int channels, int scans_per_firing)
+  int get_firing_order(int channels, int scans_per_firing) override
   {
     return channels / scans_per_firing;
   }
-  
-  int getChannelNumber(int unit_idx)
-  {
-    return unit_idx % channels_per_firing_sequence;
-  }
+
+  int get_channel_number(int unit_idx) override { return unit_idx % channels_per_firing_sequence; }
 
   constexpr static int num_maintenance_periods = 0;
 
@@ -66,14 +77,12 @@ class VLP32 : public VelodyneSensor
   constexpr static double offset_packet_time = 0;
 
   /** Special Definitions for VLS32 support **/
-  constexpr static const float VLP32_CHANNEL_DURATION =
+  constexpr static const float vlp32_channel_duration =
     2.304f;  // [µs] Channels corresponds to one laser firing
-  constexpr static const float VLP32_SEQ_DURATION =
+  constexpr static const float vlp32_seq_duration =
     55.296f;  // [µs] Sequence is a set of laser firings including recharging
 
-
 private:
   float laser_azimuth_cache_[16];
 };
-}  // namespace drivers
-}  // namespace nebula
+}  // namespace nebula::drivers

nebula_decoders/include/nebula_decoders/nebula_decoders_velodyne/decoders/vlp_32.hpp

@@ -1,28 +1,46 @@
+// Copyright 2024 TIER IV, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 #pragma once
+
 #include "nebula_decoders/nebula_decoders_velodyne/decoders/velodyne_sensor.hpp"
 
-namespace nebula
-{
-namespace drivers
+#include <rclcpp/logger.hpp>
+#include <rclcpp/logging.hpp>
+
+#include <cmath>
+
+namespace nebula::drivers
 {
 
 class VLS128 : public VelodyneSensor
 {
 public:
   // To ignore an empty data blocks in VLS128 case
   /// @brief VLS128 Dual return mode data structure in VLS128 User manual p.57
-  int getNumPaddingBlocks(bool dual_return)
+  int get_num_padding_blocks(bool dual_return) override
   {
     if (dual_return) return 4;
     return 0;
   }
 
-// calculate and stack the firing timing for each laser timeing
-/// @brief laser timing for VLS128 from VLS128 User manual in p.61
-  bool fillAzimuthCache()
+  // calculate and stack the firing timing for each laser timeing
+  /// @brief laser timing for VLS128 from VLS128 User manual in p.61
+  bool fill_azimuth_cache() override
   {
     for (uint8_t i = 0; i < 16; i++) {
-      laser_azimuth_cache_[i] = (VLS128_CHANNEL_DURATION / VLS128_SEQ_DURATION) * (i + i / 8);
+      laser_azimuth_cache_[i] = (vls128_channel_duration / vls128_seq_duration) * (i + i / 8);
     }
     return true;
   }
@@ -32,8 +50,8 @@ class VLS128 : public VelodyneSensor
   /// @param azimuth_diff Azimuth difference
   /// @param firing_order Firing order
   /// @return Corrected azimuth
-  uint16_t getAzimuthCorrected(
-    uint16_t azimuth, float azimuth_diff, int /* firing_sequence */, int firing_order)
+  uint16_t get_azimuth_corrected(
+    uint16_t azimuth, float azimuth_diff, int /* firing_sequence */, int firing_order) override
   {
     float azimuth_corrected = azimuth + (azimuth_diff * laser_azimuth_cache_[firing_order]);
 
@@ -42,24 +60,26 @@ class VLS128 : public VelodyneSensor
 
   // Not succeed nebula_test on only VLP32 so add this function
   // Choose the correct azimuth from the 2 azimuths
-  uint16_t getTrueRotation(uint16_t azimuth_corrected, uint16_t /* current_block_rotation */)
+  static uint16_t get_true_rotation(
+    uint16_t azimuth_corrected, uint16_t /* current_block_rotation */)
   {
     return azimuth_corrected;
   }
 
-  uint getBank(uint bank, uint header) {
+  uint32_t get_bank(uint32_t bank, uint32_t header) override
+  {
     // Used to detect which bank of 32 lasers is in this block.
     switch (header) {
-      case BANK_1:
+      case bank_1:
         bank = 0;
         break;
-      case BANK_2:
+      case bank_2:
         bank = 32;
         break;
-      case BANK_3:
+      case bank_3:
         bank = 64;
         break;
-      case BANK_4:
+      case bank_4:
         bank = 96;
         break;
       default:
@@ -71,15 +91,12 @@ class VLS128 : public VelodyneSensor
     return bank;
   }
 
-  int getFiringOrder(int channels, int scans_per_firing)
+  int get_firing_order(int channels, int scans_per_firing) override
   {
     return channels / scans_per_firing;
   }
 
-  int getChannelNumber(int unit_idx)
-  {
-    return unit_idx % channels_per_firing_sequence;
-  }
+  int get_channel_number(int unit_idx) override { return unit_idx % channels_per_firing_sequence; }
 
   constexpr static int num_maintenance_periods = 1;
 
@@ -98,19 +115,20 @@ class VLS128 : public VelodyneSensor
   constexpr static double offset_packet_time = 8.7 * 1e-6;
 
   /** Special Definitions for VLS128 support **/
-  constexpr static const float VLP128_DISTANCE_RESOLUTION = 0.004f;  // [m]
+  constexpr static const float vls128_distance_resolution = 0.004f;  // [m]
 
-  constexpr static const float VLS128_CHANNEL_DURATION = 2.665f;  // [µs] Channels corresponds to one laser firing
+  constexpr static const float vls128_channel_duration =
+    2.665f;  // [µs] Channels corresponds to one laser firing
 
-  constexpr static const float VLS128_SEQ_DURATION = 53.3f;  // [µs] Sequence is a set of laser firings including recharging
+  constexpr static const float vls128_seq_duration =
+    53.3f;  // [µs] Sequence is a set of laser firings including recharging
   // These are used to detect which bank of 32 lasers is in this block
-  constexpr static const uint16_t BANK_1 = 0xeeff;
-  constexpr static const uint16_t BANK_2 = 0xddff;
-  constexpr static const uint16_t BANK_3 = 0xccff;
-  constexpr static const uint16_t BANK_4 = 0xbbff;
+  constexpr static const uint16_t bank_1 = 0xeeff;
+  constexpr static const uint16_t bank_2 = 0xddff;
+  constexpr static const uint16_t bank_3 = 0xccff;
+  constexpr static const uint16_t bank_4 = 0xbbff;
 
 private:
-  float laser_azimuth_cache_[16];
+  float laser_azimuth_cache_[16]{};
 };
-}  // namespace drivers
-}  // namespace nebula
+}  // namespace nebula::drivers

nebula_decoders/include/nebula_decoders/nebula_decoders_velodyne/decoders/vls_128.hpp

@@ -19,25 +19,21 @@
 #include "nebula_common/nebula_status.hpp"
 #include "nebula_common/point_types.hpp"
 #include "nebula_common/velodyne/velodyne_common.hpp"
-#include "nebula_decoders/nebula_decoders_common/nebula_driver_base.hpp"
 #include "nebula_decoders/nebula_decoders_velodyne/decoders/velodyne_scan_decoder.hpp"
 
 #include <velodyne_msgs/msg/velodyne_packet.hpp>
 #include <velodyne_msgs/msg/velodyne_scan.hpp>
 
 #include <pcl_conversions/pcl_conversions.h>
 
-#include <iostream>
 #include <memory>
-#include <stdexcept>
-#include <string>
 #include <tuple>
 #include <vector>
 
 namespace nebula::drivers
 {
 /// @brief Velodyne driver
-class VelodyneDriver : NebulaDriverBase
+class VelodyneDriver
 {
 private:
   /// @brief Current driver status
@@ -59,7 +55,7 @@ class VelodyneDriver : NebulaDriverBase
   /// @param calibration_configuration
   /// @return Resulting status
   Status set_calibration_configuration(
-    const CalibrationConfigurationBase & calibration_configuration) override;
+    const CalibrationConfigurationBase & calibration_configuration);
 
   /// @brief Get current status of this driver
   /// @return Current status

nebula_decoders/include/nebula_decoders/nebula_decoders_velodyne/velodyne_driver.hpp

@@ -2,6 +2,7 @@
 
 #include "nebula_decoders/nebula_decoders_velodyne/velodyne_driver.hpp"
 
+#include "memory"
 #include "nebula_decoders/nebula_decoders_velodyne/decoders/velodyne_generic_decoder.hpp"
 #include "nebula_decoders/nebula_decoders_velodyne/decoders/vlp_16.hpp"
 #include "nebula_decoders/nebula_decoders_velodyne/decoders/vlp_32.hpp"
@@ -21,18 +22,18 @@ VelodyneDriver::VelodyneDriver(
       driver_status_ = nebula::Status::INVALID_SENSOR_MODEL;
       break;
     case SensorModel::VELODYNE_VLS128:
-      scan_decoder_.reset(
-        new VelodyneDecoder<VLS128>(sensor_configuration, calibration_configuration));
+      scan_decoder_ =
+        std::make_shared<VelodyneDecoder<VLS128>>(sensor_configuration, calibration_configuration);
       break;
     case SensorModel::VELODYNE_VLP32:
     case SensorModel::VELODYNE_HDL64:
     case SensorModel::VELODYNE_HDL32:
-      scan_decoder_.reset(
-        new VelodyneDecoder<VLP32>(sensor_configuration, calibration_configuration));
+      scan_decoder_ =
+        std::make_shared<VelodyneDecoder<VLP32>>(sensor_configuration, calibration_configuration);
       break;
     case SensorModel::VELODYNE_VLP16:
-      scan_decoder_.reset(
-        new VelodyneDecoder<VLP16>(sensor_configuration, calibration_configuration));
+      scan_decoder_ =
+        std::make_shared<VelodyneDecoder<VLP16>>(sensor_configuration, calibration_configuration);
       break;
     default:
       driver_status_ = nebula::Status::INVALID_SENSOR_MODEL;