clang-tidy: add more modernize-* checks

.clang-tidy

@@ -1,19 +1,20 @@
 ---
 Checks: "-*, \
-  modernize-deprecated-headers, \
-  modernize-make-shared, \
-  modernize-make-unique, \
-  modernize-redundant-void-arg, \
-  modernize-use-auto, \
-  modernize-use-equals-default, \
-  modernize-use-nullptr, \
-  modernize-use-using, \
+  modernize-*, \
+  -modernize-avoid-c-arrays, \
+  -modernize-pass-by-value, \
+  -modernize-use-trailing-return-type, \
   performance-faster-string-find, \
   performance-for-range-copy, \
   performance-inefficient-string-concatenation, \
   performance-trivially-destructible, \
   readability-delete-null-pointer, \
   readability-duplicate-include, \
   readability-string-compare"
+
+CheckOptions:
+- key: modernize-use-override.IgnoreDestructors
+  value: true
+
 FormatStyle: file
 HeaderFilterRegex: 'include/.*.hh'

include/RMGEventAction.hh

@@ -23,7 +23,6 @@
 
 class RMGRunAction;
 class G4GenericMessenger;
-class RMGVOutputManager;
 class RMGEventAction : public G4UserEventAction {
 
   public:

include/RMGHardware.hh

@@ -58,7 +58,7 @@ class RMGHardware : public G4VUserDetectorConstruction {
 
     void RegisterDetector(DetectorType type, const std::string& pv_name, int uid, int copy_nr = 0);
     inline const auto& GetDetectorMetadataMap() { return fDetectorMetadata; }
-    inline const auto& GetDetectorMetadata(std::pair<std::string, int> det) {
+    inline const auto& GetDetectorMetadata(const std::pair<std::string, int>& det) {
       return fDetectorMetadata.at(det);
     }
     inline const auto& GetActiveDetectorList() { return fActiveDetectors; }

include/RMGHardwareMessenger.hh

@@ -26,7 +26,7 @@ class RMGHardwareMessenger : public G4UImessenger {
     RMGHardwareMessenger(RMGHardware* hw);
     ~RMGHardwareMessenger();
 
-    void SetNewValue(G4UIcommand* command, G4String newValues);
+    void SetNewValue(G4UIcommand* command, G4String newValues) override;
 
   private:
 

include/RMGMasterGenerator.hh

@@ -55,7 +55,7 @@ class RMGMasterGenerator : public G4VUserPrimaryGeneratorAction {
 
     inline RMGVGenerator* GetGenerator() { return fGeneratorObj.get(); }
     inline RMGVVertexGenerator* GetVertexGenerator() { return fVertexGeneratorObj.get(); }
-    inline Confinement GetConfinement() const { return fConfinement; }
+    [[nodiscard]] inline Confinement GetConfinement() const { return fConfinement; }
 
     void SetConfinement(Confinement code);
     void SetConfinementString(std::string code);
@@ -65,10 +65,10 @@ class RMGMasterGenerator : public G4VUserPrimaryGeneratorAction {
 
   private:
 
-    Confinement fConfinement;
+    Confinement fConfinement{RMGMasterGenerator::Confinement::kUnConfined};
     std::unique_ptr<RMGVVertexGenerator> fVertexGeneratorObj;
 
-    Generator fGenerator;
+    Generator fGenerator{RMGMasterGenerator::Generator::kUndefined};
     std::unique_ptr<RMGVGenerator> fGeneratorObj;
 
     std::unique_ptr<G4GenericMessenger> fMessenger;

include/RMGPhysics.hh

@@ -23,7 +23,6 @@
 #include "G4VModularPhysicsList.hh"
 #include "globals.hh"
 
-class RMGProcessesMessenger;
 class RMGPhysics : public G4VModularPhysicsList {
 
   public:

include/RMGRun.hh

@@ -26,7 +26,7 @@ class RMGRun : public G4Run {
 
     using TimePoint = std::chrono::time_point<std::chrono::system_clock>;
 
-    inline const TimePoint& GetStartTime() const { return fStartTime; }
+    [[nodiscard]] inline const TimePoint& GetStartTime() const { return fStartTime; }
     inline void SetStartTime(TimePoint t) { fStartTime = t; }
 
   private:

include/RMGTrackingAction.hh

@@ -31,8 +31,8 @@ class RMGTrackingAction : public G4UserTrackingAction {
     RMGTrackingAction(RMGTrackingAction&&) = delete;
     RMGTrackingAction& operator=(RMGTrackingAction&&) = delete;
 
-    virtual void PreUserTrackingAction(const G4Track*) override;
-    virtual void PostUserTrackingAction(const G4Track*) override;
+    void PreUserTrackingAction(const G4Track*) override;
+    void PostUserTrackingAction(const G4Track*) override;
     inline G4TrackingManager* GetTrackingManager() {
       return G4UserTrackingAction::fpTrackingManager;
     };

include/RMGVVertexGenerator.hh

@@ -55,7 +55,7 @@ class RMGVVertexGenerator {
     inline int GetMaxAttempts() { return fMaxAttempts; }
 
 #if RMG_HAS_BXDECAY0
-    inline void ShootVertex(G4ThreeVector& v) { GenerateVertex(v); }
+    inline void ShootVertex(G4ThreeVector& v) override { GenerateVertex(v); }
 #endif
 
   protected:

include/RMGVertexConfinement.hh

@@ -98,19 +98,19 @@ class RMGVertexConfinement : public RMGVVertexGenerator {
         SampleableObjectCollection() = default;
         inline ~SampleableObjectCollection() { data.clear(); }
 
-        const SampleableObject& SurfaceWeightedRand() const;
-        const SampleableObject& VolumeWeightedRand() const;
-        bool IsInside(const G4ThreeVector& point) const;
+        [[nodiscard]] const SampleableObject& SurfaceWeightedRand() const;
+        [[nodiscard]] const SampleableObject& VolumeWeightedRand() const;
+        [[nodiscard]] bool IsInside(const G4ThreeVector& point) const;
 
         // emulate std::vector
-        size_t size() const { return data.size(); }
+        [[nodiscard]] size_t size() const { return data.size(); }
         SampleableObject& at(size_t i) { return data.at(i); }
         void emplace_back(G4VPhysicalVolume* v, const G4RotationMatrix& r, const G4ThreeVector& t,
             G4VSolid* s);
         inline void push_back(const SampleableObject& obj) {
           this->emplace_back(obj.physical_volume, obj.rotation, obj.translation, obj.sampling_solid);
         }
-        inline bool empty() const { return data.empty(); }
+        [[nodiscard]] inline bool empty() const { return data.empty(); }
         inline SampleableObject& back() { return data.back(); }
         inline void clear() { data.clear(); }
         inline void insert(SampleableObjectCollection& other) {

include/RMGVertexFromFile.hh

@@ -24,7 +24,6 @@
 #include "G4GenericMessenger.hh"
 #include "G4ThreeVector.hh"
 
-class G4Event;
 class G4VAnalysisReader;
 class RMGVertexFromFile : public RMGVVertexGenerator {
 

src/RMGGeneratorUtil.cc

@@ -45,7 +45,7 @@ G4ThreeVector RMGGeneratorUtil::rand(const G4VSolid* vol, bool on_surface) {
     return RMGGeneratorUtil::rand(dynamic_cast<const G4Tubs*>(vol), on_surface);
   else {
     RMGLog::OutDev(RMGLog::fatal, "'", entity, "' is not supported (implement me)");
-    return G4ThreeVector();
+    return {};
   }
 }
 
@@ -78,10 +78,9 @@ G4ThreeVector RMGGeneratorUtil::rand(const G4Box* box, bool on_surface) {
       y = dy * (2 * _g4rand() - 1);
       z = dz * (2 * _g4rand() - 1);
     }
-    return G4ThreeVector(x, y, z);
+    return {x, y, z};
   } else {
-    return G4ThreeVector(dx * (2 * _g4rand() - 1), dy * (2 * _g4rand() - 1),
-        dz * (2 * _g4rand() - 1));
+    return {dx * (2 * _g4rand() - 1), dy * (2 * _g4rand() - 1), dz * (2 * _g4rand() - 1)};
   }
 }
 

src/RMGLog.cc

@@ -56,11 +56,11 @@ RMGLog::RMGLog() {
 void RMGLog::StartupInfo() {
 
   std::string message = "";
-  message += "  _ __ ___ _ __ ___   __ _  __ _  ___ \n";
-  message += " | '__/ _ \\ '_ ` _ \\ / _` |/ _` |/ _ \\\n";
-  message += " | | |  __/ | | | | | (_| | (_| |  __/\n";
-  message += " |_|  \\___|_| |_| |_|\\__,_|\\__, |\\___| v" + RMGLog::fVersion + "\n";
-  message += "                           |___/      \n";
+  message += R"(  _ __ ___ _ __ ___   __ _  __ _  ___ )" "\n";
+  message += R"( | '__/ _ \ '_ ` _ \ / _` |/ _` |/ _ \)" "\n";
+  message += R"( | | |  __/ | | | | | (_| | (_| |  __/)" "\n";
+  message += R"( |_|  \___|_| |_| |_|\__,_|\__, |\___| v)" + RMGLog::fVersion + "\n";
+  message += R"(                           |___/      )" "\n";
 
   // write message to screen
   if (RMGLog::fMinimumLogLevel <= RMGLog::summary) G4cout << message << G4endl;

src/RMGMasterGenerator.cc

@@ -34,9 +34,7 @@
 
 #include "RMGTools.hh"
 
-RMGMasterGenerator::RMGMasterGenerator()
-    : fConfinement(RMGMasterGenerator::Confinement::kUnConfined), fVertexGeneratorObj(nullptr),
-      fGenerator(RMGMasterGenerator::Generator::kUndefined), fGeneratorObj(nullptr) {
+RMGMasterGenerator::RMGMasterGenerator() : fVertexGeneratorObj(nullptr), fGeneratorObj(nullptr) {
 
   this->DefineCommands();
 }

src/remage.cc

@@ -23,20 +23,18 @@
 
 #include "magic_enum/magic_enum.hpp"
 
-namespace CLI {
-  namespace detail {
-    bool lexical_cast(std::string input, RMGLog::LogLevel& output) {
-      try {
-        output = static_cast<RMGLog::LogLevel>(std::stoll(input));
-        return true;
-      } catch (...) {
-        auto r = magic_enum::enum_cast<RMGLog::LogLevel>(input);
-        if (r.has_value()) output = r.value();
-        return r.has_value();
-      }
+namespace CLI::detail {
+  bool lexical_cast(std::string input, RMGLog::LogLevel& output) {
+    try {
+      output = static_cast<RMGLog::LogLevel>(std::stoll(input));
+      return true;
+    } catch (...) {
+      auto r = magic_enum::enum_cast<RMGLog::LogLevel>(input);
+      if (r.has_value()) output = r.value();
+      return r.has_value();
     }
-  } // namespace detail
-} // namespace CLI
+  }
+} // namespace CLI::detail
 
 #include "CLI11/CLI11.hpp"