csv_file.h

Go to the documentation of this file.

// Copyright (C) 2014-2024 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
#ifndef CSV_FILE_H
#define CSV_FILE_H
 
#include <exceptions/exceptions.h>
#include <boost/lexical_cast.hpp>
#include <boost/shared_ptr.hpp>
#include <fstream>
#include <ostream>
#include <string>
#include <vector>
 
namespace isc {
namespace util {

class CSVFileError : public Exception {
public:
    CSVFileError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { }
};

class CSVFileFatalError : public Exception {
public:
    CSVFileFatalError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { }
};

class CSVRow {
public:

    CSVRow(const size_t cols = 0, const char separator = ',');

    CSVRow(const std::string& text, const char separator = ',');

    size_t getValuesCount() const {
        return (values_.size());
    }

    void parse(const std::string& line);

    std::string readAt(const size_t at) const;

    std::string readAtEscaped(const size_t at) const;

    void trim(const size_t count);

    template<typename T>
    T readAndConvertAt(const size_t at) const {
        T cast_value;
        try {
            cast_value = boost::lexical_cast<T>(readAt(at).c_str());
 
        } catch (const boost::bad_lexical_cast& ex) {
            isc_throw(CSVFileError, ex.what());
        }
        return (cast_value);
    }

    std::string render() const;

    void writeAt(const size_t at, const char* value);

    void writeAt(const size_t at, const std::string& value) {
        writeAt(at, value.c_str());
    }

    void writeAtEscaped(const size_t at, const std::string& value);

    template<typename T>
    void append(const T value) {
        try {
            values_.push_back(boost::lexical_cast<std::string>(value));
        } catch (const boost::bad_lexical_cast& ex) {
            isc_throw(CSVFileError, "unable to stringify the value to be "
                      "appended to the CSV file row.");
        }
    }

    template<typename T>
    void writeAt(const size_t at, const T value) {
        checkIndex(at);
        try {
            values_[at] = boost::lexical_cast<std::string>(value);
        } catch (const boost::bad_lexical_cast& ex) {
            isc_throw(CSVFileError, "unable to stringify the value to be"
                      " written in the CSV file row at position '"
                      << at << "'");
        }
    }

    bool operator==(const CSVRow& other) const {
        return (render() == other.render());
    }

    bool operator!=(const CSVRow& other) const {
        return (render() != other.render());
    }

    static std::string escapeCharacters(const std::string& orig_str,
                                        const std::string& characters);

    static std::string unescapeCharacters(const std::string& escaped_str);
 
private:

    void checkIndex(const size_t at) const;

    std::string separator_;

    std::vector<std::string> values_;

    static const std::string escape_tag;
};

std::ostream& operator<<(std::ostream& os, const CSVRow& row);

class CSVFile {
public:

    CSVFile(const std::string& filename);

    virtual ~CSVFile();

    void addColumn(const std::string& col_name);

    void append(const CSVRow& row) const;

    void close();

    bool exists() const;

    void flush() const;

    size_t getColumnCount() const {
        return (cols_.size());
    }

    std::string getFilename() const {
        return (filename_);
    }

    std::string getReadMsg() const {
        return (read_msg_);
    }

    size_t getColumnIndex(const std::string& col_name) const;

    std::string getColumnName(const size_t col_index) const;

    bool next(CSVRow& row, const bool skip_validation = false);

 
    virtual void open(const bool seek_to_end = false);

    virtual void recreate();

    void setReadMsg(const std::string& read_msg) {
        read_msg_ = read_msg;
    }

    static CSVRow EMPTY_ROW() {
        static CSVRow row(0);
        return (row);
    }
 
protected:

    void addColumnInternal(const std::string& col_name);

    virtual bool validate(const CSVRow& row);
 
protected:

    virtual bool validateHeader(const CSVRow& header);
 
private:
    void checkStreamStatusAndReset(const std::string& operation) const;

    std::streampos size() const;

    std::string filename_;

    boost::shared_ptr<std::fstream> fs_;

    std::vector<std::string> cols_;

    std::string read_msg_;
};
 
} // namespace isc::util
} // namespace isc
 
#endif // CSV_FILE_H