context.h

/*
Copyright (c) 2016 Alexei Novakov
https://github.com/novalexei

Distributed under the Boost Software License, Version 1.0.
http://boost.org/LICENSE_1_0.txt
*/
#ifndef MOD_SERVLET_CONTEXT_H
#define MOD_SERVLET_CONTEXT_H

#include <experimental/any>
#include <experimental/string_view>

#include <servlet/lib/any_map.h>
#include <servlet/lib/optional.h>

namespace servlet
{

using std::experimental::string_view;

class servlet_context
{
public:
    typedef std::map<std::string, std::string, std::less<>> init_params_map;

    virtual ~servlet_context() noexcept = default;

    const std::string& get_context_path() const { return _ctx_path; }

    const std::string& get_webapp_path() const { return _webapp_path; }

    template <typename T, typename KeyType>
    optional_ref<const T> get_attribute(const KeyType& key) const { return _attr_map.get<T>(key); }

    template <typename KeyType, typename ValueType>
    optional_ref<const ValueType> get_attribute(const KeyType& key) const
    {
        optional_ref<const any> found = get_attribute(key);
        if (!found.has_value()) return optional_ref<const ValueType>{};
        return optional_ref<const ValueType>{any_cast<const ValueType>(found.value())};
    }

    template <typename ValueType>
    bool set_attribute(const std::string &key, ValueType &&value) { return _attr_map.put(key, std::forward(value)); }

    template <typename ValueType>
    bool set_attribute(std::string &&key, ValueType &&value)
    { return _attr_map.put(std::move(key), std::forward(value)); }

    template <typename KeyType>
    bool remove_attribute(const KeyType& key) { return _attr_map.erase(key) > 0; }

    tree_any_map& get_attributes() { return _attr_map; }

    const tree_any_map& get_attributes() const { return _attr_map; }

    template <typename KeyType>
    optional_ref<const std::string> get_init_parameter(const KeyType& key) const
    {
        auto it = _init_params_map.find(key);
        return it == _init_params_map.end() ? optional_ref<const std::string>{} :
               optional_ref<const std::string>{it->second};
    }

    const init_params_map& get_init_parameters() const { return _init_params_map; }

    virtual optional_ref<const std::string> get_mime_type(string_view file_name) const = 0;

protected:
    servlet_context(const std::string& ctx_path, const std::string& webapp_path, init_params_map &&init_params) :
            _ctx_path{ctx_path}, _webapp_path{webapp_path}, _init_params_map{std::move(init_params)} {}

    const std::string& _ctx_path;
    tree_any_map _attr_map;
    init_params_map _init_params_map;

    const std::string& _webapp_path;
};

class servlet_config
{
public:
    servlet_config(const std::string &servlet_name) : _servlet_name{servlet_name} {}

    servlet_config(std::string &&servlet_name) : _servlet_name{std::move(servlet_name)} {}

    virtual ~servlet_config() noexcept = default;

    const std::string& get_servlet_name() const { return _servlet_name; }

    virtual const servlet_context& get_servlet_context() const = 0;

    template <typename KeyType>
    optional_ref<const std::string> get_init_parameter(const KeyType& key) const
    { return get_servlet_context().get_init_parameter(key); }

    const std::map<std::string, std::string, std::less<>>& get_init_parameters() const
    { return get_servlet_context().get_init_parameters(); }

protected:
    const std::string _servlet_name;
};

class filter_config
{
public:
    filter_config(const std::string &filter_name) : _filter_name{filter_name} {}

    filter_config(std::string &&filter_name) : _filter_name{std::move(filter_name)} {}

    virtual ~filter_config() noexcept = default;

    const std::string& get_filter_name() const { return _filter_name; }

    virtual servlet_context& get_servlet_context() = 0;

    template <typename KeyType>
    optional_ref<const std::string> get_init_parameter(const KeyType& key)
    { return get_servlet_context().get_init_parameter(key); }

    const std::map<std::string, std::string, std::less<>>& get_init_parameters()
    { return get_servlet_context().get_init_parameters(); }

protected:
    const std::string _filter_name;
};

} // end of servlet namespace

#endif // MOD_SERVLET_CONTEXT_H