FileIO::CsvInterface Class Reference

Detailed Description

Interface for reading CSV file formats.

Definition at line 40 of file CsvInterface.h.

#include <CsvInterface.h>

Inheritance diagram for FileIO::CsvInterface:

Collaboration diagram for FileIO::CsvInterface:

Public Member Functions
	CsvInterface ()
	Constructor (only needed for writing files)
std::size_t	getNArrays () const
	Returns the number of vectors currently staged for writing.
void	addIndexVectorForWriting (std::size_t s)
	Adds an index vector of size s to the CSV file.
void	setCsvHeader (bool write_header)
	Stores if the CSV file to be written should include a header or not.
template<typename T >
bool	addVectorForWriting (std::string const &vec_name, std::vector< T > const &vec)
bool	write () override
	Writes the CSV file.
Public Member Functions inherited from BaseLib::IO::Writer
	Writer ()
virtual	~Writer ()=default
std::string	writeToString ()
	Writes the object to a string.

Static Public Member Functions
static std::vector< std::string >	getColumnNames (std::string const &fname, char delim)
static int	readPoints (std::string const &fname, char delim, std::vector< GeoLib::Point * > &points)
static int	readPoints (std::string const &fname, char delim, std::vector< GeoLib::Point * > &points, std::string const &x_column_name, std::string const &y_column_name, std::string const &z_column_name="")
static int	readPoints (std::string const &fname, char delim, std::vector< GeoLib::Point * > &points, std::size_t x_column_idx, std::size_t y_column_idx, std::size_t z_column_idx=std::numeric_limits< std::size_t >::max())
template<typename T >
static std::pair< int, std::vector< T > >	readColumn (std::string const &fname, char delim, std::string const &column_name)
template<typename T >
static std::pair< int, std::vector< T > >	readColumn (std::string const &fname, char delim, std::size_t column_idx)

Private Member Functions
std::size_t	getVectorSize (std::size_t idx) const
	Returns the size of the vector with the given index.
void	writeValue (std::size_t vec_idx, std::size_t in_vec_idx)

Static Private Member Functions
static int	readPoints (std::ifstream &in, char delim, std::vector< GeoLib::Point * > &points, std::array< std::size_t, 3 > const &column_idx)
	Actual point reader for public methods.
template<typename T >
static std::pair< int, std::vector< T > >	readColumn (std::ifstream &in, char delim, std::size_t column_idx)
	Actual column reader for public methods.
static std::size_t	findColumn (std::string const &line, char delim, std::string const &column_name)

Private Attributes
bool	_writeCsvHeader {true}
std::vector< std::string >	_vec_names
std::vector< std::any >	_data

Additional Inherited Members
Protected Member Functions inherited from BaseLib::IO::Writer
Protected Attributes inherited from BaseLib::IO::Writer
std::ostringstream	out
	The stream to write to.

Constructor & Destructor Documentation

CsvInterface()

FileIO::CsvInterface::CsvInterface ( )

default

Constructor (only needed for writing files)

Member Function Documentation

addIndexVectorForWriting()

void FileIO::CsvInterface::addIndexVectorForWriting

(

std::size_t

s

)

Adds an index vector of size s to the CSV file.

Definition at line 254 of file CsvInterface.cpp.

{
    std::vector<int> idx_vec(s);
    std::iota(idx_vec.begin(), idx_vec.end(), 0);
    addVectorForWriting("Index", idx_vec);
}

References addVectorForWriting().

Referenced by FileIO::SwmmInterface::writeCsvForObject(), and FileIO::SwmmInterface::writeCsvForTimestep().

addVectorForWriting()

template<typename T >

bool FileIO::CsvInterface::addVectorForWriting ( std::string const & vec_name, std::vector< T > const & vec )

inline

Adds a data vector to the CSV file. All data vectors have to have the same size. Vectors will be written in the same sequence they have been added to the interface.

Definition at line 64 of file CsvInterface.h.

    {
        static_assert(
            std::is_same_v<T, std::string> || std::is_same_v<T, double> ||
                std::is_same_v<T, int>,
            "CsvInterface can only write vectors of strings, doubles or ints.");
 
        if (!_data.empty())
        {
            std::size_t const vec_size(getVectorSize(0));
            if (vec_size != vec.size())
            {
                ERR("Vector size does not match existing data (should be "
                    "{:d}).",
                    vec_size);
                return false;
            }
        }
 
        _vec_names.push_back(vec_name);
        _data.push_back(vec);
        return true;
    }

References _data, _vec_names, ERR(), and getVectorSize().

Referenced by addIndexVectorForWriting(), FileIO::SwmmInterface::writeCsvForObject(), and FileIO::SwmmInterface::writeCsvForTimestep().

findColumn()

std::size_t FileIO::CsvInterface::findColumn ( std::string const & line, char delim, std::string const & column_name )

staticprivate

Returns the number of the column with column_name (or std::numeric_limits::max() if no such column has been found).

Definition at line 226 of file CsvInterface.cpp.

{
    std::list<std::string> const fields = BaseLib::splitString(line, delim);
    if (fields.empty())
    {
        return std::numeric_limits<std::size_t>::max();
    }
 
    std::size_t count(0);
    for (const auto& field : fields)
    {
        if (field == column_name)
        {
            break;
        }
 
        count++;
    }
 
    if (count == fields.size())
    {
        return std::numeric_limits<std::size_t>::max();
    }
 
    return count;
}

References BaseLib::splitString().

Referenced by readColumn(), and readPoints().

getColumnNames()

std::vector< std::string > FileIO::CsvInterface::getColumnNames ( std::string const & fname, char delim )

static

Returns a vector containing the names of columns in the file (assuming the file has a header)

Definition at line 25 of file CsvInterface.cpp.

{
    std::ifstream in(fname.c_str());
 
    if (!in.is_open())
    {
        ERR("CsvInterface::getColumnNames(): Could not open file {:s}.", fname);
        return std::vector<std::string>();
    }
    std::string line;
    if (!std::getline(in, line))
    {
        ERR("CsvInterface::getColumnNames(): Could not read line from file "
            "{:s}. Is it empty?",
            fname);
        return {};
    }
 
    if (delim == '\n')
    {
        return {};
    }
 
    std::list<std::string> fields = BaseLib::splitString(line, delim);
    if (fields.size() < 2)
    {
        for (char const d : {'\t', ';', ','})
        {
            fields = BaseLib::splitString(line, d);
            if (fields.size() > 1)
            {
                break;
            }
        }
    }
    return {begin(fields), end(fields)};
}

References ERR(), and BaseLib::splitString().

getNArrays()

std::size_t FileIO::CsvInterface::getNArrays ( ) const

inline

Returns the number of vectors currently staged for writing.

Definition at line 47 of file CsvInterface.h.

{ return _vec_names.size(); }

References _vec_names.

Referenced by FileIO::SwmmInterface::writeCsvForObject(), and FileIO::SwmmInterface::writeCsvForTimestep().

getVectorSize()

std::size_t FileIO::CsvInterface::getVectorSize ( std::size_t idx ) const

private

Returns the size of the vector with the given index.

Definition at line 295 of file CsvInterface.cpp.

{
    if (_data[idx].type() == typeid(std::vector<std::string>))
    {
        return std::any_cast<std::vector<std::string>>(_data[idx]).size();
    }
    if (_data[idx].type() == typeid(std::vector<double>))
    {
        return std::any_cast<std::vector<double>>(_data[idx]).size();
    }
    if (_data[idx].type() == typeid(std::vector<int>))
    {
        return std::any_cast<std::vector<int>>(_data[idx]).size();
    }
    return 0;
}

References _data.

Referenced by addVectorForWriting(), and write().

readColumn() [1/3]

template<typename T >

static std::pair< int, std::vector< T > > FileIO::CsvInterface::readColumn ( std::ifstream & in, char delim, std::size_t column_idx )

inlinestaticprivate

Actual column reader for public methods.

Definition at line 199 of file CsvInterface.h.

    {
        std::vector<T> data_array;
        std::string line;
        std::size_t line_count(0);
        int error_count(0);
        while (std::getline(in, line))
        {
            line_count++;
            std::list<std::string> const fields =
                BaseLib::splitString(line, delim);
 
            if (fields.size() < column_idx + 1)
            {
                ERR("Line {:d} contains not enough columns of data. Skipping "
                    "line...",
                    line_count);
                error_count++;
                continue;
            }
            auto it = fields.begin();
            std::advance(it, column_idx);
 
            std::istringstream stream(*it);
            T value;
            if (!(stream >> value))
            {
                ERR("Error reading value in line {:d}.", line_count);
                error_count++;
                continue;
            }
 
            data_array.push_back(value);
        }
        return {error_count, data_array};
    }

References ERR(), and BaseLib::splitString().

readColumn() [2/3]

template<typename T >

static std::pair< int, std::vector< T > > FileIO::CsvInterface::readColumn ( std::string const & fname, char delim, std::size_t column_idx )

inlinestatic

Definition at line 178 of file CsvInterface.h.

    {
        std::ifstream in(fname.c_str());
        if (!in.is_open())
        {
            ERR("CsvInterface::readColumn(): Could not open file {:s}.", fname);
            return {-1, {}};
        }
        return readColumn<T>(in, delim, column_idx);
    }

References ERR(), and readColumn().

readColumn() [3/3]

template<typename T >

static std::pair< int, std::vector< T > > FileIO::CsvInterface::readColumn ( std::string const & fname, char delim, std::string const & column_name )

inlinestatic

Reads a column of the given name from a CSV file.

Parameters

fname	Name of the file to be read
delim	Deliminator, default is ','
column_name	The column's name to read

Returns

An error code (0 = ok, 0<i<max = number of skipped lines, -1 error reading file) and an possibly empty vector containing the read values

Definition at line 155 of file CsvInterface.h.

    {
        std::ifstream in(fname.c_str());
        if (!in.is_open())
        {
            ERR("CsvInterface::readColumn(): Could not open file {:s}.", fname);
            return {-1, {}};
        }
 
        std::string line;
        std::getline(in, line);
        std::size_t const column_idx =
            CsvInterface::findColumn(line, delim, column_name);
        if (column_idx == std::numeric_limits<std::size_t>::max())
        {
            ERR("Column '{:s}' not found in file header.", column_name);
            return {-1, {}};
        }
        return readColumn<T>(in, delim, column_idx);
    }

References ERR(), findColumn(), and readColumn().

Referenced by readColumn(), and readColumn().

readPoints() [1/4]

int FileIO::CsvInterface::readPoints ( std::ifstream & in, char delim, std::vector< GeoLib::Point * > & points, std::array< std::size_t, 3 > const & column_idx )

staticprivate

Actual point reader for public methods.

Definition at line 172 of file CsvInterface.cpp.

{
    std::array<std::size_t, 3> order = {{0, 1, 2}};
    std::sort(order.begin(), order.end(),
              [&column_idx](std::size_t idx1, std::size_t idx2)
              { return column_idx[idx1] < column_idx[idx2]; });
    std::array<std::size_t, 3> const column_advance = {
        {column_idx[order[0]], column_idx[order[1]] - column_idx[order[0]],
         column_idx[order[2]] - column_idx[order[1]]}};
 
    std::string line;
    std::size_t line_count(0);
    std::size_t error_count(0);
    std::list<std::string>::const_iterator it;
 
    while (std::getline(in, line))
    {
        line_count++;
        std::list<std::string> const fields = BaseLib::splitString(line, delim);
 
        if (fields.size() < column_idx[order[2]] + 1)
        {
            ERR("Line {:d} contains not enough columns of data. Skipping "
                "line...",
                line_count);
            error_count++;
            continue;
        }
 
        it = fields.begin();
        try
        {
            std::advance(it, column_advance[0]);
            std::array<double, 3> point{};
            point[order[0]] = std::stod(*it);
            std::advance(it, column_advance[1]);
            point[order[1]] = std::stod(*it);
            std::advance(it, column_advance[2]);
            point[order[2]] =
                (column_idx[1] == column_idx[2]) ? 0 : std::stod(*it);
            points.push_back(new GeoLib::Point(point[0], point[1], point[2]));
        }
        catch (const std::invalid_argument&)
        {
            ERR("Error converting data to coordinates in line {:d}.",
                line_count);
            error_count++;
        }
    }
    return error_count;
}

References ERR(), and BaseLib::splitString().

readPoints() [2/4]

int FileIO::CsvInterface::readPoints ( std::string const & fname, char delim, std::vector< GeoLib::Point * > & points )

static

Reads 3D points from a CSV file. It is assumed that the file has a header specifying a name for each of the columns. The first three columns will be interpreted as x-, y- and z-coordinate, respectively.

Parameters

fname	Name of the file to be read
delim	Deliminator, default is ','
points	A vector containing the 3D points read from the file

Returns

An error code (0 = ok, 0<i<max = number of skipped lines, -1 error reading file)

Definition at line 64 of file CsvInterface.cpp.

{
    std::ifstream in(fname.c_str());
 
    if (!in.is_open())
    {
        ERR("CsvInterface::readPoints(): Could not open file {:s}.", fname);
        return -1;
    }
 
    std::string line;
    std::getline(in, line);
 
    std::size_t line_count(0);
    std::size_t error_count(0);
    std::list<std::string>::const_iterator it;
    while (std::getline(in, line))
    {
        line_count++;
        std::list<std::string> const fields = BaseLib::splitString(line, delim);
 
        if (fields.size() < 3)
        {
            ERR("Line {:d} contains not enough columns of data. Skipping "
                "line...",
                line_count);
            error_count++;
            continue;
        }
        it = fields.begin();
        try
        {
            std::array<double, 3> point{};
            point[0] = std::stod(*it);
            point[1] = std::stod(*(++it));
            point[2] = std::stod(*(++it));
            points.push_back(new GeoLib::Point(point[0], point[1], point[2]));
        }
        catch (const std::invalid_argument&)
        {
            ERR("Error converting data to coordinates in line {:d}.",
                line_count);
        }
    }
    return error_count;
}

References ERR(), and BaseLib::splitString().

Referenced by readPoints(), and readPoints().

readPoints() [3/4]

int FileIO::CsvInterface::readPoints ( std::string const & fname, char delim, std::vector< GeoLib::Point * > & points, std::size_t x_column_idx, std::size_t y_column_idx, std::size_t z_column_idx = std::numeric_limits<std::size_t>::max() )

static

Reads 3D points from a headerless CSV file, so columns for x-, y- and z-coordinates have to be specified using indices (starting with 0). If z_column_idx is not given (or set to numeric_limits::max()), all z-coordinates will be set to zero.

Parameters

fname	Name of the file to be read
delim	Deliminator, default is ','
points	A vector containing the 3D points read from the file
x_column_idx	Index of the column to be interpreted as x-coordinate
y_column_idx	Index of the column to be interpreted as y-coordinate
z_column_idx	Index of the column to be interpreted as z-coordinate

Returns

An error code (0 = ok, 0<i<max = number of skipped lines, -1 error reading file)

Definition at line 149 of file CsvInterface.cpp.

{
    std::ifstream in(fname.c_str());
 
    if (!in.is_open())
    {
        ERR("CsvInterface::readPoints(): Could not open file {:s}.", fname);
        return -1;
    }
 
    if (z_column_idx == std::numeric_limits<std::size_t>::max())
    {
        z_column_idx = y_column_idx;
    }
    std::array<std::size_t, 3> const column_idx = {
        {x_column_idx, y_column_idx, z_column_idx}};
 
    return readPoints(in, delim, points, column_idx);
}

References ERR(), and readPoints().

readPoints() [4/4]

int FileIO::CsvInterface::readPoints ( std::string const & fname, char delim, std::vector< GeoLib::Point * > & points, std::string const & x_column_name, std::string const & y_column_name, std::string const & z_column_name = "" )

static

Reads 3D points from a CSV file. It is assumed that the file has a header specifying a name for each of the columns. The columns specified in the function call will be used for reading x-, y- and z-coordinates, respectively If z_column_name is an empty string or not given at all, all z-coordinates will be set to zero.

Parameters

fname	Name of the file to be read
delim	Deliminator, default is ','
points	A vector containing the 3D points read from the file
x_column_name	Name of the column to be interpreted as x-coordinate
y_column_name	Name of the column to be interpreted as y-coordinate
z_column_name	Name of the column to be interpreted as z-coordinate

Returns

An error code (0 = ok, 0<i<max = number of skipped lines, -1 error reading file)

Definition at line 112 of file CsvInterface.cpp.

{
    std::ifstream in(fname.c_str());
    std::array<std::string, 3> const column_names = {
        {x_column_name, y_column_name, z_column_name}};
 
    if (!in.is_open())
    {
        ERR("CsvInterface::readPoints(): Could not open file {:s}.", fname);
        return -1;
    }
 
    std::string line;
    std::getline(in, line);
    std::array<std::size_t, 3> const column_idx = {
        {CsvInterface::findColumn(line, delim, x_column_name),
         CsvInterface::findColumn(line, delim, y_column_name),
         (z_column_name.empty())
             ? CsvInterface::findColumn(line, delim, y_column_name)
             : CsvInterface::findColumn(line, delim, z_column_name)}};
 
    for (std::size_t i = 0; i < 3; ++i)
    {
        if (column_idx[i] == std::numeric_limits<std::size_t>::max())
        {
            ERR("Column '{:s}' not found in file header.", column_names[i]);
            return -1;
        }
    }
 
    return readPoints(in, delim, points, column_idx);
}

References ERR(), findColumn(), and readPoints().

setCsvHeader()

void FileIO::CsvInterface::setCsvHeader ( bool write_header )

inline

Stores if the CSV file to be written should include a header or not.

Definition at line 58 of file CsvInterface.h.

{ _writeCsvHeader = write_header; }

References _writeCsvHeader.

write()

bool FileIO::CsvInterface::write ( )

overridevirtual

Writes the CSV file.

Implements BaseLib::IO::Writer.

Definition at line 261 of file CsvInterface.cpp.

{
    if (_data.empty())
    {
        ERR("CsvInterface::write() - No data to write.");
        return false;
    }
 
    std::size_t const n_vecs(_data.size());
    std::size_t const vec_size(getVectorSize(0));
 
    if (_writeCsvHeader)
    {
        out << _vec_names[0];
        for (std::size_t i = 1; i < n_vecs; ++i)
        {
            out << "\t" << _vec_names[i];
        }
        out << "\n";
    }
 
    for (std::size_t j = 0; j < vec_size; ++j)
    {
        writeValue(0, j);
        for (std::size_t i = 1; i < n_vecs; ++i)
        {
            out << "\t";
            writeValue(i, j);
        }
        out << "\n";
    }
    return true;
}

References _data, _vec_names, _writeCsvHeader, ERR(), getVectorSize(), BaseLib::IO::Writer::out, and writeValue().

writeValue()

void FileIO::CsvInterface::writeValue ( std::size_t vec_idx, std::size_t in_vec_idx )

private

Writes a value from a vector to the file.

Parameters

vec_idx	Index of the vector
in_vec_idx	Entry in the selected vector

Definition at line 312 of file CsvInterface.cpp.

{
    if (_data[vec_idx].type() == typeid(std::vector<std::string>))
    {
        out << std::any_cast<std::vector<std::string>>(
            _data[vec_idx])[in_vec_idx];
    }
    else if (_data[vec_idx].type() == typeid(std::vector<double>))
    {
        out << std::any_cast<std::vector<double>>(_data[vec_idx])[in_vec_idx];
    }
    else if (_data[vec_idx].type() == typeid(std::vector<int>))
    {
        out << std::any_cast<std::vector<int>>(_data[vec_idx])[in_vec_idx];
    }
}

References _data, and BaseLib::IO::Writer::out.

Referenced by write().

Member Data Documentation

_data

std::vector<std::any> FileIO::CsvInterface::_data

private

Definition at line 255 of file CsvInterface.h.

Referenced by addVectorForWriting(), getVectorSize(), write(), and writeValue().

_vec_names

std::vector<std::string> FileIO::CsvInterface::_vec_names

private

Definition at line 254 of file CsvInterface.h.

Referenced by addVectorForWriting(), getNArrays(), and write().

_writeCsvHeader

bool FileIO::CsvInterface::_writeCsvHeader {true}

private

Definition at line 253 of file CsvInterface.h.

{true};

Referenced by setCsvHeader(), and write().

---

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

• Applications/FileIO/CsvInterface.h
• Applications/FileIO/CsvInterface.cpp