csv2 源码剖析：轻量级 CSV 处理的高效之道

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#include "csv2/reader.hpp"
#include <string>

using namespace std;

int main(){
	csv2::Reader<csv2::delimiter<','>,
            csv2::quote_character<'"'>,
            csv2::first_row_is_header<true>,
            csv2::trim_policy::trim_whitespace> csv;


    std::string content = "Name, Age\nPeter, 12\nLucy, 78";
    if(csv.parse(content)){
        const auto header = csv.header();
        for (const auto row: csv) {
            for (const auto cell: row) {
                // Do something with cell value
                std::string value;
                cell.read_value(value);
                cout << value << " ";
            }
            cout << "\n";
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#include "csv2/reader.hpp"
#include <string>

using namespace std;

int main(){
	csv2::Reader<csv2::delimiter<','>,
            csv2::quote_character<'"'>,
            csv2::first_row_is_header<true>,
            csv2::trim_policy::trim_whitespace> csv;

    if(csv.mmap("demo.csv")){
        const auto header = csv.header();
        for (const auto row: csv) {
            for (const auto cell: row) {
                // Do something with cell value
                std::string value;
                cell.read_value(value);
                cout << value << " ";
            }
            cout << "\n";
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

class CellIterator {
      friend class Row;
      const char *buffer_;
      size_t buffer_size_;
      size_t start_;
      size_t current_;
      size_t end_;

    public:
      CellIterator(const char *buffer, size_t buffer_size, size_t start, size_t end)
          : buffer_(buffer), buffer_size_(buffer_size), start_(start), current_(start_), end_(end) {
      }

      CellIterator &operator++() {
        current_ += 1;
        return *this;
      }

      Cell operator*() {
        bool escaped{false};
        class Cell cell;
        cell.buffer_ = buffer_;
        cell.start_ = current_;
        cell.end_ = end_;

        size_t last_quote_location = 0;
        bool quote_opened = false;
        for (auto i = current_; i < end_; i++) {
          current_ = i;
          if (buffer_[i] == delimiter::value && !quote_opened) {
            // actual delimiter
            // end of cell
            cell.end_ = current_;
            cell.escaped_ = escaped;
            return cell;
          } else {
            if (buffer_[i] == quote_character::value) {
              if (!quote_opened) {
                // first quote for this cell
                quote_opened = true;
                last_quote_location = i;
              } else {
                escaped = (last_quote_location == i - 1);
                last_quote_location += (i - last_quote_location) * size_t(!escaped);
                quote_opened = escaped || (buffer_[i + 1] != delimiter::value);
              }
            }
          }
        }
        cell.end_ = current_ + 1;
        return cell;
      }

      bool operator!=(const CellIterator &rhs) { return current_ != rhs.current_; }
    };

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

#include <iostream>

using namespace std;

// forward-declaration to allow use in Iter
class IntVector;

class Iter
{
    public:
    Iter (const IntVector* p_vec, int pos)
        : _pos( pos )
        , _p_vec( p_vec )
    { }

    // these three methods form the basis of an iterator for use with
    // a range-based for loop
    bool
    operator!= (const Iter& other) const
    {
        return _pos != other._pos;
    }

    // this method must be defined after the definition of IntVector
    // since it needs to use it
    int operator* () const;

    const Iter& operator++ ()
    {
        ++_pos;
        // although not strictly necessary for a range-based for loop
        // following the normal convention of returning a value from
        // operator++ is a good idea.
        return *this;
    }

    private:
    int _pos;
    const IntVector *_p_vec;
};

class IntVector
{
    public:
    IntVector ()
    {
    }

    int get (int col) const
    {
        return _data[ col ];
    }
    Iter begin () const
    {
        return Iter( this, 0 );
    }

    Iter end () const
    {
        return Iter( this, 100 );
    }

    void set (int index, int val)
    {
        _data[ index ] = val;
    }

    private:
   int _data[ 100 ];
};

int
Iter::operator* () const
{
     return _p_vec->get( _pos );
}

// sample usage of the range-based for loop on IntVector
int main()
{
    IntVector v;
    for ( int i = 0; i < 100; i++ )
    {
        v.set( i , i );
    }
    for ( int i : v ) { cout << i << endl; }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

#include <csv2/reader.hpp>
#include <csv2/parameters.hpp>
#include <csv2/mio.hpp>
#include <csv2/writer.hpp>
#include <iostream>
#include <ostream>
#include <vector>
#include <string>

using namespace csv2;
using namespace std;

int main() {
	std::ofstream out("info.csv");
	csv2::Writer<csv2::delimiter<','>, std::ofstream> writer(out);
	std::vector<std::string> header = { "Name", "Age" };
	std::vector<std::vector<std::string>> content{ {"Andy", "19"}, {"Peter", "21"}, {"Lucas", "20"} };
	writer.write_row(header);
	writer.write_rows(content);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

/**
 * Determines the operating system's page allocation granularity.
 *
 * On the first call to this function, it invokes the operating system specific syscall
 * to determine the page size, caches the value, and returns it. Any subsequent call to
 * this function serves the cached value, so no further syscalls are made.
 */
inline size_t page_size() {
  static const size_t page_size = [] {
#ifdef _WIN32
    SYSTEM_INFO SystemInfo;
    GetSystemInfo(&SystemInfo);
    return SystemInfo.dwAllocationGranularity;
#else
    return sysconf(_SC_PAGE_SIZE);
#endif
  }();
  return page_size;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

#include <cstdio>
#include <windows.h>
#include <iostream>

using namespace std;

int main(int argc, char* argv[]) {
	const TCHAR* lpFileName = TEXT("hello.txt");
	HANDLE hFile;
	HANDLE hMap;
	LPVOID lpBasePtr;
	LARGE_INTEGER liFileSize;

	hFile = CreateFile(lpFileName,
		GENERIC_READ,                          // dwDesiredAccess
		0,                                     // dwShareMode
		NULL,                                  // lpSecurityAttributes
		OPEN_EXISTING,                         // dwCreationDisposition
		FILE_ATTRIBUTE_NORMAL,                 // dwFlagsAndAttributes
		0);                                    // hTemplateFile
	if (hFile == INVALID_HANDLE_VALUE) {
		fprintf(stderr, "CreateFile failed with error %d\n", GetLastError());
		return 1;
	}

	if (!GetFileSizeEx(hFile, &liFileSize)) {
		fprintf(stderr, "GetFileSize failed with error %d\n", GetLastError());
		CloseHandle(hFile);
		return 1;
	}

	if (liFileSize.QuadPart == 0) {
		fprintf(stderr, "File is empty\n");
		CloseHandle(hFile);
		return 1;
	}

	hMap = CreateFileMapping(
		hFile,
		NULL,                          // Mapping attributes
		PAGE_READONLY,                 // Protection flags
		0,                             // MaximumSizeHigh
		0,                             // MaximumSizeLow
		NULL);                         // Name
	if (hMap == 0) {
		fprintf(stderr, "CreateFileMapping failed with error %d\n", GetLastError());
		CloseHandle(hFile);
		return 1;
	}

	lpBasePtr = MapViewOfFile(
		hMap,
		FILE_MAP_READ,         // dwDesiredAccess
		0,                     // dwFileOffsetHigh
		0,                     // dwFileOffsetLow
		0);                    // dwNumberOfBytesToMap
	if (lpBasePtr == NULL) {
		fprintf(stderr, "MapViewOfFile failed with error %d\n", GetLastError());
		CloseHandle(hMap);
		CloseHandle(hFile);
		return 1;
	}

	// Display file content as ASCII charaters
	char* ptr = (char*)lpBasePtr;
	LONGLONG i = liFileSize.QuadPart;
	while (i-- > 0) {
		fputc(*ptr++, stdout);
	}

	UnmapViewOfFile(lpBasePtr);
	CloseHandle(hMap);
	CloseHandle(hFile);

	printf("\nDone\n");
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

template<typename T>
void logging(T t){
    cout << t;
    cout << "\nLast Call\n";
}

template<typename T, typename ... Args>
void logging(T first, Args... args){
    cout << first << ", ";
    logging(args...);
}

1

Reader<> reader;

1

set(CMAKE_CXX_STANDARD 14)

1

set(CMAKE_CXX_STANDARD 17)

1

Reader reader;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#include <utility>      // std::forward
#include <iostream>     // std::cout

// function with lvalue and rvalue reference overloads:
void overloaded (const int& x) {std::cout << "[lvalue]";}
void overloaded (int&& x) {std::cout << "[rvalue]";}

// function template taking rvalue reference to deduced type:
template <class T> void fn (T&& x) {
  overloaded (x);                   // always an lvalue
  overloaded (std::forward<T>(x));  // rvalue if argument is rvalue
}

int main () {
  int a;

  std::cout << "calling fn with lvalue: ";
  fn (a);
  std::cout << '\n';

  std::cout << "calling fn with rvalue: ";
  fn (0);
  std::cout << '\n';

  return 0;
}