route_muxer.hpp

Go to the documentation of this file.

/*
 * Copyright 2020 Robert Bosch GmbH
 *
 * 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.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#pragma once

#include <algorithm>
#include <map>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>

#include <boost/algorithm/string/predicate.hpp>
#include <boost/filesystem/path.hpp>
#include <boost/thread/locks.hpp>
#include <boost/thread/shared_mutex.hpp>

namespace oak {

using Parameters = std::map<std::string, std::string>;

template <typename T>
class Muxer {
 public:
  static std::string normalize(const std::string& route) {
    std::string s = route.substr(0, route.find("?"));
    boost::filesystem::path p(s);
    if (!p.is_absolute()) {
      return "";
    }
    s = p.normalize().string();
    s = s.substr(0, s.find_last_not_of("/. \n\t\r") + 1);
    if (s.empty()) {
      return "/";
    }
    return s;
  }

  static bool is_identifier(const std::string& s) {
    auto is_illegal = [](char c) -> bool {
      return !(isalnum(c) || c == '_' || c == '-' || c == '.');
    };
    return std::find_if(s.begin(), s.end(), is_illegal) == s.end();
  }

  std::string resolve(const std::string& route) const {
    auto key = normalize(route);
    boost::shared_lock<boost::shared_mutex> read_lock(access_);
    if (!backtrack_) {
      if (routes_.count(key)) {
        return key;
      }
      return "";
    } else {
      boost::filesystem::path p(key);
      while (!routes_.count(p.string())) {
        p = p.parent_path();
      }
      return p.string();
    }
  }

  void set_backtrack(bool enabled) {
    boost::unique_lock<boost::shared_mutex> write_lock(access_);
    backtrack_ = enabled;
  }

  void set_default(T def) { routes_[""] = def; }

  std::vector<std::string> routes() const {
    std::vector<std::string> vs;
    boost::shared_lock<boost::shared_mutex> read_lock(access_);
    for (const auto& kv : routes_) {
      if (kv.first.empty()) {
        continue;
      }
      vs.push_back(kv.first);
    }
    return vs;
  }

  bool has(const std::string& route) const {
    auto key = normalize(route);
    boost::shared_lock<boost::shared_mutex> read_lock(access_);
    return routes_.count(key) != 0;
  }

  void add(const std::string& route, T val) {
    auto key = normalize(route);
    boost::unique_lock<boost::shared_mutex> write_lock(access_);
    if (routes_.count(key)) {
      throw std::runtime_error("route already exists");
    }
    routes_[key] = val;
  }

  void set(const std::string& route, T val) {
    auto key = normalize(route);
    boost::unique_lock<boost::shared_mutex> write_lock(access_);
    routes_[key] = val;
  }

  std::pair<T, Parameters> get(const std::string& route) const {
    auto key = resolve(route);
    Parameters p{};
    boost::shared_lock<boost::shared_mutex> read_lock(access_);
    return std::make_pair(routes_.at(key), p);
  }

  void set_unsafe(const std::string& key, T val) {
    boost::unique_lock<boost::shared_mutex> write_lock(access_);
    routes_[key] = val;
  }

  std::pair<T, Parameters> get_unsafe(const std::string& key) const {
    Parameters p{};
    boost::shared_lock<boost::shared_mutex> read_lock(access_);
    return std::make_pair(routes_.at(key), p);
  }

 private:
  // Configuration:
  bool backtrack_ = false;

  // State:
  std::map<std::string, T> routes_;
  mutable boost::shared_mutex access_;
};

}  // namespace oak