[ci][c++] fixed `whitespace/indent_namespace` errors from cpplint (#7056)

* dev * dev * dev * dev * dev --------- Co-authored-by: James Lamb <jaylamb20@gmail.com>

[ci][c++] fixed `whitespace/indent_namespace` errors from cpplint (#7056)
* dev * dev * dev * dev * dev --------- Co-authored-by: James Lamb <jaylamb20@gmail.com>
50f11a9f · Nikita Titov · GitHub · 6f0d7cc2 · 50f11a9f · 50f11a9f
Unverified Commit 50f11a9f authored Oct 14, 2025 by Nikita Titov Committed by GitHub Oct 14, 2025
11 changed files
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -28,7 +28,7 @@ repos:
      - id: cpplint
        args:
          - --recursive
-          - --filter=-build/include_subdir,-build/header_guard,-whitespace/indent_namespace,-whitespace/line_length
+          - --filter=-build/include_subdir,-build/header_guard,-whitespace/line_length
  - repo: local
    hooks:
      - id: check-omp-pragmas

--- a/include/LightGBM/meta.h
+++ b/include/LightGBM/meta.h
@@ -83,7 +83,7 @@ const int kAlignedSize = 32;
 // Refer to https://docs.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-4-c4127?view=vs-2019
 #ifdef _MSC_VER
-  #pragma warning(disable : 4127)
+#pragma warning(disable : 4127)
 #endif
 }  // namespace LightGBM

--- a/src/io/bin.cpp
+++ b/src/io/bin.cpp
@@ -22,13 +22,13 @@
 namespace LightGBM {
-  BinMapper::BinMapper(): num_bin_(1), is_trivial_(true), bin_type_(BinType::NumericalBin) {
+BinMapper::BinMapper(): num_bin_(1), is_trivial_(true), bin_type_(BinType::NumericalBin) {
  bin_upper_bound_.clear();
  bin_upper_bound_.push_back(std::numeric_limits<double>::infinity());
-  }
+}
-  // deep copy function for BinMapper
+// deep copy function for BinMapper
-  BinMapper::BinMapper(const BinMapper& other) {
+BinMapper::BinMapper(const BinMapper& other) {
  num_bin_ = other.num_bin_;
  missing_type_ = other.missing_type_;
  is_trivial_ = other.is_trivial_;
@@ -44,16 +44,16 @@ namespace LightGBM {
  max_val_ = other.max_val_;
  default_bin_ = other.default_bin_;
  most_freq_bin_ = other.most_freq_bin_;
-  }
+}
-  BinMapper::BinMapper(const void* memory) {
+BinMapper::BinMapper(const void* memory) {
  CopyFrom(reinterpret_cast<const char*>(memory));
-  }
+}
-  BinMapper::~BinMapper() {
+BinMapper::~BinMapper() {
-  }
+}
-  bool NeedFilter(const std::vector<int>& cnt_in_bin, int total_cnt, int filter_cnt, BinType bin_type) {
+bool NeedFilter(const std::vector<int>& cnt_in_bin, int total_cnt, int filter_cnt, BinType bin_type) {
  if (bin_type == BinType::NumericalBin) {
    int sum_left = 0;
    for (size_t i = 0; i < cnt_in_bin.size() - 1; ++i) {
@@ -75,9 +75,9 @@ namespace LightGBM {
    }
  }
  return true;
-  }
+}
-  std::vector<double> GreedyFindBin(const double* distinct_values, const int* counts,
+std::vector<double> GreedyFindBin(const double* distinct_values, const int* counts,
                                  int num_distinct_values, int max_bin,
                                  size_t total_cnt, int min_data_in_bin) {
  std::vector<double> bin_upper_bound;
@@ -156,9 +156,9 @@ namespace LightGBM {
    bin_upper_bound.push_back(std::numeric_limits<double>::infinity());
  }
  return bin_upper_bound;
-  }
+}
-  std::vector<double> FindBinWithPredefinedBin(const double* distinct_values, const int* counts,
+std::vector<double> FindBinWithPredefinedBin(const double* distinct_values, const int* counts,
                                              int num_distinct_values, int max_bin,
                                              size_t total_sample_cnt, int min_data_in_bin,
                                              const std::vector<double>& forced_upper_bounds) {
@@ -241,9 +241,9 @@ namespace LightGBM {
  std::stable_sort(bin_upper_bound.begin(), bin_upper_bound.end());
  CHECK_LE(bin_upper_bound.size(), static_cast<size_t>(max_bin));
  return bin_upper_bound;
-  }
+}
-  std::vector<double> FindBinWithZeroAsOneBin(const double* distinct_values, const int* counts, int num_distinct_values,
+std::vector<double> FindBinWithZeroAsOneBin(const double* distinct_values, const int* counts, int num_distinct_values,
                                            int max_bin, size_t total_sample_cnt, int min_data_in_bin) {
  std::vector<double> bin_upper_bound;
  int left_cnt_data = 0;
@@ -299,9 +299,9 @@ namespace LightGBM {
  }
  CHECK_LE(bin_upper_bound.size(), static_cast<size_t>(max_bin));
  return bin_upper_bound;
-  }
+}
-  std::vector<double> FindBinWithZeroAsOneBin(const double* distinct_values, const int* counts, int num_distinct_values,
+std::vector<double> FindBinWithZeroAsOneBin(const double* distinct_values, const int* counts, int num_distinct_values,
                                            int max_bin, size_t total_sample_cnt, int min_data_in_bin,
                                            const std::vector<double>& forced_upper_bounds) {
  if (forced_upper_bounds.empty()) {
@@ -310,9 +310,9 @@ namespace LightGBM {
    return FindBinWithPredefinedBin(distinct_values, counts, num_distinct_values, max_bin, total_sample_cnt, min_data_in_bin,
                                    forced_upper_bounds);
  }
-  }
+}
-  void BinMapper::FindBin(double* values, int num_sample_values, size_t total_sample_cnt,
+void BinMapper::FindBin(double* values, int num_sample_values, size_t total_sample_cnt,
                        int max_bin, int min_data_in_bin, int min_split_data, bool pre_filter, BinType bin_type,
                        bool use_missing, bool zero_as_missing,
                        const std::vector<double>& forced_upper_bounds) {
@@ -507,9 +507,9 @@ namespace LightGBM {
  } else {
    sparse_rate_ = 1.0f;
  }
-  }
+}
-  void BinMapper::CopyTo(char * buffer) const {
+void BinMapper::CopyTo(char * buffer) const {
  std::memcpy(buffer, &num_bin_, sizeof(num_bin_));
  buffer += VirtualFileWriter::AlignedSize(sizeof(num_bin_));
  std::memcpy(buffer, &missing_type_, sizeof(missing_type_));
@@ -533,9 +533,9 @@ namespace LightGBM {
  } else {
    std::memcpy(buffer, bin_2_categorical_.data(), num_bin_ * sizeof(int));
  }
-  }
+}
-  void BinMapper::CopyFrom(const char * buffer) {
+void BinMapper::CopyFrom(const char * buffer) {
  std::memcpy(&num_bin_, buffer, sizeof(num_bin_));
  buffer += VirtualFileWriter::AlignedSize(sizeof(num_bin_));
  std::memcpy(&missing_type_, buffer, sizeof(missing_type_));
@@ -565,9 +565,9 @@ namespace LightGBM {
      categorical_2_bin_[bin_2_categorical_[i]] = static_cast<unsigned int>(i);
    }
  }
-  }
+}
-  void BinMapper::SaveBinaryToFile(BinaryWriter* writer) const {
+void BinMapper::SaveBinaryToFile(BinaryWriter* writer) const {
  writer->AlignedWrite(&num_bin_, sizeof(num_bin_));
  writer->AlignedWrite(&missing_type_, sizeof(missing_type_));
  writer->AlignedWrite(&is_trivial_, sizeof(is_trivial_));
@@ -582,9 +582,9 @@ namespace LightGBM {
  } else {
    writer->Write(bin_2_categorical_.data(), sizeof(int) * num_bin_);
  }
-  }
+}
-  size_t BinMapper::SizesInByte() const {
+size_t BinMapper::SizesInByte() const {
  size_t ret = VirtualFileWriter::AlignedSize(sizeof(num_bin_)) +
                VirtualFileWriter::AlignedSize(sizeof(missing_type_)) +
                VirtualFileWriter::AlignedSize(sizeof(is_trivial_)) +
@@ -599,22 +599,22 @@ namespace LightGBM {
    ret += sizeof(int) * num_bin_;
  }
  return ret;
-  }
+}
-  template class DenseBin<uint8_t, true>;
+template class DenseBin<uint8_t, true>;
-  template class DenseBin<uint8_t, false>;
+template class DenseBin<uint8_t, false>;
-  template class DenseBin<uint16_t, false>;
+template class DenseBin<uint16_t, false>;
-  template class DenseBin<uint32_t, false>;
+template class DenseBin<uint32_t, false>;
-  template class SparseBin<uint8_t>;
+template class SparseBin<uint8_t>;
-  template class SparseBin<uint16_t>;
+template class SparseBin<uint16_t>;
-  template class SparseBin<uint32_t>;
+template class SparseBin<uint32_t>;
-  template class MultiValDenseBin<uint8_t>;
+template class MultiValDenseBin<uint8_t>;
-  template class MultiValDenseBin<uint16_t>;
+template class MultiValDenseBin<uint16_t>;
-  template class MultiValDenseBin<uint32_t>;
+template class MultiValDenseBin<uint32_t>;
-  Bin* Bin::CreateDenseBin(data_size_t num_data, int num_bin) {
+Bin* Bin::CreateDenseBin(data_size_t num_data, int num_bin) {
  if (num_bin <= 16) {
    return new DenseBin<uint8_t, true>(num_data);
  } else if (num_bin <= 256) {
@@ -624,9 +624,9 @@ namespace LightGBM {
  } else {
    return new DenseBin<uint32_t, false>(num_data);
  }
-  }
+}
-  Bin* Bin::CreateSparseBin(data_size_t num_data, int num_bin) {
+Bin* Bin::CreateSparseBin(data_size_t num_data, int num_bin) {
  if (num_bin <= 256) {
    return new SparseBin<uint8_t>(num_data);
  } else if (num_bin <= 65536) {
@@ -634,9 +634,9 @@ namespace LightGBM {
  } else {
    return new SparseBin<uint32_t>(num_data);
  }
-  }
+}
-  MultiValBin* MultiValBin::CreateMultiValBin(data_size_t num_data, int num_bin, int num_feature,
+MultiValBin* MultiValBin::CreateMultiValBin(data_size_t num_data, int num_bin, int num_feature,
  double sparse_rate, const std::vector<uint32_t>& offsets) {
  if (sparse_rate >= multi_val_bin_sparse_threshold) {
    const double average_element_per_row = (1.0 - sparse_rate) * num_feature;
@@ -645,9 +645,9 @@ namespace LightGBM {
  } else {
    return CreateMultiValDenseBin(num_data, num_bin, num_feature, offsets);
  }
-  }
+}
-  MultiValBin* MultiValBin::CreateMultiValDenseBin(data_size_t num_data,
+MultiValBin* MultiValBin::CreateMultiValDenseBin(data_size_t num_data,
                                                  int num_bin,
                                                  int num_feature,
                                                  const std::vector<uint32_t>& offsets) {
@@ -666,9 +666,9 @@ namespace LightGBM {
  } else {
    return new MultiValDenseBin<uint32_t>(num_data, num_bin, num_feature, offsets);
  }
-  }
+}
-  MultiValBin* MultiValBin::CreateMultiValSparseBin(data_size_t num_data,
+MultiValBin* MultiValBin::CreateMultiValSparseBin(data_size_t num_data,
                                                  int num_bin,
                                                  double estimate_element_per_row) {
  size_t estimate_total_entries =
@@ -707,10 +707,10 @@ namespace LightGBM {
          num_data, num_bin, estimate_element_per_row);
    }
  }
-  }
+}
-  template <>
+template <>
-  const void* DenseBin<uint8_t, false>::GetColWiseData(
+const void* DenseBin<uint8_t, false>::GetColWiseData(
  uint8_t* bit_type,
  bool* is_sparse,
  std::vector<BinIterator*>* bin_iterator,
@@ -719,10 +719,10 @@ namespace LightGBM {
  *bit_type = 8;
  bin_iterator->clear();
  return reinterpret_cast<const void*>(data_.data());
-  }
+}
-  template <>
+template <>
-  const void* DenseBin<uint16_t, false>::GetColWiseData(
+const void* DenseBin<uint16_t, false>::GetColWiseData(
  uint8_t* bit_type,
  bool* is_sparse,
  std::vector<BinIterator*>* bin_iterator,
@@ -731,10 +731,10 @@ namespace LightGBM {
  *bit_type = 16;
  bin_iterator->clear();
  return reinterpret_cast<const void*>(data_.data());
-  }
+}
-  template <>
+template <>
-  const void* DenseBin<uint32_t, false>::GetColWiseData(
+const void* DenseBin<uint32_t, false>::GetColWiseData(
  uint8_t* bit_type,
  bool* is_sparse,
  std::vector<BinIterator*>* bin_iterator,
@@ -743,10 +743,10 @@ namespace LightGBM {
  *bit_type = 32;
  bin_iterator->clear();
  return reinterpret_cast<const void*>(data_.data());
-  }
+}
-  template <>
+template <>
-  const void* DenseBin<uint8_t, true>::GetColWiseData(
+const void* DenseBin<uint8_t, true>::GetColWiseData(
  uint8_t* bit_type,
  bool* is_sparse,
  std::vector<BinIterator*>* bin_iterator,
@@ -755,10 +755,10 @@ namespace LightGBM {
  *bit_type = 4;
  bin_iterator->clear();
  return reinterpret_cast<const void*>(data_.data());
-  }
+}
-  template <>
+template <>
-  const void* DenseBin<uint8_t, false>::GetColWiseData(
+const void* DenseBin<uint8_t, false>::GetColWiseData(
  uint8_t* bit_type,
  bool* is_sparse,
  BinIterator** bin_iterator) const {
@@ -766,10 +766,10 @@ namespace LightGBM {
  *bit_type = 8;
  *bin_iterator = nullptr;
  return reinterpret_cast<const void*>(data_.data());
-  }
+}
-  template <>
+template <>
-  const void* DenseBin<uint16_t, false>::GetColWiseData(
+const void* DenseBin<uint16_t, false>::GetColWiseData(
  uint8_t* bit_type,
  bool* is_sparse,
  BinIterator** bin_iterator) const {
@@ -777,10 +777,10 @@ namespace LightGBM {
  *bit_type = 16;
  *bin_iterator = nullptr;
  return reinterpret_cast<const void*>(data_.data());
-  }
+}
-  template <>
+template <>
-  const void* DenseBin<uint32_t, false>::GetColWiseData(
+const void* DenseBin<uint32_t, false>::GetColWiseData(
  uint8_t* bit_type,
  bool* is_sparse,
  BinIterator** bin_iterator) const {
@@ -788,10 +788,10 @@ namespace LightGBM {
  *bit_type = 32;
  *bin_iterator = nullptr;
  return reinterpret_cast<const void*>(data_.data());
-  }
+}
-  template <>
+template <>
-  const void* DenseBin<uint8_t, true>::GetColWiseData(
+const void* DenseBin<uint8_t, true>::GetColWiseData(
  uint8_t* bit_type,
  bool* is_sparse,
  BinIterator** bin_iterator) const {
@@ -799,10 +799,10 @@ namespace LightGBM {
  *bit_type = 4;
  *bin_iterator = nullptr;
  return reinterpret_cast<const void*>(data_.data());
-  }
+}
-  template <>
+template <>
-  const void* SparseBin<uint8_t>::GetColWiseData(
+const void* SparseBin<uint8_t>::GetColWiseData(
  uint8_t* bit_type,
  bool* is_sparse,
  std::vector<BinIterator*>* bin_iterator,
@@ -813,10 +813,10 @@ namespace LightGBM {
    bin_iterator->emplace_back(new SparseBinIterator<uint8_t>(this, 0));
  }
  return nullptr;
-  }
+}
-  template <>
+template <>
-  const void* SparseBin<uint16_t>::GetColWiseData(
+const void* SparseBin<uint16_t>::GetColWiseData(
  uint8_t* bit_type,
  bool* is_sparse,
  std::vector<BinIterator*>* bin_iterator,
@@ -827,10 +827,10 @@ namespace LightGBM {
    bin_iterator->emplace_back(new SparseBinIterator<uint16_t>(this, 0));
  }
  return nullptr;
-  }
+}
-  template <>
+template <>
-  const void* SparseBin<uint32_t>::GetColWiseData(
+const void* SparseBin<uint32_t>::GetColWiseData(
  uint8_t* bit_type,
  bool* is_sparse,
  std::vector<BinIterator*>* bin_iterator,
@@ -841,10 +841,10 @@ namespace LightGBM {
    bin_iterator->emplace_back(new SparseBinIterator<uint32_t>(this, 0));
  }
  return nullptr;
-  }
+}
-  template <>
+template <>
-  const void* SparseBin<uint8_t>::GetColWiseData(
+const void* SparseBin<uint8_t>::GetColWiseData(
  uint8_t* bit_type,
  bool* is_sparse,
  BinIterator** bin_iterator) const {
@@ -852,10 +852,10 @@ namespace LightGBM {
  *bit_type = 8;
  *bin_iterator = new SparseBinIterator<uint8_t>(this, 0);
  return nullptr;
-  }
+}
-  template <>
+template <>
-  const void* SparseBin<uint16_t>::GetColWiseData(
+const void* SparseBin<uint16_t>::GetColWiseData(
  uint8_t* bit_type,
  bool* is_sparse,
  BinIterator** bin_iterator) const {
@@ -863,10 +863,10 @@ namespace LightGBM {
  *bit_type = 16;
  *bin_iterator = new SparseBinIterator<uint16_t>(this, 0);
  return nullptr;
-  }
+}
-  template <>
+template <>
-  const void* SparseBin<uint32_t>::GetColWiseData(
+const void* SparseBin<uint32_t>::GetColWiseData(
  uint8_t* bit_type,
  bool* is_sparse,
  BinIterator** bin_iterator) const {
@@ -874,11 +874,11 @@ namespace LightGBM {
  *bit_type = 32;
  *bin_iterator = new SparseBinIterator<uint32_t>(this, 0);
  return nullptr;
-  }
+}
-  #ifdef USE_CUDA
+#ifdef USE_CUDA
-  template <>
+template <>
-  const void* MultiValDenseBin<uint8_t>::GetRowWiseData(uint8_t* bit_type,
+const void* MultiValDenseBin<uint8_t>::GetRowWiseData(uint8_t* bit_type,
    size_t* total_size,
    bool* is_sparse,
    const void** out_data_ptr,
@@ -891,10 +891,10 @@ namespace LightGBM {
  *out_data_ptr = nullptr;
  *data_ptr_bit_type = 0;
  return to_return;
-  }
+}
-  template <>
+template <>
-  const void* MultiValDenseBin<uint16_t>::GetRowWiseData(uint8_t* bit_type,
+const void* MultiValDenseBin<uint16_t>::GetRowWiseData(uint8_t* bit_type,
  size_t* total_size,
  bool* is_sparse,
  const void** out_data_ptr,
@@ -908,10 +908,10 @@ namespace LightGBM {
  *out_data_ptr = nullptr;
  *data_ptr_bit_type = 0;
  return to_return;
-  }
+}
-  template <>
+template <>
-  const void* MultiValDenseBin<uint32_t>::GetRowWiseData(uint8_t* bit_type,
+const void* MultiValDenseBin<uint32_t>::GetRowWiseData(uint8_t* bit_type,
  size_t* total_size,
  bool* is_sparse,
  const void** out_data_ptr,
@@ -925,10 +925,10 @@ namespace LightGBM {
  *out_data_ptr = nullptr;
  *data_ptr_bit_type = 0;
  return to_return;
-  }
+}
-  template <>
+template <>
-  const void* MultiValSparseBin<uint16_t, uint8_t>::GetRowWiseData(
+const void* MultiValSparseBin<uint16_t, uint8_t>::GetRowWiseData(
  uint8_t* bit_type,
  size_t* total_size,
  bool* is_sparse,
@@ -941,10 +941,10 @@ namespace LightGBM {
  *out_data_ptr = reinterpret_cast<const uint8_t*>(row_ptr_.data());
  *data_ptr_bit_type = 16;
  return to_return;
-  }
+}
-  template <>
+template <>
-  const void* MultiValSparseBin<uint16_t, uint16_t>::GetRowWiseData(
+const void* MultiValSparseBin<uint16_t, uint16_t>::GetRowWiseData(
  uint8_t* bit_type,
  size_t* total_size,
  bool* is_sparse,
@@ -957,10 +957,10 @@ namespace LightGBM {
  *out_data_ptr = reinterpret_cast<const uint8_t*>(row_ptr_.data());
  *data_ptr_bit_type = 16;
  return to_return;
-  }
+}
-  template <>
+template <>
-  const void* MultiValSparseBin<uint16_t, uint32_t>::GetRowWiseData(
+const void* MultiValSparseBin<uint16_t, uint32_t>::GetRowWiseData(
  uint8_t* bit_type,
  size_t* total_size,
  bool* is_sparse,
@@ -973,10 +973,10 @@ namespace LightGBM {
  *out_data_ptr = reinterpret_cast<const uint8_t*>(row_ptr_.data());
  *data_ptr_bit_type = 16;
  return to_return;
-  }
+}
-  template <>
+template <>
-  const void* MultiValSparseBin<uint32_t, uint8_t>::GetRowWiseData(
+const void* MultiValSparseBin<uint32_t, uint8_t>::GetRowWiseData(
  uint8_t* bit_type,
  size_t* total_size,
  bool* is_sparse,
@@ -989,10 +989,10 @@ namespace LightGBM {
  *out_data_ptr = reinterpret_cast<const uint8_t*>(row_ptr_.data());
  *data_ptr_bit_type = 32;
  return to_return;
-  }
+}
-  template <>
+template <>
-  const void* MultiValSparseBin<uint32_t, uint16_t>::GetRowWiseData(
+const void* MultiValSparseBin<uint32_t, uint16_t>::GetRowWiseData(
  uint8_t* bit_type,
  size_t* total_size,
  bool* is_sparse,
@@ -1005,10 +1005,10 @@ namespace LightGBM {
  *out_data_ptr = reinterpret_cast<const uint8_t*>(row_ptr_.data());
  *data_ptr_bit_type = 32;
  return to_return;
-  }
+}
-  template <>
+template <>
-  const void* MultiValSparseBin<uint32_t, uint32_t>::GetRowWiseData(
+const void* MultiValSparseBin<uint32_t, uint32_t>::GetRowWiseData(
  uint8_t* bit_type,
  size_t* total_size,
  bool* is_sparse,
@@ -1021,10 +1021,10 @@ namespace LightGBM {
  *out_data_ptr = reinterpret_cast<const uint8_t*>(row_ptr_.data());
  *data_ptr_bit_type = 32;
  return to_return;
-  }
+}
-  template <>
+template <>
-  const void* MultiValSparseBin<uint64_t, uint8_t>::GetRowWiseData(
+const void* MultiValSparseBin<uint64_t, uint8_t>::GetRowWiseData(
  uint8_t* bit_type,
  size_t* total_size,
  bool* is_sparse,
@@ -1037,10 +1037,10 @@ namespace LightGBM {
  *out_data_ptr = reinterpret_cast<const uint8_t*>(row_ptr_.data());
  *data_ptr_bit_type = 64;
  return to_return;
-  }
+}
-  template <>
+template <>
-  const void* MultiValSparseBin<uint64_t, uint16_t>::GetRowWiseData(
+const void* MultiValSparseBin<uint64_t, uint16_t>::GetRowWiseData(
  uint8_t* bit_type,
  size_t* total_size,
  bool* is_sparse,
@@ -1053,10 +1053,10 @@ namespace LightGBM {
  *out_data_ptr = reinterpret_cast<const uint8_t*>(row_ptr_.data());
  *data_ptr_bit_type = 64;
  return to_return;
-  }
+}
-  template <>
+template <>
-  const void* MultiValSparseBin<uint64_t, uint32_t>::GetRowWiseData(
+const void* MultiValSparseBin<uint64_t, uint32_t>::GetRowWiseData(
  uint8_t* bit_type,
  size_t* total_size,
  bool* is_sparse,
@@ -1069,8 +1069,8 @@ namespace LightGBM {
  *out_data_ptr = reinterpret_cast<const uint8_t*>(row_ptr_.data());
  *data_ptr_bit_type = 64;
  return to_return;
-  }
+}
-  #endif  // USE_CUDA
+#endif  // USE_CUDA
 }  // namespace LightGBM
--- a/src/io/dataset.cpp
+++ b/src/io/dataset.cpp
@@ -28,10 +28,8 @@ namespace LightGBM {
 const int Dataset::kSerializedReferenceVersionLength = 2;
 const char* Dataset::serialized_reference_version = "v1";
-const char* Dataset::binary_file_token =
+const char* Dataset::binary_file_token = "______LightGBM_Binary_File_Token______\n";
-    "______LightGBM_Binary_File_Token______\n";
+const char* Dataset::binary_serialized_reference_token = "______LightGBM_Binary_Serialized_Token______\n";
-const char* Dataset::binary_serialized_reference_token =
-    "______LightGBM_Binary_Serialized_Token______\n";
 Dataset::Dataset() {
  data_filename_ = "noname";

--- a/src/metric/cuda/cuda_binary_metric.cpp
+++ b/src/metric/cuda/cuda_binary_metric.cpp
@@ -12,8 +12,8 @@
 namespace LightGBM {
-CUDABinaryLoglossMetric::CUDABinaryLoglossMetric(const Config& config):
+CUDABinaryLoglossMetric::CUDABinaryLoglossMetric(
-  CUDABinaryMetricInterface<BinaryLoglossMetric, CUDABinaryLoglossMetric>(config) {}
+  const Config& config):CUDABinaryMetricInterface<BinaryLoglossMetric, CUDABinaryLoglossMetric>(config) {}
 template <typename HOST_METRIC, typename CUDA_METRIC>
 std::vector<double> CUDABinaryMetricInterface<HOST_METRIC, CUDA_METRIC>::Eval(const double* score, const ObjectiveFunction* objective) const {

--- a/src/metric/xentropy_metric.hpp
+++ b/src/metric/xentropy_metric.hpp
@@ -30,9 +30,9 @@
 namespace LightGBM {
-  // label should be in interval [0, 1];
+// label should be in interval [0, 1];
-  // prob should be in interval (0, 1); prob is clipped if needed
+// prob should be in interval (0, 1); prob is clipped if needed
-  inline static double XentLoss(label_t label, double prob) {
+inline static double XentLoss(label_t label, double prob) {
  const double log_arg_epsilon = 1.0e-12;
  double a = label;
  if (prob > log_arg_epsilon) {
@@ -47,23 +47,23 @@ namespace LightGBM {
    b *= std::log(log_arg_epsilon);
  }
  return - (a + b);
-  }
+}
-  // hhat >(=) 0 assumed; and weight > 0 required; but not checked here
+// hhat >(=) 0 assumed; and weight > 0 required; but not checked here
-  inline static double XentLambdaLoss(label_t label, label_t weight, double hhat) {
+inline static double XentLambdaLoss(label_t label, label_t weight, double hhat) {
  return XentLoss(label, 1.0f - std::exp(-weight * hhat));
-  }
+}
-  // Computes the (negative) entropy for label p; p should be in interval [0, 1];
+// Computes the (negative) entropy for label p; p should be in interval [0, 1];
-  // This is used to presum the KL-divergence offset term (to be _added_ to the cross-entropy loss).
+// This is used to presum the KL-divergence offset term (to be _added_ to the cross-entropy loss).
-  // NOTE: x*log(x) = 0 for x=0,1; so only add when in (0, 1); avoid log(0)*0
+// NOTE: x*log(x) = 0 for x=0,1; so only add when in (0, 1); avoid log(0)*0
-  inline static double YentLoss(double p) {
+inline static double YentLoss(double p) {
  double hp = 0.0;
  if (p > 0) hp += p * std::log(p);
  double q = 1.0f - p;
  if (q > 0) hp += q * std::log(q);
  return hp;
-  }
+}
 //
 // CrossEntropyMetric : "xentropy" : (optional) weights are used linearly

--- a/src/treelearner/data_parallel_tree_learner.cpp
+++ b/src/treelearner/data_parallel_tree_learner.cpp
@@ -12,8 +12,7 @@
 namespace LightGBM {
 template <typename TREELEARNER_T>
-DataParallelTreeLearner<TREELEARNER_T>::DataParallelTreeLearner(const Config* config)
+DataParallelTreeLearner<TREELEARNER_T>::DataParallelTreeLearner(const Config* config):TREELEARNER_T(config) {
-  :TREELEARNER_T(config) {
 }
 template <typename TREELEARNER_T>

--- a/src/treelearner/feature_histogram.cpp
+++ b/src/treelearner/feature_histogram.cpp
@@ -384,8 +384,11 @@ void FeatureHistogram::FindBestThresholdCategoricalInner(double sum_gradient,
  }
 }
-template <bool USE_RAND, bool USE_MC, bool USE_L1, bool USE_MAX_OUTPUT, bool USE_SMOOTHING, typename PACKED_HIST_BIN_T, typename PACKED_HIST_ACC_T,
+template <
-          typename HIST_BIN_T, typename HIST_ACC_T, int HIST_BITS_BIN, int HIST_BITS_ACC>
+bool USE_RAND, bool USE_MC, bool USE_L1, bool USE_MAX_OUTPUT, bool USE_SMOOTHING,
+typename PACKED_HIST_BIN_T, typename PACKED_HIST_ACC_T, typename HIST_BIN_T, typename HIST_ACC_T,
+int HIST_BITS_BIN, int HIST_BITS_ACC
+>
 void FeatureHistogram::FindBestThresholdCategoricalIntInner(int64_t int_sum_gradient_and_hessian,
                                          const double grad_scale, const double hess_scale,
                                          data_size_t num_data,

--- a/src/treelearner/feature_parallel_tree_learner.cpp
+++ b/src/treelearner/feature_parallel_tree_learner.cpp
@@ -11,8 +11,7 @@ namespace LightGBM {
 template <typename TREELEARNER_T>
-FeatureParallelTreeLearner<TREELEARNER_T>::FeatureParallelTreeLearner(const Config* config)
+FeatureParallelTreeLearner<TREELEARNER_T>::FeatureParallelTreeLearner(const Config* config):TREELEARNER_T(config) {
-  :TREELEARNER_T(config) {
 }
 template <typename TREELEARNER_T>

--- a/src/treelearner/voting_parallel_tree_learner.cpp
+++ b/src/treelearner/voting_parallel_tree_learner.cpp
@@ -15,8 +15,7 @@
 namespace LightGBM {
 template <typename TREELEARNER_T>
-VotingParallelTreeLearner<TREELEARNER_T>::VotingParallelTreeLearner(const Config* config)
+VotingParallelTreeLearner<TREELEARNER_T>::VotingParallelTreeLearner(const Config* config):TREELEARNER_T(config) {
-  :TREELEARNER_T(config) {
  top_k_ = this->config_->top_k;
 }

--- a/tests/cpp_tests/testutils.cpp
+++ b/tests/cpp_tests/testutils.cpp
@@ -18,10 +18,10 @@ using LightGBM::Random;
 namespace LightGBM {
-  /*!
+/*!
-  * Creates a Dataset from the internal repository examples.
+* Creates a Dataset from the internal repository examples.
-  */
+*/
-  int TestUtils::LoadDatasetFromExamples(const char* filename, const char* config, DatasetHandle* out) {
+int TestUtils::LoadDatasetFromExamples(const char* filename, const char* config, DatasetHandle* out) {
  std::string fullPath("examples/");
  fullPath += filename;
  Log::Info("Debug sample data path: %s", fullPath.c_str());
@@ -30,12 +30,12 @@ namespace LightGBM {
    config,
    nullptr,
    out);
-  }
+}
-  /*!
+/*!
-  * Creates fake data in the passed vectors.
+* Creates fake data in the passed vectors.
-  */
+*/
-  void TestUtils::CreateRandomDenseData(
+void TestUtils::CreateRandomDenseData(
  int32_t nrows,
  int32_t ncols,
  int32_t nclasses,
@@ -54,12 +54,12 @@ namespace LightGBM {
  }
  CreateRandomMetadata(nrows, nclasses, labels, weights, init_scores, groups);
-  }
+}
-  /*!
+/*!
-  * Creates fake data in the passed vectors.
+* Creates fake data in the passed vectors.
-  */
+*/
-  void TestUtils::CreateRandomSparseData(
+void TestUtils::CreateRandomSparseData(
  int32_t nrows,
  int32_t ncols,
  int32_t nclasses,
@@ -89,12 +89,12 @@ namespace LightGBM {
  }
  CreateRandomMetadata(nrows, nclasses, labels, weights, init_scores, groups);
-  }
+}
-  /*!
+/*!
-  * Creates fake data in the passed vectors.
+* Creates fake data in the passed vectors.
-  */
+*/
-  void TestUtils::CreateRandomMetadata(int32_t nrows,
+void TestUtils::CreateRandomMetadata(int32_t nrows,
  int32_t nclasses,
  std::vector<float>* labels,
  std::vector<float>* weights,
@@ -131,9 +131,9 @@ namespace LightGBM {
      groups->push_back(group);
    }
  }
-  }
+}
-  void TestUtils::StreamDenseDataset(DatasetHandle dataset_handle,
+void TestUtils::StreamDenseDataset(DatasetHandle dataset_handle,
  int32_t nrows,
  int32_t ncols,
  int32_t nclasses,
@@ -206,9 +206,9 @@ namespace LightGBM {
  auto cur_time = std::chrono::steady_clock::now();
  Log::Info(" Time: %d", cur_time - start_time);
-  }
+}
-  void TestUtils::StreamSparseDataset(DatasetHandle dataset_handle,
+void TestUtils::StreamSparseDataset(DatasetHandle dataset_handle,
                                    int32_t nrows,
                                    int32_t nclasses,
                                    int32_t batch_count,
@@ -273,14 +273,14 @@ namespace LightGBM {
  auto cur_time = std::chrono::steady_clock::now();
  Log::Info(" Time: %d", cur_time - start_time);
-  }
+}
-  /*!
+/*!
  * Pushes data from 1 thread into a Dataset based on thread_id and nrows.
  * e.g. with 100 rows, thread 0 will push rows 0-49, and thread 2 will push rows 50-99.
  * Note that rows are still pushed in microbatches within their range.
  */
-  void TestUtils::PushSparseBatch(DatasetHandle dataset_handle,
+void TestUtils::PushSparseBatch(DatasetHandle dataset_handle,
                                int32_t nrows,
                                int32_t nclasses,
                                int32_t batch_count,
@@ -346,10 +346,10 @@ namespace LightGBM {
      groups_ptr += batch_count;
    }
  }
-  }
+}
-  void TestUtils::AssertMetadata(const Metadata* metadata,
+void TestUtils::AssertMetadata(const Metadata* metadata,
  const std::vector<float>* ref_labels,
  const std::vector<float>* ref_weights,
  const std::vector<double>* ref_init_scores,
@@ -419,9 +419,9 @@ namespace LightGBM {
  } else if (ref_groups) {
    FAIL() << "Expected non-null query_boundaries";
  }
-  }
+}
-  const double* TestUtils::CreateInitScoreBatch(std::vector<double>* init_score_batch,
+const double* TestUtils::CreateInitScoreBatch(std::vector<double>* init_score_batch,
  int32_t index,
  int32_t nrows,
  int32_t nclasses,
@@ -435,6 +435,6 @@ namespace LightGBM {
    }
  }
  return init_score_batch->data();
-  }
+}
 }  // namespace LightGBM