string.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-or-later
/*
 * Project: RAVENNAKIT (RAVENNA / AES67 / ST2110-30 SDK)
 * Copyright (c) 2024-2025 Sound on Digital
 *
 * This file is part of RAVENNAKIT.
 *
 * RAVENNAKIT is dual-licensed:
 *   1) Under the terms of the GNU Affero General Public License as published by
 *      the Free Software Foundation, either version 3 of the License, or
 *      (at your option) any later version (the "AGPL License"); and
 *   2) Under a commercial license from Sound on Digital, for customers who
 *      cannot (or do not wish to) comply with the AGPL License terms.
 *
 * If you obtained this file under the AGPL License, you may redistribute it
 * and/or modify it under the terms of the AGPL License. See the LICENSE
 * file in the project root for details.
 *
 * For commercial licensing, support, and other inquiries, please visit:
 *
 *     https://ravennakit.com
 *
 */
 
#pragma once
 
#include <algorithm>
#include <charconv>
#include <limits>
#include <optional>
#include <sstream>
#include <string_view>
#include <vector>
 
namespace rav {

inline std::string_view string_up_to_first_occurrence_of(
    std::string_view string_to_search_in, const std::string_view string_to_search_for, const bool include_sub_string_in_result
) {
    const auto pos = string_to_search_in.find(string_to_search_for);
 
    if (pos == std::string_view::npos)
        return {};
 
    return string_to_search_in.substr(0, include_sub_string_in_result ? pos + string_to_search_for.size() : pos);
}

inline std::string_view string_up_to_the_nth_occurrence_of(
    const size_t nth, std::string_view string_to_search_in, const std::string_view string_to_search_for,
    const bool include_sub_string_in_result
) {
    size_t pos = std::string_view::npos;
 
    for (size_t i = 0; i < nth; ++i) {
        pos = string_to_search_in.find(string_to_search_for, pos + 1);
 
        if (pos == std::string_view::npos) {
            return {};
        }
    }
 
    if (pos == std::string_view::npos) {
        return {};
    }
 
    return string_to_search_in.substr(0, include_sub_string_in_result ? pos + string_to_search_for.size() : pos);
}

inline std::string_view string_up_to_last_occurrence_of(
    const std::string_view string_to_search_in, const std::string_view string_to_search_for, const bool include_sub_string_in_result
) {
    const auto pos = string_to_search_in.rfind(string_to_search_for);
 
    if (pos == std::string_view::npos)
        return {};
 
    return string_to_search_in.substr(0, include_sub_string_in_result ? pos + string_to_search_for.size() : pos);
}

inline std::string_view string_from_first_occurrence_of(
    std::string_view string_to_search_in, const std::string_view string_to_search_for, const bool include_sub_string_in_result
) {
    const auto pos = string_to_search_in.find(string_to_search_for);
 
    if (pos == std::string_view::npos)
        return {};
 
    return string_to_search_in.substr(include_sub_string_in_result ? pos : pos + string_to_search_for.size());
}

inline std::string_view string_from_nth_occurrence_of(
    const size_t nth, std::string_view string_to_search_in, const std::string_view string_to_search_for,
    const bool include_sub_string_in_result
) {
    size_t pos = std::string_view::npos;
 
    for (size_t i = 0; i < nth; ++i) {
        pos = string_to_search_in.find(string_to_search_for, pos + 1);
 
        if (pos == std::string_view::npos) {
            return {};
        }
    }
 
    if (pos == std::string_view::npos) {
        return {};
    }
 
    return string_to_search_in.substr(include_sub_string_in_result ? pos : pos + string_to_search_for.size(), string_to_search_in.size());
}

inline std::string_view string_from_last_occurrence_of(
    const std::string_view string_to_search_in, const std::string_view string_to_search_for, const bool include_sub_string_in_result
) {
    const auto pos = string_to_search_in.rfind(string_to_search_for);
 
    if (pos == std::string_view::npos) {
        return {};
    }
 
    return string_to_search_in.substr(include_sub_string_in_result ? pos : pos + string_to_search_for.size());
}

inline std::string_view
string_remove_prefix(const std::string_view& string, const std::string_view prefix_to_remove, bool* found = nullptr) {
    const auto pos = string.find(prefix_to_remove);
 
    if (pos != 0) {
        if (found) {
            *found = false;
        }
        return string;
    }
 
    if (found) {
        *found = true;
    }
 
    return string.substr(pos + prefix_to_remove.size());
}

inline std::string_view
string_remove_suffix(const std::string_view& string, const std::string_view suffix_to_remove, bool* found = nullptr) {
    const auto pos = string.rfind(suffix_to_remove);
 
    if (pos != string.size() - suffix_to_remove.size()) {
        if (found) {
            *found = false;
        }
        return string;
    }
 
    if (found) {
        *found = true;
    }
 
    return string.substr(0, pos);
}

inline std::string_view string_trim(const std::string_view input) {
    if (input.empty()) {
        return {};
    }
 
    // Find first non-whitespace character
    size_t start = 0;
    while (start < input.size() && std::isspace(input[start])) {
        ++start;
    }
 
    // If all characters are whitespace
    if (start == input.size()) {
        return std::string_view {};
    }
 
    // Find last non-whitespace character
    size_t end = input.size() - 1;
    while (end > start && std::isspace(input[end])) {
        --end;
    }
 
    return input.substr(start, end - start + 1);
}

template<typename Type>
std::enable_if_t<std::is_integral_v<Type>, std::optional<Type>>
string_to_int(std::string_view string, const bool strict = false, const int base = 10) {
    Type result {};
    auto [p, ec] = std::from_chars(string.data(), string.data() + string.size(), result, base);
    if (ec == std::errc() && (!strict || p >= string.data() + string.size()))
        return result;
    return {};
}

inline std::optional<float> string_to_float(const std::string& str) {
    try {
        return std::stof(str);
    } catch (...) {
        return std::nullopt;
    }
}

inline std::optional<double> string_to_double(const std::string& str) {
    try {
        return std::stod(str);
    } catch (...) {
        return std::nullopt;
    }
}

inline bool string_starts_with(const std::string_view text, const std::string_view starts_with) {
    return text.rfind(starts_with, 0) == 0;
}

inline bool string_ends_with(const std::string_view text, const std::string_view ends_with) {
    if (ends_with.length() > text.length()) {
        return false;
    }
    return text.compare(text.length() - ends_with.length(), ends_with.length(), ends_with) == 0;
}

inline bool string_contains(const std::string_view string, char c) {
    return std::any_of(string.begin(), string.end(), [c](const char& item) {
        return item == c;
    });
}

inline bool string_contains(const std::string_view string, const std::string_view sub_string) {
    return string.find(sub_string) != std::string_view::npos;
}

inline std::vector<std::string> string_split(const std::string& string, const char* delimiter) {
    std::vector<std::string> results;
 
    size_t prev = 0;
    size_t next = 0;
 
    while ((next = string.find_first_of(delimiter, prev)) != std::string::npos) {
        if (next - prev != 0) {
            results.push_back(string.substr(prev, next - prev));
        }
        prev = next + 1;
    }
 
    if (prev < string.size()) {
        results.push_back(string.substr(prev));
    }
 
    return results;
}

inline std::vector<std::string> string_split(const std::string& string, const char delimiter) {
    const char delimiter_string[2] = {delimiter, '\0'};
    return string_split(string, delimiter_string);
}

inline std::string string_replace(const std::string_view original, const std::string_view to_replace, const std::string_view replacement) {
    auto modified = std::string(original);
    size_t pos = 0;
 
    while ((pos = modified.find(to_replace, pos)) != std::string::npos) {
        modified.replace(pos, to_replace.length(), replacement);
        pos += replacement.length();  // Move past the replacement to avoid infinite loop
    }
 
    return modified;
}

inline std::string_view string_unquoted(std::string_view input) {
    input = string_trim(input);
 
    if (input.size() < 2) {
        return input;  // NOLINT
    }
 
    const char first = input.front();
    const char last = input.back();
 
    // Only unquote if there are matching quotes at both beginning AND end
    if ((first == '"' && last == '"') || (first == '\'' && last == '\'')) {
        return input.substr(1, input.size() - 2);
    }
 
    // If quotes don't match or aren't at both ends, return unchanged
    return input;  // NOLINT
}

inline bool string_compare_case_insensitive(const std::string_view lhs, const std::string_view rhs) {
    if (lhs.size() != rhs.size()) {
        return false;
    }
 
    for (size_t i = 0; i < lhs.size(); ++i) {
        if (std::tolower(lhs[i]) != std::tolower(rhs[i])) {
            return false;
        }
    }
 
    return true;
}

inline std::string string_to_upper(const std::string& str, std::size_t count = std::numeric_limits<size_t>::max()) {
    if (str.empty() || count == 0) {
        return str;
    }
    std::string result = str;
    count = std::min(count, result.size());
    for (std::size_t i = 0; i < count; ++i) {
        result[i] = static_cast<char>(std::toupper(static_cast<unsigned char>(result[i])));
    }
    return result;
}

inline std::string string_to_lower(const std::string& str, std::size_t count = std::numeric_limits<size_t>::max()) {
    if (str.empty() || count == 0) {
        return str;
    }
    std::string result = str;
    count = std::min(count, result.size());
    for (std::size_t i = 0; i < count; ++i) {
        result[i] = static_cast<char>(std::tolower(static_cast<unsigned char>(result[i])));
    }
    return result;
}
 
}  // namespace rav