path_matcher.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 "ravennakit/core/string_parser.hpp"
 
#include <map>
#include <string_view>
#include <boost/system/result.hpp>
#include <fmt/ostream.h>
 
namespace rav {
class PathMatcher {
  public:
    static constexpr auto k_loop_upper_bound = 100'000;
 
    enum class Error {
        invalid_recursive_wildcard,
        invalid_argument,
    };

    class Parameters {
      public:
        void set(const std::string_view name, const std::string_view value) {
            parameters_[std::string(name)] = std::string(value);
        }

        [[nodiscard]] const std::string* get(const std::string_view name) const {
            const auto it = parameters_.find(std::string(name));
            if (it != parameters_.end()) {
                return &it->second;
            }
            return nullptr;
        }

        template<typename T>
        std::enable_if_t<std::is_integral_v<T>, std::optional<T>> get_as(const std::string_view name) const {
            const auto it = parameters_.find(std::string(name));
            if (it != parameters_.end()) {
                return string_to_int<T>(it->second);
            }
            return std::nullopt;
        }

        [[nodiscard]] const std::map<std::string, std::string>& get_all() const {
            return parameters_;
        }

        [[nodiscard]] bool empty() const {
            return parameters_.empty();
        }

        void clear() {
            parameters_.clear();
        }
 
      private:
        std::map<std::string, std::string> parameters_;  // name => value
    };

    [[nodiscard]] static boost::system::result<bool, Error>
    match(const std::string_view path, const std::string_view pattern, Parameters* parameters = nullptr) {
        if (path.empty() || pattern.empty()) {
            return false;
        }
 
        StringParser path_parser(path);
        StringParser pattern_parser(pattern);
 
        path_parser.skip('/');
        pattern_parser.skip('/');
 
        auto path_section = path_parser.split('/');
        auto pattern_section = pattern_parser.split('/');
 
        for (size_t i = 0; i < k_loop_upper_bound; ++i) {
            if (!path_section && !pattern_section) {
                return true;
            }
 
            if (pattern_section == "**") {
                if (!pattern_parser.exhausted()) {
                    return Error::invalid_recursive_wildcard;
                }
                return true;
            }
 
            if (!path_section || !pattern_section) {
                return false;
            }
 
            if (path_section == pattern_section || pattern_section == "*") {
                path_section = path_parser.split('/');
                pattern_section = pattern_parser.split('/');
                continue;
            }
 
            StringParser parameter_parser(*pattern_section);
            const auto leading = parameter_parser.read_until('{');
            const auto parameter_name = parameter_parser.read_until('}');
            const auto trailing = parameter_parser.read_until_end();
 
            if (!leading) {
                return false;  // No '{' was found
            }
 
            if (!parameter_name || parameter_name->empty()) {
                return false;
            }
 
            auto parameter_value = *path_section;
 
            if (leading) {
                bool found = false;
                parameter_value = string_remove_prefix(parameter_value, *leading, &found);
                if (!found) {
                    return false;
                }
            }
 
            if (trailing) {
                bool found = false;
                parameter_value = string_remove_suffix(parameter_value, *trailing, &found);
                if (!found) {
                    return false;
                }
            }
 
            if (parameters == nullptr) {
                return Error::invalid_argument;
            }
 
            parameters->set(*parameter_name, parameter_value);
 
            path_section = path_parser.split('/');
            pattern_section = pattern_parser.split('/');
        }
 
        RAV_ASSERT_FALSE("PathMatcher::match() loop upper bound exceeded");
        return false;
    }
};
 
}  // namespace rav
 
// Make PathMatcher::Error printable with fmt
template<>
struct fmt::formatter<rav::PathMatcher::Error>: ostream_formatter {};
 
namespace rav {
 
// Make PathMatcher::Error compatible with ostream
inline std::ostream& operator<<(std::ostream& os, const PathMatcher::Error err) {
    switch (err) {
        case PathMatcher::Error::invalid_recursive_wildcard:
            os << "invalid_recursive_wildcard";
            break;
        case PathMatcher::Error::invalid_argument:
            os << "invalid_argument";
            break;
    }
    return os;
}
 
// Make PathMatcher::Error compatible with boost::system::result
BOOST_NORETURN BOOST_NOINLINE inline void throw_exception_from_error(PathMatcher::Error const& e, boost::source_location const& loc) {
    boost::throw_with_location(std::runtime_error(fmt::format("PathMatcher::Error: {}", e)), loc);
}
 
}  // namespace rav