data-structure-typed 2.4.1 → 2.4.3

package/build/_deps/benchmark-src/src/reporter.cc

@@ -1,118 +0,0 @@
-// Copyright 2015 Google Inc. All rights reserved.
-//
-// 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.
-
-#include <cstdlib>
-#include <iostream>
-#include <map>
-#include <string>
-#include <tuple>
-#include <vector>
-
-#include "benchmark/benchmark.h"
-#include "check.h"
-#include "string_util.h"
-#include "timers.h"
-
-namespace benchmark {
-
-BenchmarkReporter::BenchmarkReporter()
-    : output_stream_(&std::cout), error_stream_(&std::cerr) {}
-
-BenchmarkReporter::~BenchmarkReporter() {}
-
-void BenchmarkReporter::PrintBasicContext(std::ostream *out,
-                                          Context const &context) {
-  BM_CHECK(out) << "cannot be null";
-  auto &Out = *out;
-
-#ifndef BENCHMARK_OS_QURT
-  // Date/time information is not available on QuRT.
-  // Attempting to get it via this call cause the binary to crash.
-  Out << LocalDateTimeString() << "\n";
-#endif
-
-  if (context.executable_name)
-    Out << "Running " << context.executable_name << "\n";
-
-  const CPUInfo &info = context.cpu_info;
-  Out << "Run on (" << info.num_cpus << " X "
-      << (info.cycles_per_second / 1000000.0) << " MHz CPU "
-      << ((info.num_cpus > 1) ? "s" : "") << ")\n";
-  if (info.caches.size() != 0) {
-    Out << "CPU Caches:\n";
-    for (auto &CInfo : info.caches) {
-      Out << "  L" << CInfo.level << " " << CInfo.type << " "
-          << (CInfo.size / 1024) << " KiB";
-      if (CInfo.num_sharing != 0)
-        Out << " (x" << (info.num_cpus / CInfo.num_sharing) << ")";
-      Out << "\n";
-    }
-  }
-  if (!info.load_avg.empty()) {
-    Out << "Load Average: ";
-    for (auto It = info.load_avg.begin(); It != info.load_avg.end();) {
-      Out << StrFormat("%.2f", *It++);
-      if (It != info.load_avg.end()) Out << ", ";
-    }
-    Out << "\n";
-  }
-
-  std::map<std::string, std::string> *global_context =
-      internal::GetGlobalContext();
-
-  if (global_context != nullptr) {
-    for (const auto &kv : *global_context) {
-      Out << kv.first << ": " << kv.second << "\n";
-    }
-  }
-
-  if (CPUInfo::Scaling::ENABLED == info.scaling) {
-    Out << "***WARNING*** CPU scaling is enabled, the benchmark "
-           "real time measurements may be noisy and will incur extra "
-           "overhead.\n";
-  }
-
-#ifndef NDEBUG
-  Out << "***WARNING*** Library was built as DEBUG. Timings may be "
-         "affected.\n";
-#endif
-}
-
-// No initializer because it's already initialized to NULL.
-const char *BenchmarkReporter::Context::executable_name;
-
-BenchmarkReporter::Context::Context()
-    : cpu_info(CPUInfo::Get()), sys_info(SystemInfo::Get()) {}
-
-std::string BenchmarkReporter::Run::benchmark_name() const {
-  std::string name = run_name.str();
-  if (run_type == RT_Aggregate) {
-    name += "_" + aggregate_name;
-  }
-  return name;
-}
-
-double BenchmarkReporter::Run::GetAdjustedRealTime() const {
-  double new_time = real_accumulated_time * GetTimeUnitMultiplier(time_unit);
-  if (iterations != 0) new_time /= static_cast<double>(iterations);
-  return new_time;
-}
-
-double BenchmarkReporter::Run::GetAdjustedCPUTime() const {
-  double new_time = cpu_accumulated_time * GetTimeUnitMultiplier(time_unit);
-  if (iterations != 0) new_time /= static_cast<double>(iterations);
-  return new_time;
-}
-
-}  // end namespace benchmark

package/build/_deps/benchmark-src/src/statistics.cc

@@ -1,209 +0,0 @@
-// Copyright 2016 Ismael Jimenez Martinez. All rights reserved.
-// Copyright 2017 Roman Lebedev. All rights reserved.
-//
-// 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.
-
-#include "statistics.h"
-
-#include <algorithm>
-#include <cmath>
-#include <numeric>
-#include <string>
-#include <vector>
-
-#include "benchmark/benchmark.h"
-#include "check.h"
-
-namespace benchmark {
-
-auto StatisticsSum = [](const std::vector<double>& v) {
-  return std::accumulate(v.begin(), v.end(), 0.0);
-};
-
-double StatisticsMean(const std::vector<double>& v) {
-  if (v.empty()) return 0.0;
-  return StatisticsSum(v) * (1.0 / v.size());
-}
-
-double StatisticsMedian(const std::vector<double>& v) {
-  if (v.size() < 3) return StatisticsMean(v);
-  std::vector<double> copy(v);
-
-  auto center = copy.begin() + v.size() / 2;
-  std::nth_element(copy.begin(), center, copy.end());
-
-  // Did we have an odd number of samples?  If yes, then center is the median.
-  // If not, then we are looking for the average between center and the value
-  // before.  Instead of resorting, we just look for the max value before it,
-  // which is not necessarily the element immediately preceding `center` Since
-  // `copy` is only partially sorted by `nth_element`.
-  if (v.size() % 2 == 1) return *center;
-  auto center2 = std::max_element(copy.begin(), center);
-  return (*center + *center2) / 2.0;
-}
-
-// Return the sum of the squares of this sample set
-auto SumSquares = [](const std::vector<double>& v) {
-  return std::inner_product(v.begin(), v.end(), v.begin(), 0.0);
-};
-
-auto Sqr = [](const double dat) { return dat * dat; };
-auto Sqrt = [](const double dat) {
-  // Avoid NaN due to imprecision in the calculations
-  if (dat < 0.0) return 0.0;
-  return std::sqrt(dat);
-};
-
-double StatisticsStdDev(const std::vector<double>& v) {
-  const auto mean = StatisticsMean(v);
-  if (v.empty()) return mean;
-
-  // Sample standard deviation is undefined for n = 1
-  if (v.size() == 1) return 0.0;
-
-  const double avg_squares = SumSquares(v) * (1.0 / v.size());
-  return Sqrt(v.size() / (v.size() - 1.0) * (avg_squares - Sqr(mean)));
-}
-
-double StatisticsCV(const std::vector<double>& v) {
-  if (v.size() < 2) return 0.0;
-
-  const auto stddev = StatisticsStdDev(v);
-  const auto mean = StatisticsMean(v);
-
-  return stddev / mean;
-}
-
-std::vector<BenchmarkReporter::Run> ComputeStats(
-    const std::vector<BenchmarkReporter::Run>& reports) {
-  typedef BenchmarkReporter::Run Run;
-  std::vector<Run> results;
-
-  auto error_count = std::count_if(reports.begin(), reports.end(),
-                                   [](Run const& run) { return run.skipped; });
-
-  if (reports.size() - error_count < 2) {
-    // We don't report aggregated data if there was a single run.
-    return results;
-  }
-
-  // Accumulators.
-  std::vector<double> real_accumulated_time_stat;
-  std::vector<double> cpu_accumulated_time_stat;
-
-  real_accumulated_time_stat.reserve(reports.size());
-  cpu_accumulated_time_stat.reserve(reports.size());
-
-  // All repetitions should be run with the same number of iterations so we
-  // can take this information from the first benchmark.
-  const IterationCount run_iterations = reports.front().iterations;
-  // create stats for user counters
-  struct CounterStat {
-    Counter c;
-    std::vector<double> s;
-  };
-  std::map<std::string, CounterStat> counter_stats;
-  for (Run const& r : reports) {
-    for (auto const& cnt : r.counters) {
-      auto it = counter_stats.find(cnt.first);
-      if (it == counter_stats.end()) {
-        it = counter_stats
-                 .emplace(cnt.first,
-                          CounterStat{cnt.second, std::vector<double>{}})
-                 .first;
-        it->second.s.reserve(reports.size());
-      } else {
-        BM_CHECK_EQ(it->second.c.flags, cnt.second.flags);
-      }
-    }
-  }
-
-  // Populate the accumulators.
-  for (Run const& run : reports) {
-    BM_CHECK_EQ(reports[0].benchmark_name(), run.benchmark_name());
-    BM_CHECK_EQ(run_iterations, run.iterations);
-    if (run.skipped) continue;
-    real_accumulated_time_stat.emplace_back(run.real_accumulated_time);
-    cpu_accumulated_time_stat.emplace_back(run.cpu_accumulated_time);
-    // user counters
-    for (auto const& cnt : run.counters) {
-      auto it = counter_stats.find(cnt.first);
-      BM_CHECK_NE(it, counter_stats.end());
-      it->second.s.emplace_back(cnt.second);
-    }
-  }
-
-  // Only add label if it is same for all runs
-  std::string report_label = reports[0].report_label;
-  for (std::size_t i = 1; i < reports.size(); i++) {
-    if (reports[i].report_label != report_label) {
-      report_label = "";
-      break;
-    }
-  }
-
-  const double iteration_rescale_factor =
-      double(reports.size()) / double(run_iterations);
-
-  for (const auto& Stat : *reports[0].statistics) {
-    // Get the data from the accumulator to BenchmarkReporter::Run's.
-    Run data;
-    data.run_name = reports[0].run_name;
-    data.family_index = reports[0].family_index;
-    data.per_family_instance_index = reports[0].per_family_instance_index;
-    data.run_type = BenchmarkReporter::Run::RT_Aggregate;
-    data.threads = reports[0].threads;
-    data.repetitions = reports[0].repetitions;
-    data.repetition_index = Run::no_repetition_index;
-    data.aggregate_name = Stat.name_;
-    data.aggregate_unit = Stat.unit_;
-    data.report_label = report_label;
-
-    // It is incorrect to say that an aggregate is computed over
-    // run's iterations, because those iterations already got averaged.
-    // Similarly, if there are N repetitions with 1 iterations each,
-    // an aggregate will be computed over N measurements, not 1.
-    // Thus it is best to simply use the count of separate reports.
-    data.iterations = reports.size();
-
-    data.real_accumulated_time = Stat.compute_(real_accumulated_time_stat);
-    data.cpu_accumulated_time = Stat.compute_(cpu_accumulated_time_stat);
-
-    if (data.aggregate_unit == StatisticUnit::kTime) {
-      // We will divide these times by data.iterations when reporting, but the
-      // data.iterations is not necessarily the scale of these measurements,
-      // because in each repetition, these timers are sum over all the iters.
-      // And if we want to say that the stats are over N repetitions and not
-      // M iterations, we need to multiply these by (N/M).
-      data.real_accumulated_time *= iteration_rescale_factor;
-      data.cpu_accumulated_time *= iteration_rescale_factor;
-    }
-
-    data.time_unit = reports[0].time_unit;
-
-    // user counters
-    for (auto const& kv : counter_stats) {
-      // Do *NOT* rescale the custom counters. They are already properly scaled.
-      const auto uc_stat = Stat.compute_(kv.second.s);
-      auto c = Counter(uc_stat, counter_stats[kv.first].c.flags,
-                       counter_stats[kv.first].c.oneK);
-      data.counters[kv.first] = c;
-    }
-
-    results.push_back(data);
-  }
-
-  return results;
-}
-
-}  // end namespace benchmark

package/build/_deps/benchmark-src/src/statistics.h

@@ -1,44 +0,0 @@
-// Copyright 2016 Ismael Jimenez Martinez. All rights reserved.
-// Copyright 2017 Roman Lebedev. All rights reserved.
-//
-// 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.
-
-#ifndef STATISTICS_H_
-#define STATISTICS_H_
-
-#include <vector>
-
-#include "benchmark/benchmark.h"
-
-namespace benchmark {
-
-// Return a vector containing the mean, median and standard deviation
-// information (and any user-specified info) for the specified list of reports.
-// If 'reports' contains less than two non-errored runs an empty vector is
-// returned
-BENCHMARK_EXPORT
-std::vector<BenchmarkReporter::Run> ComputeStats(
-    const std::vector<BenchmarkReporter::Run>& reports);
-
-BENCHMARK_EXPORT
-double StatisticsMean(const std::vector<double>& v);
-BENCHMARK_EXPORT
-double StatisticsMedian(const std::vector<double>& v);
-BENCHMARK_EXPORT
-double StatisticsStdDev(const std::vector<double>& v);
-BENCHMARK_EXPORT
-double StatisticsCV(const std::vector<double>& v);
-
-}  // end namespace benchmark
-
-#endif  // STATISTICS_H_

package/build/_deps/benchmark-src/src/string_util.cc

@@ -1,254 +0,0 @@
-#include "string_util.h"
-
-#include <array>
-#ifdef BENCHMARK_STL_ANDROID_GNUSTL
-#include <cerrno>
-#endif
-#include <cmath>
-#include <cstdarg>
-#include <cstdio>
-#include <memory>
-#include <sstream>
-
-#include "arraysize.h"
-#include "benchmark/benchmark.h"
-
-namespace benchmark {
-namespace {
-// kilo, Mega, Giga, Tera, Peta, Exa, Zetta, Yotta.
-const char* const kBigSIUnits[] = {"k", "M", "G", "T", "P", "E", "Z", "Y"};
-// Kibi, Mebi, Gibi, Tebi, Pebi, Exbi, Zebi, Yobi.
-const char* const kBigIECUnits[] = {"Ki", "Mi", "Gi", "Ti",
-                                    "Pi", "Ei", "Zi", "Yi"};
-// milli, micro, nano, pico, femto, atto, zepto, yocto.
-const char* const kSmallSIUnits[] = {"m", "u", "n", "p", "f", "a", "z", "y"};
-
-// We require that all three arrays have the same size.
-static_assert(arraysize(kBigSIUnits) == arraysize(kBigIECUnits),
-              "SI and IEC unit arrays must be the same size");
-static_assert(arraysize(kSmallSIUnits) == arraysize(kBigSIUnits),
-              "Small SI and Big SI unit arrays must be the same size");
-
-static const int64_t kUnitsSize = arraysize(kBigSIUnits);
-
-void ToExponentAndMantissa(double val, int precision, double one_k,
-                           std::string* mantissa, int64_t* exponent) {
-  std::stringstream mantissa_stream;
-
-  if (val < 0) {
-    mantissa_stream << "-";
-    val = -val;
-  }
-
-  // Adjust threshold so that it never excludes things which can't be rendered
-  // in 'precision' digits.
-  const double adjusted_threshold =
-      std::max(1.0, 1.0 / std::pow(10.0, precision));
-  const double big_threshold = (adjusted_threshold * one_k) - 1;
-  const double small_threshold = adjusted_threshold;
-  // Values in ]simple_threshold,small_threshold[ will be printed as-is
-  const double simple_threshold = 0.01;
-
-  if (val > big_threshold) {
-    // Positive powers
-    double scaled = val;
-    for (size_t i = 0; i < arraysize(kBigSIUnits); ++i) {
-      scaled /= one_k;
-      if (scaled <= big_threshold) {
-        mantissa_stream << scaled;
-        *exponent = i + 1;
-        *mantissa = mantissa_stream.str();
-        return;
-      }
-    }
-    mantissa_stream << val;
-    *exponent = 0;
-  } else if (val < small_threshold) {
-    // Negative powers
-    if (val < simple_threshold) {
-      double scaled = val;
-      for (size_t i = 0; i < arraysize(kSmallSIUnits); ++i) {
-        scaled *= one_k;
-        if (scaled >= small_threshold) {
-          mantissa_stream << scaled;
-          *exponent = -static_cast<int64_t>(i + 1);
-          *mantissa = mantissa_stream.str();
-          return;
-        }
-      }
-    }
-    mantissa_stream << val;
-    *exponent = 0;
-  } else {
-    mantissa_stream << val;
-    *exponent = 0;
-  }
-  *mantissa = mantissa_stream.str();
-}
-
-std::string ExponentToPrefix(int64_t exponent, bool iec) {
-  if (exponent == 0) return "";
-
-  const int64_t index = (exponent > 0 ? exponent - 1 : -exponent - 1);
-  if (index >= kUnitsSize) return "";
-
-  const char* const* array =
-      (exponent > 0 ? (iec ? kBigIECUnits : kBigSIUnits) : kSmallSIUnits);
-
-  return std::string(array[index]);
-}
-
-std::string ToBinaryStringFullySpecified(double value, int precision,
-                                         Counter::OneK one_k) {
-  std::string mantissa;
-  int64_t exponent;
-  ToExponentAndMantissa(value, precision,
-                        one_k == Counter::kIs1024 ? 1024.0 : 1000.0, &mantissa,
-                        &exponent);
-  return mantissa + ExponentToPrefix(exponent, one_k == Counter::kIs1024);
-}
-
-std::string StrFormatImp(const char* msg, va_list args) {
-  // we might need a second shot at this, so pre-emptivly make a copy
-  va_list args_cp;
-  va_copy(args_cp, args);
-
-  // TODO(ericwf): use std::array for first attempt to avoid one memory
-  // allocation guess what the size might be
-  std::array<char, 256> local_buff;
-
-  // 2015-10-08: vsnprintf is used instead of snd::vsnprintf due to a limitation
-  // in the android-ndk
-  auto ret = vsnprintf(local_buff.data(), local_buff.size(), msg, args_cp);
-
-  va_end(args_cp);
-
-  // handle empty expansion
-  if (ret == 0) return std::string{};
-  if (static_cast<std::size_t>(ret) < local_buff.size())
-    return std::string(local_buff.data());
-
-  // we did not provide a long enough buffer on our first attempt.
-  // add 1 to size to account for null-byte in size cast to prevent overflow
-  std::size_t size = static_cast<std::size_t>(ret) + 1;
-  auto buff_ptr = std::unique_ptr<char[]>(new char[size]);
-  // 2015-10-08: vsnprintf is used instead of snd::vsnprintf due to a limitation
-  // in the android-ndk
-  vsnprintf(buff_ptr.get(), size, msg, args);
-  return std::string(buff_ptr.get());
-}
-
-}  // end namespace
-
-std::string HumanReadableNumber(double n, Counter::OneK one_k) {
-  return ToBinaryStringFullySpecified(n, 1, one_k);
-}
-
-std::string StrFormat(const char* format, ...) {
-  va_list args;
-  va_start(args, format);
-  std::string tmp = StrFormatImp(format, args);
-  va_end(args);
-  return tmp;
-}
-
-std::vector<std::string> StrSplit(const std::string& str, char delim) {
-  if (str.empty()) return {};
-  std::vector<std::string> ret;
-  size_t first = 0;
-  size_t next = str.find(delim);
-  for (; next != std::string::npos;
-       first = next + 1, next = str.find(delim, first)) {
-    ret.push_back(str.substr(first, next - first));
-  }
-  ret.push_back(str.substr(first));
-  return ret;
-}
-
-#ifdef BENCHMARK_STL_ANDROID_GNUSTL
-/*
- * GNU STL in Android NDK lacks support for some C++11 functions, including
- * stoul, stoi, stod. We reimplement them here using C functions strtoul,
- * strtol, strtod. Note that reimplemented functions are in benchmark::
- * namespace, not std:: namespace.
- */
-unsigned long stoul(const std::string& str, size_t* pos, int base) {
-  /* Record previous errno */
-  const int oldErrno = errno;
-  errno = 0;
-
-  const char* strStart = str.c_str();
-  char* strEnd = const_cast<char*>(strStart);
-  const unsigned long result = strtoul(strStart, &strEnd, base);
-
-  const int strtoulErrno = errno;
-  /* Restore previous errno */
-  errno = oldErrno;
-
-  /* Check for errors and return */
-  if (strtoulErrno == ERANGE) {
-    throw std::out_of_range("stoul failed: " + str +
-                            " is outside of range of unsigned long");
-  } else if (strEnd == strStart || strtoulErrno != 0) {
-    throw std::invalid_argument("stoul failed: " + str + " is not an integer");
-  }
-  if (pos != nullptr) {
-    *pos = static_cast<size_t>(strEnd - strStart);
-  }
-  return result;
-}
-
-int stoi(const std::string& str, size_t* pos, int base) {
-  /* Record previous errno */
-  const int oldErrno = errno;
-  errno = 0;
-
-  const char* strStart = str.c_str();
-  char* strEnd = const_cast<char*>(strStart);
-  const long result = strtol(strStart, &strEnd, base);
-
-  const int strtolErrno = errno;
-  /* Restore previous errno */
-  errno = oldErrno;
-
-  /* Check for errors and return */
-  if (strtolErrno == ERANGE || long(int(result)) != result) {
-    throw std::out_of_range("stoul failed: " + str +
-                            " is outside of range of int");
-  } else if (strEnd == strStart || strtolErrno != 0) {
-    throw std::invalid_argument("stoul failed: " + str + " is not an integer");
-  }
-  if (pos != nullptr) {
-    *pos = static_cast<size_t>(strEnd - strStart);
-  }
-  return int(result);
-}
-
-double stod(const std::string& str, size_t* pos) {
-  /* Record previous errno */
-  const int oldErrno = errno;
-  errno = 0;
-
-  const char* strStart = str.c_str();
-  char* strEnd = const_cast<char*>(strStart);
-  const double result = strtod(strStart, &strEnd);
-
-  /* Restore previous errno */
-  const int strtodErrno = errno;
-  errno = oldErrno;
-
-  /* Check for errors and return */
-  if (strtodErrno == ERANGE) {
-    throw std::out_of_range("stoul failed: " + str +
-                            " is outside of range of int");
-  } else if (strEnd == strStart || strtodErrno != 0) {
-    throw std::invalid_argument("stoul failed: " + str + " is not an integer");
-  }
-  if (pos != nullptr) {
-    *pos = static_cast<size_t>(strEnd - strStart);
-  }
-  return result;
-}
-#endif
-
-}  // end namespace benchmark

package/build/_deps/benchmark-src/src/string_util.h

@@ -1,70 +0,0 @@
-#ifndef BENCHMARK_STRING_UTIL_H_
-#define BENCHMARK_STRING_UTIL_H_
-
-#include <sstream>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "benchmark/benchmark.h"
-#include "benchmark/export.h"
-#include "check.h"
-#include "internal_macros.h"
-
-namespace benchmark {
-
-BENCHMARK_EXPORT
-std::string HumanReadableNumber(double n, Counter::OneK one_k);
-
-BENCHMARK_EXPORT
-#if defined(__MINGW32__)
-__attribute__((format(__MINGW_PRINTF_FORMAT, 1, 2)))
-#elif defined(__GNUC__)
-__attribute__((format(printf, 1, 2)))
-#endif
-std::string
-StrFormat(const char* format, ...);
-
-inline std::ostream& StrCatImp(std::ostream& out) BENCHMARK_NOEXCEPT {
-  return out;
-}
-
-template <class First, class... Rest>
-inline std::ostream& StrCatImp(std::ostream& out, First&& f, Rest&&... rest) {
-  out << std::forward<First>(f);
-  return StrCatImp(out, std::forward<Rest>(rest)...);
-}
-
-template <class... Args>
-inline std::string StrCat(Args&&... args) {
-  std::ostringstream ss;
-  StrCatImp(ss, std::forward<Args>(args)...);
-  return ss.str();
-}
-
-BENCHMARK_EXPORT
-std::vector<std::string> StrSplit(const std::string& str, char delim);
-
-// Disable lint checking for this block since it re-implements C functions.
-// NOLINTBEGIN
-#ifdef BENCHMARK_STL_ANDROID_GNUSTL
-/*
- * GNU STL in Android NDK lacks support for some C++11 functions, including
- * stoul, stoi, stod. We reimplement them here using C functions strtoul,
- * strtol, strtod. Note that reimplemented functions are in benchmark::
- * namespace, not std:: namespace.
- */
-unsigned long stoul(const std::string& str, size_t* pos = nullptr,
-                    int base = 10);
-int stoi(const std::string& str, size_t* pos = nullptr, int base = 10);
-double stod(const std::string& str, size_t* pos = nullptr);
-#else
-using std::stod;   // NOLINT(misc-unused-using-decls)
-using std::stoi;   // NOLINT(misc-unused-using-decls)
-using std::stoul;  // NOLINT(misc-unused-using-decls)
-#endif
-// NOLINTEND
-
-}  // end namespace benchmark
-
-#endif  // BENCHMARK_STRING_UTIL_H_