InputParseUtils.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
//
// Copyright 2026 Caleb Buahin
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

 
#ifndef OPENSWMM_ENGINE_INPUT_PARSE_UTILS_HPP
#define OPENSWMM_ENGINE_INPUT_PARSE_UTILS_HPP
 
#include <string_view>
#include <string>
#include <vector>
#include <charconv>
#include "../core/charconv_compat.hpp"
#include "../core/DateTime.hpp"
#include "../core/ErrorCodes.hpp"
#include "../data/NameIndex.hpp"
 
namespace openswmm::input {
 
// ============================================================================
// Numeric parsing
// ============================================================================

inline double to_double(std::string_view sv, double def = 0.0) noexcept {
    double v = def;
    openswmm::from_chars_double(sv.data(), sv.data() + sv.size(), v);
    return v;
}

inline bool parse_double_strict(std::string_view sv, double& out) noexcept {
    if (sv.empty()) {
        out = 0.0;
        return true;
    }
    if (sv.front() == '+') { // strtod accepts a leading '+'
        sv.remove_prefix(1);
        if (sv.empty() || sv.front() == '+' || sv.front() == '-')
            return false;
    }
    double v = 0.0;
    const auto [ptr, ec] = openswmm::from_chars_double(sv.data(), sv.data() + sv.size(), v);
    if (ec != std::errc{} || ptr != sv.data() + sv.size())
        return false;
    out = v;
    return true;
}

inline int to_int(std::string_view sv, int def = 0) noexcept {
    int v = def;
    auto [ptr, ec] = std::from_chars(sv.data(), sv.data() + sv.size(), v);
    if (ec != std::errc{})
        return def;
    return v;
}
 
// ============================================================================
// Date/time parsing
// ============================================================================

inline double parse_date(std::string_view sv) {
    unsigned m = 0, d = 0, y = 0;
    const char* p = sv.data();
    const char* end = sv.data() + sv.size();
 
    auto read_uint = [&](unsigned& out) -> bool {
        auto [np, ec] = std::from_chars(p, end, out);
        if (ec != std::errc{})
            return false;
        p = np;
        return true;
    };
    auto read_sep = [&]() -> bool {
        if (p < end && (*p == '/' || *p == '-')) {
            ++p;
            return true;
        }
        return false;
    };
 
    if (!read_uint(m))
        return 0.0;
    if (!read_sep())
        return 0.0;
    if (!read_uint(d))
        return 0.0;
    if (!read_sep())
        return 0.0;
    if (!read_uint(y))
        return 0.0;
 
    return datetime::encodeDate(static_cast<int>(y), static_cast<int>(m), static_cast<int>(d));
}

inline double parse_time_seconds(std::string_view sv) {
    // Try plain number first
    double val = 0.0;
    auto [ptr, ec] = openswmm::from_chars_double(sv.data(), sv.data() + sv.size(), val);
    if (ec == std::errc{} && ptr == sv.data() + sv.size()) {
        return val; // plain number = seconds
    }
 
    // Try HH:MM:SS or HH:MM
    unsigned h = 0, m = 0;
    double s = 0.0;
    const char* p = sv.data();
    const char* end = sv.data() + sv.size();
 
    auto read_uint = [&](unsigned& out) -> bool {
        auto [np, nec] = std::from_chars(p, end, out);
        if (nec != std::errc{})
            return false;
        p = np;
        return true;
    };
 
    if (!read_uint(h))
        return 0.0;
    if (p < end && *p == ':') {
        ++p;
        if (!read_uint(m))
            return static_cast<double>(h);
        if (p < end && *p == ':') {
            ++p;
            openswmm::from_chars_double(p, end, s);
        }
    }
    return h * 3600.0 + m * 60.0 + s;
}

inline double parse_time_day_fraction(std::string_view sv) {
    const char* p = sv.data();
    const char* end = sv.data() + sv.size();
 
    // A time token is EITHER decimal hours (a bare number such as "0.167" or
    // "10") OR a clock string "HH:MM[:SS]" — matching legacy datetime_strToTime
    // ("accepts time as hr:min:sec or as decimal hours"). Try a full decimal
    // parse first: if the WHOLE token is a number it is decimal hours (/24);
    // otherwise fall back to integer HH:MM:SS. This helper (and parse_datetime
    // through it) previously handled only HH:MM:SS, so a bare "0.167" on a dated
    // [TIMESERIES] row was truncated to 0 — corrupting the series and colliding
    // with the prior day's "24" row (dx == 0 -> spurious ERR 173).
    double dec_hours = 0.0;
    auto [dp, dec] = openswmm::from_chars_double(p, end, dec_hours);
    if (dec == std::errc{} && dp == end)
        return dec_hours / 24.0;
 
    unsigned h = 0, m = 0, s = 0;
    auto read_uint = [&](unsigned& out) -> bool {
        auto [np, ec] = std::from_chars(p, end, out);
        if (ec != std::errc{})
            return false;
        p = np;
        return true;
    };
 
    if (!read_uint(h))
        return 0.0;
    if (p < end && *p == ':')
        ++p;
    read_uint(m);
    if (p < end && *p == ':')
        ++p;
    read_uint(s);
 
    return datetime::encodeTime(static_cast<int>(h), static_cast<int>(m), static_cast<int>(s));
}

inline double parse_datetime(std::string_view date_sv, std::string_view time_sv) {
    return parse_date(date_sv) + parse_time_day_fraction(time_sv);
}
 
// ============================================================================
// Object registration
// ============================================================================

inline int add_unique(NameIndex& reg, const std::string& name, std::vector<std::string>& errors) {
    const int idx = reg.try_add(name);
    if (idx < 0) {
        const std::string* canon = reg.canonical(name);
        if (canon != nullptr && *canon != name) {
            errors.push_back(
                format_error(ERR_DUP_NAME, name,
                             "(matches existing ID '" + *canon + "'; names are case-insensitive)"));
        } else {
            errors.push_back(format_error(ERR_DUP_NAME, name));
        }
    }
    return idx;
}
 
} /* namespace openswmm::input */
 
#endif /* OPENSWMM_ENGINE_INPUT_PARSE_UTILS_HPP */