Clang tidy everything else (#1826)

Author: tvami

Conditions/include/Conditions/GeneralCSVLoader.h

@@ -22,7 +22,7 @@ class GeneralCSVLoader {
   virtual ~GeneralCSVLoader() {}
 
   /** Get the column names */
-  std::vector<std::string> columnNames() const { return colNames_; }
+  std::vector<std::string> columnNames() const { return col_names_; }
 
   /** Advance to next row if possible */
   bool nextRow();
@@ -45,11 +45,11 @@ class GeneralCSVLoader {
   /**
    * The column names
    */
-  std::vector<std::string> colNames_;
+  std::vector<std::string> col_names_;
   /**
    * The row data
    */
-  std::vector<std::string> rowData_;
+  std::vector<std::string> row_data_;
 };
 
 /** @brief Specialization of the GeneralCSVLoader for loading from a string
@@ -77,7 +77,7 @@ class StringCSVLoader : public GeneralCSVLoader {
   /**
    * The current start and end pointers
    */
-  std::string::size_type rowBegin_, rowEnd_;
+  std::string::size_type row_begin_, row_end_;
 };
 
 /** @brief Specialization of the GeneralCSVLoader for loading from a file/stream
@@ -115,7 +115,7 @@ class StreamCSVLoader : public GeneralCSVLoader {
   /**
    * Own stream?
    */
-  bool ownStream_;
+  bool own_stream_;
   /**
    * Line buffer
    */

Conditions/include/Conditions/SimpleCSVTableProvider.h

@@ -70,10 +70,10 @@ class SimpleCSVTableProvider : public framework::ConditionsObjectProvider {
   getCondition(const ldmx::EventHeader& context);
 
  private:
-  enum { OBJ_unknown, OBJ_int, OBJ_double } objectType_;
+  enum { OBJ_unknown, OBJ_int, OBJ_double } object_type_;
   std::vector<std::string> columns_;
-  std::string entriesURL_;
-  std::string conditions_baseURL_;
+  std::string entries_url_;
+  std::string conditions_base_url_;
 
   void entriesFromPython(std::vector<framework::config::Parameters>&);
   void entriesFromCSV();

Conditions/include/Conditions/SimpleTableCondition.h

@@ -26,29 +26,29 @@ class BaseTableCondition : public framework::ConditionsObject {
                      const std::vector<std::string>& columns)
       : framework::ConditionsObject{name},
         columns_{columns},
-        idMask_{0xFFFFFFFFu} {
-    columnCount_ = (unsigned int)(columns.size());
+        id_mask_{0xFFFFFFFFu} {
+    column_count_ = (unsigned int)(columns.size());
   }
 
   /**
    * Get a the column number for the given column name
    */
   unsigned int getColumnNumber(const std::string& colname) const {
-    for (unsigned int i = 0; i < columnCount_; i++)
+    for (unsigned int i = 0; i < column_count_; i++)
       if (colname == columns_[i]) return i;
-    return columnCount_;
+    return column_count_;
   }
 
   /**
    * Get the number of columns
    */
-  unsigned int getColumnCount() const { return columnCount_; }
+  unsigned int getColumnCount() const { return column_count_; }
 
   /**
    * Get the name of the given column
    */
   const std::string& getColumnName(unsigned int icol) const {
-    if (icol >= columnCount_) {
+    if (icol >= column_count_) {
       EXCEPTION_RAISE("ConditionsException",
                       std::string("Column index out of range in ") + getName());
     }
@@ -80,13 +80,13 @@ class BaseTableCondition : public framework::ConditionsObject {
    * Set an AND mask to be applied to the id.  Typically used to "flatten" a
    * table in some manner.
    */
-  void setIdMask(unsigned int mask) { idMask_ = mask; }
+  void setIdMask(unsigned int mask) { id_mask_ = mask; }
 
   /**
    * Get the AND mask to be applied to the id.  Typically used to "flatten" a
    * table in some manner.
    */
-  unsigned int getIdMask() const { return idMask_; }
+  unsigned int getIdMask() const { return id_mask_; }
 
   /**
    * Streams a given row of this table
@@ -101,9 +101,9 @@ class BaseTableCondition : public framework::ConditionsObject {
   std::size_t findKeyInsert(unsigned int id) const;
 
   std::vector<std::string> columns_;
-  unsigned int columnCount_;
+  unsigned int column_count_;
   std::vector<uint32_t> keys_;
-  unsigned int idMask_;
+  unsigned int id_mask_;
 };
 
 template <class T>
@@ -125,12 +125,12 @@ class HomogenousTableCondition : public BaseTableCondition {
 
   /** Add an entry to the table */
   void add(unsigned int id, const std::vector<T>& values) {
-    if (values.size() != columnCount_) {
+    if (values.size() != column_count_) {
       EXCEPTION_RAISE("ConditionsException",
                       getName() + ": Attempted to insert a row with " +
                           std::to_string(values.size()) +
                           " columns into a table with " +
-                          std::to_string(columnCount_) + " columns");
+                          std::to_string(column_count_) + " columns");
     }
     std::size_t loc = findKey(id);
     if (loc != getRowCount()) {
@@ -143,7 +143,7 @@ class HomogenousTableCondition : public BaseTableCondition {
     // insert into the keys
     keys_.insert(keys_.begin() + loc, id);
     // insert into the values
-    values_.insert(values_.begin() + loc * columnCount_, values.begin(),
+    values_.insert(values_.begin() + loc * column_count_, values.begin(),
                    values.end());
   }
 
@@ -153,12 +153,12 @@ class HomogenousTableCondition : public BaseTableCondition {
    */
   T get(unsigned int id, unsigned int col) const {
     std::size_t irow = findKey(id);
-    if (col >= columnCount_ || irow == getRowCount()) {  // raise exception
+    if (col >= column_count_ || irow == getRowCount()) {  // raise exception
       EXCEPTION_RAISE("ConditionsException",
                       "No such column " + std::to_string(col) + " or id " +
                           std::to_string(id));
     }
-    return values_[irow * columnCount_ + col];
+    return values_[irow * column_count_ + col];
   }
 
   /**
@@ -170,8 +170,8 @@ class HomogenousTableCondition : public BaseTableCondition {
       EXCEPTION_RAISE("ConditionsException",
                       "Row out of range: " + std::to_string(irow));
     }
-    std::vector<T> rv(&(values_[irow * columnCount_]),
-                      &(values_[(irow + 1) * columnCount_]));
+    std::vector<T> rv(&(values_[irow * column_count_]),
+                      &(values_[(irow + 1) * column_count_]));
     return std::pair<unsigned int, std::vector<T> >(keys_[irow], rv);
   }
 
@@ -194,8 +194,8 @@ class HomogenousTableCondition : public BaseTableCondition {
                       "Row out of range: " + std::to_string(irow));
     }
     s << keys_[irow];
-    for (int i = 0; i < columnCount_; i++)
-      s << ',' << values_[irow * columnCount_ + i];
+    for (int i = 0; i < column_count_; i++)
+      s << ',' << values_[irow * column_count_ + i];
     return s << std::endl;
   }
 

Conditions/src/Conditions/BaseTableCondition.cxx

@@ -21,7 +21,7 @@ std::ostream& operator<<(std::ostream& s,
 namespace conditions {
 
 std::size_t BaseTableCondition::findKey(unsigned int id) const {
-  unsigned int effid = id & idMask_;
+  unsigned int effid = id & id_mask_;
   std::vector<unsigned int>::const_iterator ptr =
       std::lower_bound(keys_.begin(), keys_.end(), effid);
   if (ptr == keys_.end() || *ptr != effid)
@@ -31,7 +31,7 @@ std::size_t BaseTableCondition::findKey(unsigned int id) const {
 }
 
 std::size_t BaseTableCondition::findKeyInsert(unsigned int id) const {
-  unsigned int effid = id & idMask_;
+  unsigned int effid = id & id_mask_;
   std::vector<unsigned int>::const_iterator ptr =
       std::lower_bound(keys_.begin(), keys_.end(), effid);
   return std::distance(keys_.begin(), ptr);

Conditions/src/Conditions/GeneralCSVLoader.cxx

@@ -14,16 +14,16 @@ namespace conditions {
 const std::string& GeneralCSVLoader::get(const std::string& colname,
                                          bool ignore_case) const {
   size_t i;
-  for (i = 0; i < colNames_.size(); i++) {
-    if (ignore_case && !strcasecmp(colNames_[i].c_str(), colname.c_str()))
+  for (i = 0; i < col_names_.size(); i++) {
+    if (ignore_case && !strcasecmp(col_names_[i].c_str(), colname.c_str()))
       break;
-    if (colNames_[i] == colname) break;
+    if (col_names_[i] == colname) break;
   }
-  if (i == colNames_.size()) {
+  if (i == col_names_.size()) {
     EXCEPTION_RAISE("CSVNoSuchColumn",
                     "No such column '" + colname + "' reading CSV");
   }
-  return rowData_[i];
+  return row_data_[i];
 }
 
 int GeneralCSVLoader::getInteger(const std::string& colname,
@@ -48,17 +48,17 @@ bool GeneralCSVLoader::nextRow() {
     for (auto chunk : tok) {
       line_split.push_back(chunk);
     }
-    if (colNames_.empty()) {
-      colNames_.swap(line_split);
+    if (col_names_.empty()) {
+      col_names_.swap(line_split);
       continue;
     }
-    if (line_split.size() == colNames_.size()) {
-      rowData_.swap(line_split);
+    if (line_split.size() == col_names_.size()) {
+      row_data_.swap(line_split);
     } else {
       EXCEPTION_RAISE("CSVLineMismatch",
                       "Reading CSV found line with " +
                           std::to_string(line_split.size()) + " in CSV with " +
-                          std::to_string(colNames_.size()) + " columns");
+                          std::to_string(col_names_.size()) + " columns");
     }
 
     return true;
@@ -67,32 +67,32 @@ bool GeneralCSVLoader::nextRow() {
 
 StringCSVLoader::StringCSVLoader(const std::string& source,
                                  const std::string lineseparators)
-    : source_{source}, linesep_{lineseparators}, rowBegin_{0}, rowEnd_{0} {
+    : source_{source}, linesep_{lineseparators}, row_begin_{0}, row_end_{0} {
   getNextLine();
 }
 
 std::string StringCSVLoader::getNextLine() {
   std::string retval;
-  if (rowBegin_ != rowEnd_) {
-    if (rowEnd_ == std::string::npos) {
-      retval = source_.substr(rowBegin_, rowEnd_);
+  if (row_begin_ != row_end_) {
+    if (row_end_ == std::string::npos) {
+      retval = source_.substr(row_begin_, row_end_);
     } else {
-      retval = source_.substr(rowBegin_, rowEnd_ - rowBegin_);
+      retval = source_.substr(row_begin_, row_end_ - row_begin_);
     }
   }
   // now we look for the follow on.
   // find the first non-end-of-line character
-  rowBegin_ = source_.find_first_not_of(linesep_, rowEnd_);
-  if (rowBegin_ != std::string::npos) {
-    rowEnd_ = source_.find_first_of(linesep_, rowBegin_);
+  row_begin_ = source_.find_first_not_of(linesep_, row_end_);
+  if (row_begin_ != std::string::npos) {
+    row_end_ = source_.find_first_of(linesep_, row_begin_);
   } else {
-    rowEnd_ = std::string::npos;
+    row_end_ = std::string::npos;
   }
   return retval;
 }
 
 StreamCSVLoader::StreamCSVLoader(const std::string& filename)
-    : source_{0}, ownStream_{true} {
+    : source_{0}, own_stream_{true} {
   std::string expanded_fname = filename;
   wordexp_t p;
 
@@ -125,10 +125,10 @@ StreamCSVLoader::StreamCSVLoader(const std::string& filename)
 }
 
 StreamCSVLoader::StreamCSVLoader(std::istream& stream)
-    : source_{&stream}, ownStream_{false} {}
+    : source_{&stream}, own_stream_{false} {}
 
 StreamCSVLoader::~StreamCSVLoader() {
-  if (ownStream_ && source_) delete source_;
+  if (own_stream_ && source_) delete source_;
   source_ = 0;
 }