data_frame.hpp

#pragma once
 
#include <algorithm>
#include <functional>
#include <iterator>
#include <memory>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include "csv_reader.hpp"
 
namespace csv {
    namespace internals {
        template<typename T>
        class is_hashable {
        private:
            template<typename U>
            static auto test(int) -> decltype(
                std::hash<U>{}(std::declval<const U&>()),
                std::true_type{}
            );
 
            template<typename>
            static std::false_type test(...);
 
        public:
            static constexpr bool value = decltype(test<T>(0))::value;
        };
 
        template<typename T>
        class is_equality_comparable {
        private:
            template<typename U>
            static auto test(int) -> decltype(
                std::declval<const U&>() == std::declval<const U&>(),
                std::true_type{}
            );
 
            template<typename>
            static std::false_type test(...);
 
        public:
            static constexpr bool value = decltype(test<T>(0))::value;
        };
    }
 
    class DataFrameOptions {
    public:
        DataFrameOptions() = default;
 
        enum class DuplicateKeyPolicy {
            THROW,      // Throw an error if a duplicate key is encountered
            OVERWRITE,  // Overwrite the existing value with the new value
            KEEP_FIRST  // Ignore the new value and keep the existing value
        };
 
        DataFrameOptions& set_duplicate_key_policy(DuplicateKeyPolicy value) {
            this->duplicate_key_policy = value;
            return *this;
        }
 
        DuplicateKeyPolicy get_duplicate_key_policy() const {
            return this->duplicate_key_policy;
        }
 
        DataFrameOptions& set_key_column(const std::string& value) {
            this->key_column = value;
            return *this;
        }
 
        const std::string& get_key_column() const {
            return this->key_column;
        }
 
        DataFrameOptions& set_throw_on_missing_key(bool value) {
            this->throw_on_missing_key = value;
            return *this;
        }
 
        bool get_throw_on_missing_key() const {
            return this->throw_on_missing_key;
        }
 
    private:
        std::string key_column;
 
        DuplicateKeyPolicy duplicate_key_policy = DuplicateKeyPolicy::OVERWRITE;
 
        bool throw_on_missing_key = true;
    };
 
    template<typename KeyType>
    class DataFrameRow {
    public:
        DataFrameRow() : row(nullptr), row_edits(nullptr), key_ptr(nullptr) {}
 
        DataFrameRow(
            const CSVRow* _row,
            const std::unordered_map<std::string, std::string>* _edits,
            const KeyType* _key
        ) : row(_row), row_edits(_edits), key_ptr(_key) {}
 
        CSVField operator[](const std::string& col) const {
            if (row_edits) {
                auto it = row_edits->find(col);
                if (it != row_edits->end()) {
                    return CSVField(csv::string_view(it->second));
                }
            }
            return (*row)[col];
        }
 
        CSVField operator[](size_t n) const {
            return (*row)[n];
        }
 
        size_t size() const { return row->size(); }
 
        bool empty() const { return row->empty(); }
 
        std::vector<std::string> get_col_names() const { return row->get_col_names(); }
 
        const CSVRow& get_underlying_row() const { return *row; }
 
        const KeyType& get_key() const { return *key_ptr; }
 
        operator std::vector<std::string>() const {
            std::vector<std::string> result;
            result.reserve(row->size());
            
            auto col_names = row->get_col_names();
            for (size_t i = 0; i < row->size(); i++) {
                // Check if this column has an edit
                if (row_edits && i < col_names.size()) {
                    auto it = row_edits->find(col_names[i]);
                    if (it != row_edits->end()) {
                        result.push_back(it->second);
                        continue;
                    }
                }
                // Use original value
                result.push_back((*row)[i].get<std::string>());
            }
            return result;
        }
 
        std::string to_json(const std::vector<std::string>& subset = {}) const {
            return row->to_json(subset);
        }
 
        std::string to_json_array(const std::vector<std::string>& subset = {}) const {
            return row->to_json_array(subset);
        }
 
    private:
        const CSVRow* row;
        const std::unordered_map<std::string, std::string>* row_edits;
        const KeyType* key_ptr;
    };
 
    template<typename KeyType = std::string>
    class DataFrame {
    public:
        using row_entry = std::pair<KeyType, CSVRow>;
 
        class iterator {
        public:
            using value_type = DataFrameRow<KeyType>;
            using difference_type = std::ptrdiff_t;
            using pointer = const DataFrameRow<KeyType>*;
            using reference = const DataFrameRow<KeyType>&;
            using iterator_category = std::random_access_iterator_tag;
 
            iterator() = default;
            iterator(
                typename std::vector<row_entry>::iterator it,
                const std::unordered_map<KeyType, std::unordered_map<std::string, std::string>>* edits
            ) : iter(it), edits_map(edits) {}
 
            reference operator*() const {
                const std::unordered_map<std::string, std::string>* row_edits = nullptr;
                if (edits_map) {
                    auto it = edits_map->find(iter->first);
                    if (it != edits_map->end()) {
                        row_edits = &it->second;
                    }
                }
                cached_row = DataFrameRow<KeyType>(&iter->second, row_edits, &iter->first);
                return cached_row;
            }
 
            pointer operator->() const {
                // Ensure cached_row is populated
                operator*();
                return &cached_row;
            }
 
            iterator& operator++() { ++iter; return *this; }
            iterator operator++(int) { auto tmp = *this; ++iter; return tmp; }
            iterator& operator--() { --iter; return *this; }
            iterator operator--(int) { auto tmp = *this; --iter; return tmp; }
 
            iterator operator+(difference_type n) const { return iterator(iter + n, edits_map); }
            iterator operator-(difference_type n) const { return iterator(iter - n, edits_map); }
            difference_type operator-(const iterator& other) const { return iter - other.iter; }
 
            bool operator==(const iterator& other) const { return iter == other.iter; }
            bool operator!=(const iterator& other) const { return iter != other.iter; }
 
        private:
            typename std::vector<row_entry>::iterator iter;
            const std::unordered_map<KeyType, std::unordered_map<std::string, std::string>>* edits_map = nullptr;
            mutable DataFrameRow<KeyType> cached_row;
        };
 
        class const_iterator {
        public:
            using value_type = DataFrameRow<KeyType>;
            using difference_type = std::ptrdiff_t;
            using pointer = const DataFrameRow<KeyType>*;
            using reference = const DataFrameRow<KeyType>&;
            using iterator_category = std::random_access_iterator_tag;
 
            const_iterator() = default;
            const_iterator(
                typename std::vector<row_entry>::const_iterator it,
                const std::unordered_map<KeyType, std::unordered_map<std::string, std::string>>* edits
            ) : iter(it), edits_map(edits) {}
 
            reference operator*() const {
                const std::unordered_map<std::string, std::string>* row_edits = nullptr;
                if (edits_map) {
                    auto it = edits_map->find(iter->first);
                    if (it != edits_map->end()) {
                        row_edits = &it->second;
                    }
                }
                cached_row = DataFrameRow<KeyType>(&iter->second, row_edits, &iter->first);
                return cached_row;
            }
 
            pointer operator->() const {
                // Ensure cached_row is populated
                operator*();
                return &cached_row;
            }
 
            const_iterator& operator++() { ++iter; return *this; }
            const_iterator operator++(int) { auto tmp = *this; ++iter; return tmp; }
            const_iterator& operator--() { --iter; return *this; }
            const_iterator operator--(int) { auto tmp = *this; --iter; return tmp; }
 
            const_iterator operator+(difference_type n) const { return const_iterator(iter + n, edits_map); }
            const_iterator operator-(difference_type n) const { return const_iterator(iter - n, edits_map); }
            difference_type operator-(const const_iterator& other) const { return iter - other.iter; }
 
            bool operator==(const const_iterator& other) const { return iter == other.iter; }
            bool operator!=(const const_iterator& other) const { return iter != other.iter; }
 
        private:
            typename std::vector<row_entry>::const_iterator iter;
            const std::unordered_map<KeyType, std::unordered_map<std::string, std::string>>* edits_map = nullptr;
            mutable DataFrameRow<KeyType> cached_row;
        };
 
        static_assert(
            internals::is_hashable<KeyType>::value,
            "DataFrame<KeyType> requires KeyType to be hashable (std::hash<KeyType> specialization required)."
        );
 
        static_assert(
            internals::is_equality_comparable<KeyType>::value,
            "DataFrame<KeyType> requires KeyType to be equality comparable (operator== required)."
        );
 
        static_assert(
            std::is_default_constructible<KeyType>::value,
            "DataFrame<KeyType> requires KeyType to be default-constructible."
        );
 
        using DuplicateKeyPolicy = DataFrameOptions::DuplicateKeyPolicy;
 
        DataFrame() = default;
 
        explicit DataFrame(CSVReader& reader) {
            this->init_unkeyed_from_reader(reader);
        }
 
        explicit DataFrame(CSVReader& reader, const DataFrameOptions& options) {
            this->init_from_reader(reader, options);
        }
 
        DataFrame(
            csv::string_view filename,
            const DataFrameOptions& options,
            CSVFormat format = CSVFormat::guess_csv()
        ) {
            CSVReader reader(filename, format);
            this->init_from_reader(reader, options);
        }
 
        DataFrame(
            CSVReader& reader,
            const std::string& _key_column,
            DuplicateKeyPolicy policy = DuplicateKeyPolicy::OVERWRITE,
            bool throw_on_missing_key = true
        ) : DataFrame(
            reader,
            DataFrameOptions()
                .set_key_column(_key_column)
                .set_duplicate_key_policy(policy)
                .set_throw_on_missing_key(throw_on_missing_key)
        ) {}
 
        template<
            typename KeyFunc,
            typename ResultType = invoke_result_t<KeyFunc, const CSVRow&>,
            csv::enable_if_t<std::is_convertible<ResultType, KeyType>::value, int> = 0
        >
        DataFrame(
            CSVReader& reader,
            KeyFunc key_func,
            DuplicateKeyPolicy policy = DuplicateKeyPolicy::OVERWRITE
        ) : col_names(reader.get_col_names()) {
            this->is_keyed = true;
            this->build_from_key_function(reader, key_func, policy);
        }
 
        template<
            typename KeyFunc,
            typename ResultType = invoke_result_t<KeyFunc, const CSVRow&>,
            csv::enable_if_t<std::is_convertible<ResultType, KeyType>::value, int> = 0
        >
        DataFrame(
            CSVReader& reader,
            KeyFunc key_func,
            const DataFrameOptions& options
        ) : DataFrame(reader, key_func, options.get_duplicate_key_policy()) {}
 
        size_t size() const noexcept {
            return rows.size();
        }
 
        bool empty() const noexcept {
            return rows.empty();
        }
 
        size_t n_rows() const noexcept { return rows.size(); }
        
        size_t n_cols() const noexcept { return col_names.size(); }
 
        bool has_column(const std::string& name) const {
            return std::find(col_names.begin(), col_names.end(), name) != col_names.end();
        }
 
        int index_of(const std::string& name) const {
            auto it = std::find(col_names.begin(), col_names.end(), name);
            if (it == col_names.end())
                return CSV_NOT_FOUND;
            return static_cast<int>(std::distance(col_names.begin(), it));
        }
 
        const std::vector<std::string>& columns() const noexcept {
            return col_names;
        }
 
        const std::string& key_name() const noexcept {
            return key_column;
        }
 
        template<typename K = KeyType,
            csv::enable_if_t<!std::is_integral<K>::value, int> = 0>
        DataFrameRow<KeyType> operator[](size_t i) {
            static_assert(std::is_same<K, KeyType>::value,
                "Do not explicitly instantiate this template. Use iloc() for positional access.");
            return this->iloc(i);
        }
 
        template<typename K = KeyType,
            csv::enable_if_t<!std::is_integral<K>::value, int> = 0>
        DataFrameRow<KeyType> operator[](size_t i) const {
            static_assert(std::is_same<K, KeyType>::value,
                "Do not explicitly instantiate this template. Use iloc() for positional access.");
            return this->iloc(i);
        }
 
        DataFrameRow<KeyType> at(size_t i) {
            const std::unordered_map<std::string, std::string>* row_edits = nullptr;
            if (is_keyed) {
                auto it = edits.find(rows.at(i).first);
                if (it != edits.end()) row_edits = &it->second;
            }
            return DataFrameRow<KeyType>(&rows.at(i).second, row_edits, &rows.at(i).first);
        }
        
        DataFrameRow<KeyType> at(size_t i) const {
            const std::unordered_map<std::string, std::string>* row_edits = nullptr;
            if (is_keyed) {
                auto it = edits.find(rows.at(i).first);
                if (it != edits.end()) row_edits = &it->second;
            }
            return DataFrameRow<KeyType>(&rows.at(i).second, row_edits, &rows.at(i).first);
        }
 
        DataFrameRow<KeyType> operator[](const KeyType& key) {
            this->require_keyed_frame();
            auto position = this->position_of(key);
            const std::unordered_map<std::string, std::string>* row_edits = nullptr;
            auto it = edits.find(key);
            if (it != edits.end()) row_edits = &it->second;
            return DataFrameRow<KeyType>(&rows[position].second, row_edits, &rows[position].first);
        }
 
        DataFrameRow<KeyType> operator[](const KeyType& key) const {
            this->require_keyed_frame();
            auto position = this->position_of(key);
            const std::unordered_map<std::string, std::string>* row_edits = nullptr;
            auto it = edits.find(key);
            if (it != edits.end()) row_edits = &it->second;
            return DataFrameRow<KeyType>(&rows[position].second, row_edits, &rows[position].first);
        }
 
        DataFrameRow<KeyType> iloc(size_t i) {
            const std::unordered_map<std::string, std::string>* row_edits = nullptr;
            if (is_keyed) {
                auto it = edits.find(rows.at(i).first);
                if (it != edits.end()) row_edits = &it->second;
            }
            return DataFrameRow<KeyType>(&rows.at(i).second, row_edits, &rows.at(i).first);
        }
 
        DataFrameRow<KeyType> iloc(size_t i) const {
            const std::unordered_map<std::string, std::string>* row_edits = nullptr;
            if (is_keyed) {
                auto it = edits.find(rows.at(i).first);
                if (it != edits.end()) row_edits = &it->second;
            }
            return DataFrameRow<KeyType>(&rows.at(i).second, row_edits, &rows.at(i).first);
        }
 
        bool try_get(size_t i, DataFrameRow<KeyType>& out) {
            if (i >= rows.size()) {
                return false;
            }
            const std::unordered_map<std::string, std::string>* row_edits = nullptr;
            if (is_keyed) {
                auto it = edits.find(rows[i].first);
                if (it != edits.end()) row_edits = &it->second;
            }
            out = DataFrameRow<KeyType>(&rows[i].second, row_edits, &rows[i].first);
            return true;
        }
 
        bool try_get(size_t i, DataFrameRow<KeyType>& out) const {
            if (i >= rows.size()) {
                return false;
            }
            const std::unordered_map<std::string, std::string>* row_edits = nullptr;
            if (is_keyed) {
                auto it = edits.find(rows[i].first);
                if (it != edits.end()) row_edits = &it->second;
            }
            out = DataFrameRow<KeyType>(&rows[i].second, row_edits, &rows[i].first);
            return true;
        }
 
        const KeyType& key_at(size_t i) const {
            this->require_keyed_frame();
            return rows.at(i).first;
        }
 
        bool contains(const KeyType& key) const {
            this->require_keyed_frame();
            this->ensure_key_index();
            return key_index->find(key) != key_index->end();
        }
 
        DataFrameRow<KeyType> at(const KeyType& key) {
            this->require_keyed_frame();
            auto position = this->position_of(key);
            const std::unordered_map<std::string, std::string>* row_edits = nullptr;
            auto it = edits.find(key);
            if (it != edits.end()) row_edits = &it->second;
            return DataFrameRow<KeyType>(&rows.at(position).second, row_edits, &rows.at(position).first);
        }
 
        DataFrameRow<KeyType> at(const KeyType& key) const {
            this->require_keyed_frame();
            auto position = this->position_of(key);
            const std::unordered_map<std::string, std::string>* row_edits = nullptr;
            auto it = edits.find(key);
            if (it != edits.end()) row_edits = &it->second;
            return DataFrameRow<KeyType>(&rows.at(position).second, row_edits, &rows.at(position).first);
        }
 
        bool try_get(const KeyType& key, DataFrameRow<KeyType>& out) {
            this->require_keyed_frame();
            this->ensure_key_index();
            auto it = key_index->find(key);
            if (it == key_index->end()) {
                return false;
            }
            const std::unordered_map<std::string, std::string>* row_edits = nullptr;
            auto edit_it = edits.find(key);
            if (edit_it != edits.end()) row_edits = &edit_it->second;
            out = DataFrameRow<KeyType>(&rows[it->second].second, row_edits, &rows[it->second].first);
            return true;
        }
 
        bool try_get(const KeyType& key, DataFrameRow<KeyType>& out) const {
            this->require_keyed_frame();
            this->ensure_key_index();
            auto it = key_index->find(key);
            if (it == key_index->end()) {
                return false;
            }
            const std::unordered_map<std::string, std::string>* row_edits = nullptr;
            auto edit_it = edits.find(key);
            if (edit_it != edits.end()) row_edits = &edit_it->second;
            out = DataFrameRow<KeyType>(&rows[it->second].second, row_edits, &rows[it->second].first);
            return true;
        }
 
        std::string get(const KeyType& key, const std::string& column) const {
            this->require_keyed_frame();
 
            auto row_edits = this->edits.find(key);
            if (row_edits != this->edits.end()) {
                auto value = row_edits->second.find(column);
                if (value != row_edits->second.end()) {
                    return value->second;
                }
            }
 
            return (*this)[key][column].template get<std::string>();
        }
 
        void set(const KeyType& key, const std::string& column, const std::string& value) {
            this->require_keyed_frame();
            (void)this->position_of(key);
            edits[key][column] = value;
        }
 
        bool erase_row(const KeyType& key) {
            this->require_keyed_frame();
            this->ensure_key_index();
 
            auto it = key_index->find(key);
            if (it == key_index->end()) {
                return false;
            }
 
            rows.erase(rows.begin() + it->second);
            edits.erase(key);
            this->invalidate_key_index();
            return true;
        }
 
        bool erase_row_at(size_t i) {
            if (i >= rows.size()) return false;
            if (is_keyed) edits.erase(rows[i].first);
 
            rows.erase(rows.begin() + i);
            this->invalidate_key_index();
            return true;
        }
 
        void set_at(size_t i, const std::string& column, const std::string& value) {
            if (!is_keyed) {
                throw std::runtime_error("This DataFrame was created without a key column.");
            }
            if (i >= rows.size()) {
                throw std::out_of_range("Row index out of bounds.");
            }
            edits[rows[i].first][column] = value;
        }
 
        template<typename T = std::string>
        std::vector<T> column(const std::string& name) const {
            if (std::find(col_names.begin(), col_names.end(), name) == col_names.end()) {
                throw std::runtime_error("Column not found: " + name);
            }
 
            std::vector<T> values;
            values.reserve(rows.size());
 
            for (const auto& entry : rows) {
                auto row_edits = this->edits.find(entry.first);
                if (row_edits != this->edits.end()) {
                    auto value = row_edits->second.find(name);
                    if (value != row_edits->second.end()) {
                        // Reuse CSVField parsing/validation on edited string values.
                        CSVField edited_field(csv::string_view(value->second));
                        values.push_back(edited_field.template get<T>());
                        continue;
                    }
                }
 
                values.push_back(entry.second[name].template get<T>());
            }
 
            return values;
        }
 
        template<
            typename GroupFunc,
            typename GroupKey = invoke_result_t<GroupFunc, const CSVRow&>,
            csv::enable_if_t<
                internals::is_hashable<GroupKey>::value &&
                internals::is_equality_comparable<GroupKey>::value,
                int
            > = 0
        >
        std::unordered_map<GroupKey, std::vector<size_t>> group_by(GroupFunc group_func) const {
            std::unordered_map<GroupKey, std::vector<size_t>> grouped;
 
            for (size_t i = 0; i < rows.size(); i++) {
                GroupKey group_key = group_func(rows[i].second);
                grouped[group_key].push_back(i);
            }
 
            return grouped;
        }
 
        std::unordered_map<std::string, std::vector<size_t>> group_by(
            const std::string& name,
            bool use_edits = true
        ) const {
            if (std::find(col_names.begin(), col_names.end(), name) == col_names.end()) {
                throw std::runtime_error("Column not found: " + name);
            }
 
            std::unordered_map<std::string, std::vector<size_t>> grouped;
 
            for (size_t i = 0; i < rows.size(); i++) {
                std::string group_key;
                bool has_group_key = false;
 
                if (use_edits) {
                    auto row_edits = this->edits.find(rows[i].first);
                    if (row_edits != this->edits.end()) {
                        auto edited_value = row_edits->second.find(name);
                        if (edited_value != row_edits->second.end()) {
                            group_key = edited_value->second;
                            has_group_key = true;
                        }
                    }
                }
 
                if (!has_group_key) {
                    group_key = rows[i].second[name].template get<std::string>();
                }
 
                grouped[group_key].push_back(i);
            }
 
            return grouped;
        }
 
        iterator begin() { return iterator(rows.begin(), is_keyed ? &edits : nullptr); }
        
        iterator end() { return iterator(rows.end(), is_keyed ? &edits : nullptr); }
        
        const_iterator begin() const { return const_iterator(rows.begin(), is_keyed ? &edits : nullptr); }
        
        const_iterator end() const { return const_iterator(rows.end(), is_keyed ? &edits : nullptr); }
        
        const_iterator cbegin() const { return const_iterator(rows.begin(), is_keyed ? &edits : nullptr); }
        
        const_iterator cend() const { return const_iterator(rows.end(), is_keyed ? &edits : nullptr); }
 
    private:
        std::string key_column;
        
        bool is_keyed = false;
        
        std::vector<std::string> col_names;
        
        std::vector<row_entry> rows;
 
        mutable std::unique_ptr<std::unordered_map<KeyType, size_t>> key_index;
 
        std::unordered_map<KeyType, std::unordered_map<std::string, std::string>> edits;
 
        void init_unkeyed_from_reader(CSVReader& reader) {
            this->col_names = reader.get_col_names();
            for (auto& row : reader) {
                rows.push_back(row_entry{KeyType(), row});
            }
        }
 
        void init_from_reader(CSVReader& reader, const DataFrameOptions& options) {
            this->is_keyed = true;
            this->key_column = options.get_key_column();
            this->col_names = reader.get_col_names();
 
            if (key_column.empty()) {
                throw std::runtime_error("Key column cannot be empty.");
            }
 
            if (std::find(col_names.begin(), col_names.end(), key_column) == col_names.end()) {
                throw std::runtime_error("Key column not found: " + key_column);
            }
 
            const bool throw_on_missing_key = options.get_throw_on_missing_key();
 
            this->build_from_key_function(
                reader,
                [this, throw_on_missing_key](const CSVRow& row) -> KeyType {
                    try {
                        return row[this->key_column].template get<KeyType>();
                    }
                    catch (const std::exception& e) {
                        if (throw_on_missing_key) {
                            throw std::runtime_error("Error retrieving key column value: " + std::string(e.what()));
                        }
 
                        return KeyType();
                    }
                },
                options.get_duplicate_key_policy()
            );
        }
 
        template<typename KeyFunc>
        void build_from_key_function(
            CSVReader& reader,
            KeyFunc key_func,
            DuplicateKeyPolicy policy
        ) {
            std::unordered_map<KeyType, size_t> key_to_pos;
 
            for (auto& row : reader) {
                KeyType key = key_func(row);
 
                auto existing = key_to_pos.find(key);
                if (existing != key_to_pos.end()) {
                    if (policy == DuplicateKeyPolicy::THROW) {
                        throw std::runtime_error("Duplicate key encountered.");
                    }
 
                    if (policy == DuplicateKeyPolicy::OVERWRITE) {
                        rows[existing->second].second = row;
                    }
 
                    continue;
                }
 
                rows.push_back(row_entry{key, row});
                key_to_pos[key] = rows.size() - 1;
            }
        }
 
        void require_keyed_frame() const {
            if (!is_keyed) {
                throw std::runtime_error("This DataFrame was created without a key column.");
            }
        }
 
        void invalidate_key_index() {
            key_index.reset();
        }
 
        void ensure_key_index() const {
            if (key_index) {
                return;
            }
 
            key_index = std::unique_ptr<std::unordered_map<KeyType, size_t>>(
                new std::unordered_map<KeyType, size_t>()
            );
 
            for (size_t i = 0; i < rows.size(); i++) {
                (*key_index)[rows[i].first] = i;
            }
        }
 
        size_t position_of(const KeyType& key) const {
            this->ensure_key_index();
            auto it = key_index->find(key);
            if (it == key_index->end()) {
                throw std::out_of_range("Key not found.");
            }
 
            return it->second;
        }
    };
}