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 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;
    };
 
    if (!read_uint(m)) return 0.0;
    if (p < end && *p == '/') ++p; else return 0.0;
    if (!read_uint(d)) return 0.0;
    if (p < end && *p == '/') ++p; else 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) {
    unsigned h = 0, m = 0, s = 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;
    };
 
    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 */