externalcolumnfilecore.h

Go to the documentation of this file.

 
#ifndef OPENSWMMVIS_UI_UTIL_EXTERNALCOLUMNFILECORE_H
#define OPENSWMMVIS_UI_UTIL_EXTERNALCOLUMNFILECORE_H
 
#include <algorithm>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
 
namespace openswmmvis::ui::extcol {
 
inline std::string cellTrim(const std::string& s)
{
    std::size_t a = 0, b = s.size();
    auto space = [](char c) {
        return c == ' ' || c == '\t' || c == '\r' || c == '\n';
    };
    while (a < b && space(s[a])) ++a;
    while (b > a && space(s[b - 1])) --b;
    if (b - a >= 2 && s[a] == '"' && s[b - 1] == '"') { ++a; --b; }
    return s.substr(a, b - a);
}
 
inline std::vector<std::string> splitCells(const std::string& line, char delim)
{
    std::vector<std::string> out;
    std::string cur;
    bool inQuotes = false;
    for (const char c : line) {
        if (c == '"') { inQuotes = !inQuotes; cur.push_back(c); }
        else if (c == delim && !inQuotes) { out.push_back(cellTrim(cur)); cur.clear(); }
        else cur.push_back(c);
    }
    out.push_back(cellTrim(cur));
    return out;
}
 
inline bool iequals(const std::string& a, const std::string& b)
{
    if (a.size() != b.size()) return false;
    for (std::size_t i = 0; i < a.size(); ++i)
        if (std::tolower(static_cast<unsigned char>(a[i]))
            != std::tolower(static_cast<unsigned char>(b[i]))) return false;
    return true;
}
 
inline void normalizeLine(std::string& line, bool firstLine)
{
    if (firstLine && line.size() >= 3 &&
        static_cast<unsigned char>(line[0]) == 0xEF &&
        static_cast<unsigned char>(line[1]) == 0xBB &&
        static_cast<unsigned char>(line[2]) == 0xBF)
        line.erase(0, 3);
    if (!line.empty() && line.back() == '\r') line.pop_back();
}
 
inline bool isBlankOrComment(const std::string& line)
{
    for (const char c : line) {
        if (c == ' ' || c == '\t') continue;
        return c == ';' || c == '#';
    }
    return true;  // all-whitespace / empty
}
 
inline bool isTsfHeader(const std::string& line)
{
    static const std::string prefix = "IDs:";
    if (line.size() < prefix.size()) return false;
    return iequals(line.substr(0, prefix.size()), prefix);
}
 
inline char sniffDelimiter(const std::string& headerLine)
{
    long tabs = 0, commas = 0, semis = 0;
    bool inQuotes = false;
    for (const char c : headerLine) {
        if (c == '"') { inQuotes = !inQuotes; continue; }
        if (inQuotes)  continue;
        if (c == '\t')      ++tabs;
        else if (c == ',')  ++commas;
        else if (c == ';')  ++semis;
    }
    if (tabs >= commas && tabs >= semis && tabs > 0) return '\t';
    if (semis > commas && semis > 0)                  return ';';
    return ',';
}
 
struct DateTimeParts {
    int year = 0, month = 0, day = 0;
    int hour = 0, minute = 0, second = 0;
};
 
inline int trailingMeridiem(const std::string& cell)
{
    const std::size_t e = cell.find_last_not_of(" \t\r\n");
    if (e == std::string::npos || e < 1) return 0;
    const char m1 = static_cast<char>(std::toupper(static_cast<unsigned char>(cell[e])));
    const char m0 = static_cast<char>(std::toupper(static_cast<unsigned char>(cell[e - 1])));
    if (m1 != 'M' || (m0 != 'A' && m0 != 'P')) return 0;
    return m0 == 'A' ? 1 : 2;
}
 
inline bool parseSeriesDateTime(const std::string& cell, DateTimeParts& out)
{
    int y = 0, mo = 0, d = 0, h = 0, mi = 0, s = 0;
    const char* c = cell.c_str();
 
    // ISO-8601: YYYY-MM-DD[ T]HH:MM[:SS]
    int n = std::sscanf(c, "%d-%d-%d%*[ T]%d:%d:%d", &y, &mo, &d, &h, &mi, &s);
    if (n >= 3) {
        if (n < 4) { h = mi = s = 0; }
        else if (n < 6) { s = 0; }
        out = {y, mo, d, h, mi, s};
        return true;
    }
 
    // US: MM/DD/YYYY[ HH:MM[:SS]], optionally 12-hour with trailing AM/PM.
    n = std::sscanf(c, "%d/%d/%d %d:%d:%d", &mo, &d, &y, &h, &mi, &s);
    if (n >= 3) {
        if (n < 4) { h = mi = s = 0; }
        else if (n < 6) { s = 0; }
        if (n >= 4) {
            const int meridiem = trailingMeridiem(cell);
            if (meridiem != 0) {
                if (h == 12) h = 0;          // 12:xx AM → 00:xx, 12:xx PM → 12:xx
                if (meridiem == 2) h += 12;  // PM
            }
        }
        out = {y, mo, d, h, mi, s};
        return true;
    }
    return false;
}
 
inline void splitPathColumn(const std::string& token,
                            std::string& pathOut, std::string& columnOut)
{
    const std::size_t colSep = token.rfind(':');
    const bool driveLetter =
        colSep == 1 && std::isalpha(static_cast<unsigned char>(token[0]));
    if (colSep != std::string::npos && !driveLetter
        && token.find_first_of("/\\", colSep + 1) == std::string::npos) {
        pathOut   = token.substr(0, colSep);
        columnOut = token.substr(colSep + 1);
    } else {
        pathOut   = token;
        columnOut.clear();
    }
}
 
inline std::string composePathColumn(const std::string& path,
                                     const std::string& column)
{
    return column.empty() ? path : path + ":" + column;
}
 
inline int findColumn(const std::vector<std::string>& valueHeaders,
                      const std::string& name)
{
    for (std::size_t i = 0; i < valueHeaders.size(); ++i)
        if (iequals(valueHeaders[i], name)) return static_cast<int>(i);
    return -1;
}
 
inline std::string fabricatedColumnName(std::size_t oneBasedIndex)
{
    return "col_" + std::to_string(oneBasedIndex);
}
 
} // namespace openswmmvis::ui::extcol
 
#endif // OPENSWMMVIS_UI_UTIL_EXTERNALCOLUMNFILECORE_H