TP14 : Commenter et documenter

#include "csv-utils.h"

#include <string>
#include <vector>
#include <fstream>
#include <stdexcept>
#include <algorithm>

CsvTable CsvUtils::readFile(const std::string& filePath) {
    std::ifstream file(filePath);
    if (!file.is_open()) {
        throw std::runtime_error("Impossible d'ouvrir le fichier CSV.");
    }

    std::string line;
    if (!std::getline(file, line)) {
        throw std::invalid_argument("Le fichier CSV est vide.");
    }

    std::vector<std::string> headers = splitLine(line);

    CsvTable table;
    while (std::getline(file, line)) {
        std::vector<std::string> values = splitLine(line);
        table.push_back(buildRow(headers, values));
    }

    return table;
}

void CsvUtils::writeFile(const std::string& filePath, const CsvTable& table) {
    if (table.empty()) {
        throw std::invalid_argument("Impossible d'écrire une table CSV vide.");
    }

    std::ofstream file(filePath);
    if (!file.is_open()) {
        throw std::runtime_error("Impossible d'écrire dans le fichier CSV.");
    }

    std::vector<std::string> headers = getColumnNames(table);
    writeHeaders(file, headers);

    for (const CsvRow& row : table) {
        checkColumnNames(headers, getColumnNames({row}));
        writeValues(file, row, headers);
    }
}

std::vector<std::string> CsvUtils::getColumnNames(const CsvTable& table) {
    if (table.empty()) {
        throw std::invalid_argument("Impossible de récupérer les noms de colonnes d'une table vide.");
    }

    std::vector<std::string> columnNames;
    for (const std::pair<const std::string, std::string>& column : table[0]) {
        columnNames.push_back(column.first);
    }

    return columnNames;
}

std::string CsvUtils::getValue(const CsvTable& table, int rowIndex, const std::string& columnName) {
    if (rowIndex < 0 || rowIndex >= table.size()) {
        throw std::out_of_range("L'indice de ligne est hors limites.");
    }

    const CsvRow& row = table[rowIndex];

    if (row.find(columnName) == row.end()) {
        throw std::invalid_argument("La colonne n'existe pas.");
    }

    return row.at(columnName);
}

std::vector<std::string> CsvUtils::splitLine(const std::string& line) {
    std::vector<std::string> values;
    std::string currentValue;

    for (char character : line) {
        if (character != SEPARATOR) {
            currentValue += character;
        } else {
            values.push_back(currentValue);
            currentValue.clear();
        }
    }
    values.push_back(currentValue);

    for (const std::string& value : values) {
        checkQuotes(value);
    }
    
    return values;
}

CsvRow CsvUtils::buildRow(const std::vector<std::string>& headers, const std::vector<std::string>& values) {
    checkColumnCount(headers, values);

    CsvRow row;
    for (int index = 0; index < headers.size(); index++) {
        row[headers[index]] = values[index];
    }

    return row;
}

void CsvUtils::checkColumnCount(const std::vector<std::string>& headers, const std::vector<std::string>& values) {
    if (headers.size() != values.size()) {
        throw std::invalid_argument("La ligne CSV ne contient pas le bon nombre de colonnes.");
    }
}

void CsvUtils::checkColumnNames(const std::vector<std::string>& expectedColumns, const std::vector<std::string>& actualColumns) {
    checkColumnCount(expectedColumns, actualColumns);

    for (const std::string& expectedColumn : expectedColumns) {
        if (std::find(actualColumns.begin(), actualColumns.end(),expectedColumn) == actualColumns.end()) {
            throw std::invalid_argument("La table CSV ne contient pas les bonnes colonnes.");
        }
    }
}

void CsvUtils::checkQuotes(const std::string& value) {
    if (value.find(QUOTE) != std::string::npos) {
        throw std::invalid_argument("Les guillemets ne sont pas supportés par ce format CSV.");
    }
}

void CsvUtils::writeHeaders(std::ofstream& file, const std::vector<std::string>& headers) {
    file << headers[0];
    for (int index = 1; index < headers.size(); index++) {
        file << SEPARATOR << headers[index];
    }
    file << '\n';
}

void CsvUtils::writeValues(std::ofstream& file, const CsvRow& row, const std::vector<std::string>& headers) {
    file << row.at(headers[0]);
    for (int index = 1; index < headers.size(); index++) {
        file << SEPARATOR << row.at(headers[index]);
    }
    file << '\n';
}

-xc++
-std=c++17
-Iinclude

all:
	mkdir -p lib
	g++ -std=c++17 -Iinclude -c source/csv-utils.cpp -o lib/csv-utils.o
	ar rcs lib/libcsvutils.a lib/csv-utils.o
	rm -f lib/csv-utils.o

-xc++
-std=c++17
-Iexternal/csv-utils/include

all:
	g++ -std=c++17 main.cpp -Iexternal/csv-utils/include -Lexternal/csv-utils/lib -lcsvutils -o my-app

run:
	./my-app

clean:
	rm my-app