options.hh

#ifndef VTESTBED_ASSETS_OPTIONS_HH
#define VTESTBED_ASSETS_OPTIONS_HH

#include <any>
#include <string>
#include <unordered_map>

namespace vtb {

    namespace assets {

        class Options: public std::unordered_map<std::string,std::any> {

        private:
            using base_type = std::unordered_map<std::string,std::any>;

        public:
            using key_type = typename base_type::key_type;
            using value_type = typename base_type::value_type;
            using mapped_type = typename base_type::mapped_type;
            using hasher = typename base_type::hasher;
            using key_equal = typename base_type::key_equal;
            using allocator_type = typename base_type::allocator_type;
            using pointer = typename base_type::pointer;
            using const_pointer = typename base_type::const_pointer;
            using reference = typename base_type::reference;
            using const_reference = typename base_type::const_reference;
            using iterator = typename base_type::iterator;
            using const_iterator = typename base_type::const_iterator;
            using local_iterator = typename base_type::local_iterator;
            using const_local_iterator = typename base_type::const_local_iterator;
            using size_type = typename base_type::size_type;
            using difference_type = typename base_type::difference_type;

        public:
            using base_type::base_type;
            using base_type::operator=;
            using base_type::operator[];

            inline const std::any&
            get(const std::string& key, const std::any& default_value) const {
                auto result = this->find(key);
                if (result == this->end()) { return default_value; }
                return result->second;
            }

            template <class T> inline T
            get(const std::string& key, T default_value) const {
                auto result = this->find(key);
                if (result == this->end()) { return default_value; }
                return std::any_cast<T>(result->second);
            }

            template <class T> inline T
            get(const std::string& key) const {
                auto result = this->find(key);
                if (result == this->end()) { throw std::invalid_argument(key); }
                return std::any_cast<T>(result->second);
            }

            inline std::string
            string(const std::string& key) const {
                return get<std::string>(key);
            }

            void read(const std::string& text);
            void read(const std::string& key, const std::string& value);

        };

    }

}

#endif // vim:filetype=cpp