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 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