/*

The function featured here is of course csvline_populate. It parses a
line of data by a delimiter. If you pass in a comma as your delimiter
it will parse out a Comma Separated Value (CSV) file. If you pass in a
'\t' char it will parse out a tab delimited file (.txt or .tsv). CSV
files often have commas in the actual data, but accounts for this by
surrounding the data in quotes. This also means the quotes need to be
parsed out, this function accounts for that as well.

It would make some sense to only pass in the line and delimiter to the
function, and have the return type be the vector. However in terms of
performance under heavy loads, this makes less sense. Passing in a
predefined vector allows a function to populate it, copying bytes from
your line as it goes. However, to not pass in a predefined vector,
we'd have to declare it as a local variable to the function, which
declares it on the stack. This means when the function completes, the
variable will be deallocated, so when it returns the vector, the
return keyword uses the copy constructor of the vector (which uses the
copy constructor of each string object) to assign the return type to
the variable in the caller function. To copy the return value of an
object (depending on the size of your vector and the number of times
you do it), can be an expensive operation.

Note: The only other problem with this code here, is that the
definition of a csv allows for the newline character '\n' to be part
of a csv field if the field is surrounded by quotes. The
csvline_populate function takes care of this properly, but the main
function which calls csvline_populate doesn't handle it. The way the
main function works is that the getline(in, line) function populates
the next line of the file from the 'in' stream using '\n' as a
delimiter. So, if there is a '\n' in the middle of the csv field, the
getline(in,line) still treats it as an end of line character. Most CSV
files do not have a \n in the middle of the field, so it is usually
not worth worrying about.

If one were to fix this issue, it would be by making a fgetcsv type
function which operates directly on the FILE* handle or the
ifstream. The function would also have to detect EOF (end of file).

*/

#include <iostream>
#include <fstream>
#include <string>
#include <vector>

#include "csv_parse.h"

using namespace std;

void csvline_populate(vector<xtring> &record,
        const string& line, char delimiter) {
    int linepos=0;
    int inquotes=false;
    char c;
//???    int i;
    int linemax=line.length();
    record.clear();
    xtring curstring;

    while(line[linepos]!=0 && linepos < linemax) {
        c = line[linepos];

        if (!inquotes && curstring.str.length()==0 && c=='"')
        {
            //beginquotechar
            inquotes=true;
            curstring.quoted = 1;
        }
        else if (inquotes && c=='"')
        {
            //quotechar
            if ( (linepos+1 <linemax) && (line[linepos+1]=='"') )
            {
                //encountered 2 double quotes in a row (resolves to 1 double quote)
                curstring.str.push_back(c);
                linepos++;
            }
            else
            {
                //endquotechar
                inquotes=false;
            }
        }
        else if (!inquotes && c==delimiter)
        {
            //end of field
            record.push_back( curstring );
            curstring.str="";
            curstring.quoted = 0;
        }
        else if (!inquotes && (c=='\r' || c=='\n') )
        {
            record.push_back( curstring );
            return;
        }
        else
        {
            curstring.str.push_back(c);
        }
        linepos++;
    }
    record.push_back( curstring );
    return;
}