OmniSciDB  04ee39c94c
Importer_NS::Detector Class Reference

#include <Importer.h>

+ Inheritance diagram for Importer_NS::Detector:
+ Collaboration diagram for Importer_NS::Detector:

Public Member Functions

 Detector (const boost::filesystem::path &fp, CopyParams &cp)
 
std::vector< std::string > get_headers ()
 
std::vector< std::vector< std::string > > get_sample_rows (size_t n)
 
- Public Member Functions inherited from Importer_NS::DataStreamSink
 DataStreamSink ()
 
 DataStreamSink (const CopyParams &copy_params, const std::string file_path)
 
virtual ~DataStreamSink ()
 
const CopyParamsget_copy_params () const
 
void import_compressed (std::vector< std::string > &file_paths)
 

Static Public Member Functions

static SQLTypes detect_sqltype (const std::string &str)
 

Public Attributes

std::vector< std::vector< std::string > > raw_rows
 
std::vector< SQLTypesbest_sqltypes
 
std::vector< EncodingTypebest_encodings
 
bool has_headers = false
 

Private Member Functions

void init ()
 
void read_file ()
 
void detect_row_delimiter ()
 
void split_raw_data ()
 
std::vector< SQLTypesdetect_column_types (const std::vector< std::string > &row)
 
void find_best_sqltypes ()
 
std::vector< SQLTypesfind_best_sqltypes (const std::vector< std::vector< std::string >> &raw_rows, const CopyParams &copy_params)
 
std::vector< SQLTypesfind_best_sqltypes (const std::vector< std::vector< std::string >>::const_iterator &row_begin, const std::vector< std::vector< std::string >>::const_iterator &row_end, const CopyParams &copy_params)
 
std::vector< EncodingTypefind_best_encodings (const std::vector< std::vector< std::string >>::const_iterator &row_begin, const std::vector< std::vector< std::string >>::const_iterator &row_end, const std::vector< SQLTypes > &best_types)
 
bool detect_headers (const std::vector< SQLTypes > &first_types, const std::vector< SQLTypes > &rest_types)
 
void find_best_sqltypes_and_headers ()
 
ImportStatus importDelimited (const std::string &file_path, const bool decompressed) override
 

Static Private Member Functions

static bool more_restrictive_sqltype (const SQLTypes a, const SQLTypes b)
 

Private Attributes

std::string raw_data
 
boost::filesystem::path file_path
 
std::chrono::duration< double > timeout {1}
 
std::string line1
 

Additional Inherited Members

- Protected Member Functions inherited from Importer_NS::DataStreamSink
ImportStatus archivePlumber ()
 
- Protected Attributes inherited from Importer_NS::DataStreamSink
CopyParams copy_params
 
const std::string file_path
 
FILE * p_file = nullptr
 
ImportStatus import_status
 
bool load_failed = false
 
size_t total_file_size {0}
 
std::vector< size_t > file_offsets
 
std::mutex file_offsets_mutex
 

Detailed Description

Definition at line 762 of file Importer.h.

Constructor & Destructor Documentation

◆ Detector()

Importer_NS::Detector::Detector ( const boost::filesystem::path &  fp,
CopyParams cp 
)
inline

Definition at line 764 of file Importer.h.

References logger::init().

765  : DataStreamSink(cp, fp.string()), file_path(fp) {
766  read_file();
767  init();
768  };
boost::filesystem::path file_path
Definition: Importer.h:807
+ Here is the call graph for this function:

Member Function Documentation

◆ detect_column_types()

std::vector< SQLTypes > Importer_NS::Detector::detect_column_types ( const std::vector< std::string > &  row)
private

Definition at line 2845 of file Importer.cpp.

2845  {
2846  std::vector<SQLTypes> types(row.size());
2847  for (size_t i = 0; i < row.size(); i++) {
2848  types[i] = detect_sqltype(row[i]);
2849  }
2850  return types;
2851 }
static SQLTypes detect_sqltype(const std::string &str)
Definition: Importer.cpp:2768

◆ detect_headers()

bool Importer_NS::Detector::detect_headers ( const std::vector< SQLTypes > &  first_types,
const std::vector< SQLTypes > &  rest_types 
)
private

Definition at line 2987 of file Importer.cpp.

References kTEXT.

2988  {
2989  if (head_types.size() != tail_types.size()) {
2990  return false;
2991  }
2992  bool has_headers = false;
2993  for (size_t col_idx = 0; col_idx < tail_types.size(); col_idx++) {
2994  if (head_types[col_idx] != kTEXT) {
2995  return false;
2996  }
2997  has_headers = has_headers || tail_types[col_idx] != kTEXT;
2998  }
2999  return has_headers;
3000 }
Definition: sqltypes.h:54

◆ detect_row_delimiter()

void Importer_NS::Detector::detect_row_delimiter ( )
private

Definition at line 2713 of file Importer.cpp.

References Importer_NS::DataStreamSink::copy_params, Importer_NS::CopyParams::delimiter, and Importer_NS::DataStreamSink::file_path.

2713  {
2714  if (copy_params.delimiter == '\0') {
2715  copy_params.delimiter = ',';
2716  if (boost::filesystem::extension(file_path) == ".tsv") {
2717  copy_params.delimiter = '\t';
2718  }
2719  }
2720 }
boost::filesystem::path file_path
Definition: Importer.h:807

◆ detect_sqltype()

SQLTypes Importer_NS::Detector::detect_sqltype ( const std::string &  str)
static

Definition at line 2768 of file Importer.cpp.

References kBIGINT, kDATE, kDOUBLE, kFLOAT, kINT, kLINESTRING, kMULTIPOLYGON, kPOINT, kPOLYGON, kSMALLINT, kTEXT, kTIME, kTIMESTAMP, Importer_NS::try_strptimes(), and run-benchmark-import::type.

Referenced by anonymous_namespace{ImportTest.cpp}::d().

2768  {
2769  SQLTypes type = kTEXT;
2770  if (try_cast<double>(str)) {
2771  type = kDOUBLE;
2772  /*if (try_cast<bool>(str)) {
2773  type = kBOOLEAN;
2774  }*/
2775  if (try_cast<int16_t>(str)) {
2776  type = kSMALLINT;
2777  } else if (try_cast<int32_t>(str)) {
2778  type = kINT;
2779  } else if (try_cast<int64_t>(str)) {
2780  type = kBIGINT;
2781  } else if (try_cast<float>(str)) {
2782  type = kFLOAT;
2783  }
2784  }
2785 
2786  // check for geo types
2787  if (type == kTEXT) {
2788  // convert to upper case
2789  std::string str_upper_case = str;
2790  std::transform(
2791  str_upper_case.begin(), str_upper_case.end(), str_upper_case.begin(), ::toupper);
2792 
2793  // then test for leading words
2794  if (str_upper_case.find("POINT") == 0) {
2795  type = kPOINT;
2796  } else if (str_upper_case.find("LINESTRING") == 0) {
2797  type = kLINESTRING;
2798  } else if (str_upper_case.find("POLYGON") == 0) {
2800  type = kMULTIPOLYGON;
2801  } else {
2802  type = kPOLYGON;
2803  }
2804  } else if (str_upper_case.find("MULTIPOLYGON") == 0) {
2805  type = kMULTIPOLYGON;
2806  } else if (str_upper_case.find_first_not_of("0123456789ABCDEF") ==
2807  std::string::npos &&
2808  (str_upper_case.size() % 2) == 0) {
2809  // could be a WKB hex blob
2810  // we can't handle these yet
2811  // leave as TEXT for now
2812  // deliberate return here, as otherwise this would get matched as TIME
2813  // @TODO
2814  // implement WKB import
2815  return type;
2816  }
2817  }
2818 
2819  // check for time types
2820  if (type == kTEXT) {
2821  // @TODO
2822  // make these tests more robust so they don't match stuff they should not
2823  char* buf;
2824  buf = try_strptimes(str.c_str(), {"%Y-%m-%d", "%m/%d/%Y", "%d-%b-%y", "%d/%b/%Y"});
2825  if (buf) {
2826  type = kDATE;
2827  if (*buf == 'T' || *buf == ' ' || *buf == ':') {
2828  buf++;
2829  }
2830  }
2831  buf = try_strptimes(buf == nullptr ? str.c_str() : buf,
2832  {"%T %z", "%T", "%H%M%S", "%R"});
2833  if (buf) {
2834  if (type == kDATE) {
2835  type = kTIMESTAMP;
2836  } else {
2837  type = kTIME;
2838  }
2839  }
2840  }
2841 
2842  return type;
2843 }
Definition: sqltypes.h:51
SQLTypes
Definition: sqltypes.h:40
char * try_strptimes(const char *str, const std::vector< std::string > &formats)
Definition: Importer.cpp:2756
Definition: sqltypes.h:54
Definition: sqltypes.h:55
Definition: sqltypes.h:47
static constexpr bool PROMOTE_POLYGON_TO_MULTIPOLYGON
Definition: Importer.cpp:141
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ find_best_encodings()

std::vector< EncodingType > Importer_NS::Detector::find_best_encodings ( const std::vector< std::vector< std::string >>::const_iterator &  row_begin,
const std::vector< std::vector< std::string >>::const_iterator &  row_end,
const std::vector< SQLTypes > &  best_types 
)
private

Definition at line 2951 of file Importer.cpp.

References Importer_NS::DataStreamSink::file_path, IS_STRING, kENCODING_DICT, and kENCODING_NONE.

2954  {
2955  if (raw_rows.size() < 1) {
2956  throw std::runtime_error("No rows found in: " +
2957  boost::filesystem::basename(file_path));
2958  }
2959  size_t num_cols = best_types.size();
2960  std::vector<EncodingType> best_encodes(num_cols, kENCODING_NONE);
2961  std::vector<size_t> num_rows_per_col(num_cols, 1);
2962  std::vector<std::unordered_set<std::string>> count_set(num_cols);
2963  for (auto row = row_begin; row != row_end; row++) {
2964  for (size_t col_idx = 0; col_idx < row->size() && col_idx < num_cols; col_idx++) {
2965  if (IS_STRING(best_types[col_idx])) {
2966  count_set[col_idx].insert(row->at(col_idx));
2967  num_rows_per_col[col_idx]++;
2968  }
2969  }
2970  }
2971  for (size_t col_idx = 0; col_idx < num_cols; col_idx++) {
2972  if (IS_STRING(best_types[col_idx])) {
2973  float uniqueRatio =
2974  static_cast<float>(count_set[col_idx].size()) / num_rows_per_col[col_idx];
2975  if (uniqueRatio < 0.75) {
2976  best_encodes[col_idx] = kENCODING_DICT;
2977  }
2978  }
2979  }
2980  return best_encodes;
2981 }
boost::filesystem::path file_path
Definition: Importer.h:807
std::vector< std::vector< std::string > > raw_rows
Definition: Importer.h:774
#define IS_STRING(T)
Definition: sqltypes.h:163

◆ find_best_sqltypes() [1/3]

void Importer_NS::Detector::find_best_sqltypes ( )
private

Definition at line 2898 of file Importer.cpp.

References Importer_NS::DataStreamSink::copy_params.

2898  {
2900 }
std::vector< std::vector< std::string > > raw_rows
Definition: Importer.h:774
std::vector< SQLTypes > best_sqltypes
Definition: Importer.h:776

◆ find_best_sqltypes() [2/3]

std::vector< SQLTypes > Importer_NS::Detector::find_best_sqltypes ( const std::vector< std::vector< std::string >> &  raw_rows,
const CopyParams copy_params 
)
private

Definition at line 2902 of file Importer.cpp.

References Importer_NS::DataStreamSink::copy_params.

2904  {
2905  return find_best_sqltypes(raw_rows.begin(), raw_rows.end(), copy_params);
2906 }
std::vector< std::vector< std::string > > raw_rows
Definition: Importer.h:774

◆ find_best_sqltypes() [3/3]

std::vector< SQLTypes > Importer_NS::Detector::find_best_sqltypes ( const std::vector< std::vector< std::string >>::const_iterator &  row_begin,
const std::vector< std::vector< std::string >>::const_iterator &  row_end,
const CopyParams copy_params 
)
private

Definition at line 2908 of file Importer.cpp.

References run-benchmark-import::end_time, Importer_NS::DataStreamSink::file_path, kCHAR, kTEXT, and Importer_NS::CopyParams::null_str.

2911  {
2912  if (raw_rows.size() < 1) {
2913  throw std::runtime_error("No rows found in: " +
2914  boost::filesystem::basename(file_path));
2915  }
2916  auto end_time = std::chrono::steady_clock::now() + timeout;
2917  size_t num_cols = raw_rows.front().size();
2918  std::vector<SQLTypes> best_types(num_cols, kCHAR);
2919  std::vector<size_t> non_null_col_counts(num_cols, 0);
2920  for (auto row = row_begin; row != row_end; row++) {
2921  while (best_types.size() < row->size() || non_null_col_counts.size() < row->size()) {
2922  best_types.push_back(kCHAR);
2923  non_null_col_counts.push_back(0);
2924  }
2925  for (size_t col_idx = 0; col_idx < row->size(); col_idx++) {
2926  // do not count nulls
2927  if (row->at(col_idx) == "" || !row->at(col_idx).compare(copy_params.null_str)) {
2928  continue;
2929  }
2930  SQLTypes t = detect_sqltype(row->at(col_idx));
2931  non_null_col_counts[col_idx]++;
2932  if (!more_restrictive_sqltype(best_types[col_idx], t)) {
2933  best_types[col_idx] = t;
2934  }
2935  }
2936  if (std::chrono::steady_clock::now() > end_time) {
2937  break;
2938  }
2939  }
2940  for (size_t col_idx = 0; col_idx < num_cols; col_idx++) {
2941  // if we don't have any non-null values for this column make it text to be
2942  // safe b/c that is least restrictive type
2943  if (non_null_col_counts[col_idx] == 0) {
2944  best_types[col_idx] = kTEXT;
2945  }
2946  }
2947 
2948  return best_types;
2949 }
std::chrono::duration< double > timeout
Definition: Importer.h:808
SQLTypes
Definition: sqltypes.h:40
static SQLTypes detect_sqltype(const std::string &str)
Definition: Importer.cpp:2768
std::string null_str
boost::filesystem::path file_path
Definition: Importer.h:807
Definition: sqltypes.h:54
static bool more_restrictive_sqltype(const SQLTypes a, const SQLTypes b)
Definition: Importer.cpp:2853
std::vector< std::vector< std::string > > raw_rows
Definition: Importer.h:774
Definition: sqltypes.h:43

◆ find_best_sqltypes_and_headers()

void Importer_NS::Detector::find_best_sqltypes_and_headers ( )
private

Definition at line 2875 of file Importer.cpp.

References Importer_NS::AUTODETECT, Importer_NS::DataStreamSink::copy_params, Importer_NS::HAS_HEADER, Importer_NS::CopyParams::has_header, and Importer_NS::NO_HEADER.

2875  {
2877  best_encodings =
2878  find_best_encodings(raw_rows.begin() + 1, raw_rows.end(), best_sqltypes);
2879  std::vector<SQLTypes> head_types = detect_column_types(raw_rows.at(0));
2880  switch (copy_params.has_header) {
2882  has_headers = detect_headers(head_types, best_sqltypes);
2883  if (has_headers) {
2885  } else {
2887  }
2888  break;
2890  has_headers = false;
2891  break;
2893  has_headers = true;
2894  break;
2895  }
2896 }
std::vector< EncodingType > find_best_encodings(const std::vector< std::vector< std::string >>::const_iterator &row_begin, const std::vector< std::vector< std::string >>::const_iterator &row_end, const std::vector< SQLTypes > &best_types)
Definition: Importer.cpp:2951
std::vector< EncodingType > best_encodings
Definition: Importer.h:777
ImportHeaderRow has_header
Definition: Importer.h:101
std::vector< SQLTypes > detect_column_types(const std::vector< std::string > &row)
Definition: Importer.cpp:2845
std::vector< std::vector< std::string > > raw_rows
Definition: Importer.h:774
bool detect_headers(const std::vector< SQLTypes > &first_types, const std::vector< SQLTypes > &rest_types)
Definition: Importer.cpp:2987
std::vector< SQLTypes > best_sqltypes
Definition: Importer.h:776

◆ get_headers()

std::vector< std::string > Importer_NS::Detector::get_headers ( )

Definition at line 3010 of file Importer.cpp.

References to_string().

Referenced by MapDHandler::detect_column_types().

3010  {
3011  std::vector<std::string> headers(best_sqltypes.size());
3012  for (size_t i = 0; i < best_sqltypes.size(); i++) {
3013  if (has_headers && i < raw_rows[0].size()) {
3014  headers[i] = raw_rows[0][i];
3015  } else {
3016  headers[i] = "column_" + std::to_string(i + 1);
3017  }
3018  }
3019  return headers;
3020 }
std::string to_string(char const *&&v)
std::vector< std::vector< std::string > > raw_rows
Definition: Importer.h:774
std::vector< SQLTypes > best_sqltypes
Definition: Importer.h:776
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ get_sample_rows()

std::vector< std::vector< std::string > > Importer_NS::Detector::get_sample_rows ( size_t  n)

Definition at line 3002 of file Importer.cpp.

Referenced by MapDHandler::detect_column_types().

3002  {
3003  n = std::min(n, raw_rows.size());
3004  size_t offset = (has_headers && raw_rows.size() > 1) ? 1 : 0;
3005  std::vector<std::vector<std::string>> sample_rows(raw_rows.begin() + offset,
3006  raw_rows.begin() + n);
3007  return sample_rows;
3008 }
std::vector< std::vector< std::string > > raw_rows
Definition: Importer.h:774
+ Here is the caller graph for this function:

◆ importDelimited()

ImportStatus Importer_NS::Detector::importDelimited ( const std::string &  file_path,
const bool  decompressed 
)
overrideprivatevirtual

Implements Importer_NS::DataStreamSink.

Definition at line 2648 of file Importer.cpp.

References anonymous_namespace{ExecuteTest.cpp}::c(), Importer_NS::DataStreamSink::copy_params, run-benchmark-import::end_time, Importer_NS::DataStreamSink::import_status, Importer_NS::CopyParams::line_delim, Importer_NS::DataStreamSink::load_failed, Importer_NS::ImportStatus::load_truncated, Importer_NS::DataStreamSink::p_file, and Importer_NS::ImportStatus::rows_completed.

2649  {
2650  if (!p_file) {
2651  p_file = fopen(file_path.c_str(), "rb");
2652  }
2653  if (!p_file) {
2654  throw std::runtime_error("failed to open file '" + file_path +
2655  "': " + strerror(errno));
2656  }
2657 
2658  // somehow clang does not support ext/stdio_filebuf.h, so
2659  // need to diy readline with customized copy_params.line_delim...
2660  char line[1 << 20];
2661  auto end_time = std::chrono::steady_clock::now() +
2662  timeout * (boost::istarts_with(file_path, "s3://") ? 3 : 1);
2663  try {
2664  while (!feof(p_file)) {
2665  int c;
2666  size_t n = 0;
2667  while (EOF != (c = fgetc(p_file)) && copy_params.line_delim != c) {
2668  line[n++] = c;
2669  if (n >= sizeof(line) - 1) {
2670  break;
2671  }
2672  }
2673  if (0 == n) {
2674  break;
2675  }
2676  line[n] = 0;
2677  // remember the first line, which is possibly a header line, to
2678  // ignore identical header line(s) in 2nd+ files of a archive;
2679  // otherwise, 2nd+ header may be mistaken as an all-string row
2680  // and so be final column types.
2681  if (line1.empty()) {
2682  line1 = line;
2683  } else if (line == line1) {
2684  continue;
2685  }
2686 
2687  raw_data += std::string(line, n);
2690  if (std::chrono::steady_clock::now() > end_time) {
2691  if (import_status.rows_completed > 10000) {
2692  break;
2693  }
2694  }
2695  }
2696  } catch (std::exception& e) {
2697  }
2698 
2699  // as if load truncated
2701  load_failed = true;
2702 
2703  fclose(p_file);
2704  p_file = nullptr;
2705  return import_status;
2706 }
std::chrono::duration< double > timeout
Definition: Importer.h:808
void c(const std::string &query_string, const ExecutorDeviceType device_type)
std::string line1
Definition: Importer.h:809
std::string raw_data
Definition: Importer.h:806
boost::filesystem::path file_path
Definition: Importer.h:807
ImportStatus import_status
Definition: Importer.h:755
+ Here is the call graph for this function:

◆ init()

void Importer_NS::Detector::init ( )
private

Definition at line 2642 of file Importer.cpp.

2642  {
2644  split_raw_data();
2646 }
void find_best_sqltypes_and_headers()
Definition: Importer.cpp:2875

◆ more_restrictive_sqltype()

bool Importer_NS::Detector::more_restrictive_sqltype ( const SQLTypes  a,
const SQLTypes  b 
)
staticprivate

Definition at line 2853 of file Importer.cpp.

References kBIGINT, kBOOLEAN, kCHAR, kDATE, kDOUBLE, kFLOAT, kINT, kLINESTRING, kMULTIPOLYGON, kPOINT, kPOLYGON, kSMALLINT, kTEXT, kTIME, and kTIMESTAMP.

2853  {
2854  static std::array<int, kSQLTYPE_LAST> typeorder;
2855  typeorder[kCHAR] = 0;
2856  typeorder[kBOOLEAN] = 2;
2857  typeorder[kSMALLINT] = 3;
2858  typeorder[kINT] = 4;
2859  typeorder[kBIGINT] = 5;
2860  typeorder[kFLOAT] = 6;
2861  typeorder[kDOUBLE] = 7;
2862  typeorder[kTIMESTAMP] = 8;
2863  typeorder[kTIME] = 9;
2864  typeorder[kDATE] = 10;
2865  typeorder[kPOINT] = 11;
2866  typeorder[kLINESTRING] = 11;
2867  typeorder[kPOLYGON] = 11;
2868  typeorder[kMULTIPOLYGON] = 11;
2869  typeorder[kTEXT] = 12;
2870 
2871  // note: b < a instead of a < b because the map is ordered most to least restrictive
2872  return typeorder[b] < typeorder[a];
2873 }
Definition: sqltypes.h:51
Definition: sqltypes.h:54
Definition: sqltypes.h:55
Definition: sqltypes.h:43
Definition: sqltypes.h:47

◆ read_file()

void Importer_NS::Detector::read_file ( )
private

Definition at line 2708 of file Importer.cpp.

References Importer_NS::DataStreamSink::archivePlumber().

2708  {
2709  // this becomes analogous to Importer::import()
2711 }
ImportStatus archivePlumber()
Definition: Importer.cpp:3058
+ Here is the call graph for this function:

◆ split_raw_data()

void Importer_NS::Detector::split_raw_data ( )
private

Definition at line 2722 of file Importer.cpp.

References Importer_NS::DataStreamSink::copy_params, Importer_NS::get_row(), and Importer_NS::CopyParams::threads.

2722  {
2723  const char* buf = raw_data.c_str();
2724  const char* buf_end = buf + raw_data.size();
2725  bool try_single_thread = false;
2726  for (const char* p = buf; p < buf_end; p++) {
2727  std::vector<std::string> row;
2728  p = get_row(p, buf_end, buf_end, copy_params, true, nullptr, row, try_single_thread);
2729  raw_rows.push_back(row);
2730  if (try_single_thread) {
2731  break;
2732  }
2733  }
2734  if (try_single_thread) {
2735  copy_params.threads = 1;
2736  raw_rows.clear();
2737  for (const char* p = buf; p < buf_end; p++) {
2738  std::vector<std::string> row;
2739  p = get_row(
2740  p, buf_end, buf_end, copy_params, true, nullptr, row, try_single_thread);
2741  raw_rows.push_back(row);
2742  }
2743  }
2744 }
static const char * get_row(const char *buf, const char *buf_end, const char *entire_buf_end, const CopyParams &copy_params, bool is_begin, const bool *is_array, std::vector< std::string > &row, bool &try_single_thread)
Definition: Importer.cpp:238
std::string raw_data
Definition: Importer.h:806
std::vector< std::vector< std::string > > raw_rows
Definition: Importer.h:774
+ Here is the call graph for this function:

Member Data Documentation

◆ best_encodings

std::vector<EncodingType> Importer_NS::Detector::best_encodings

Definition at line 777 of file Importer.h.

Referenced by MapDHandler::detect_column_types().

◆ best_sqltypes

std::vector<SQLTypes> Importer_NS::Detector::best_sqltypes

Definition at line 776 of file Importer.h.

Referenced by MapDHandler::detect_column_types().

◆ file_path

boost::filesystem::path Importer_NS::Detector::file_path
private

Definition at line 807 of file Importer.h.

◆ has_headers

bool Importer_NS::Detector::has_headers = false

Definition at line 778 of file Importer.h.

◆ line1

std::string Importer_NS::Detector::line1
private

Definition at line 809 of file Importer.h.

◆ raw_data

std::string Importer_NS::Detector::raw_data
private

Definition at line 806 of file Importer.h.

◆ raw_rows

std::vector<std::vector<std::string> > Importer_NS::Detector::raw_rows

Definition at line 774 of file Importer.h.

◆ timeout

std::chrono::duration<double> Importer_NS::Detector::timeout {1}
private

Definition at line 808 of file Importer.h.


The documentation for this class was generated from the following files: