any_map.h

Go to the documentation of this file.

/*
 * TypeMap.h
 *
 *  Created on: Oct 13, 2019
 *      Author: joseph
 */

#ifndef BLACKCAT_TENSORS_UTILITY_TYPEMAP_H_
#define BLACKCAT_TENSORS_UTILITY_TYPEMAP_H_

#include <unordered_map>
#include <memory>
#include <typeinfo>

namespace bc {
namespace utility {

template<class T>
using Type = bc::traits::Type<T>;

template<char... Chars>
struct Name {
    std::string name() {
        return "";
    }
};

template<char C, char... Chars>
struct Name<C, Chars...> {
    static std::string name() {
        return "C" + Name<Chars...>::name();
    }
};

template<class Key, class Value>
struct Any_Key {
    using key_type = Key;
    using value_type = Value;
};

class Any_Map {

    using any_ptr = std::shared_ptr<void>;
    std::unordered_map<std::size_t, any_ptr> m_any_map;

    template<class K, class V>
    static std::size_t hash(Any_Key<K, V> type_key) {
        return typeid(Any_Key<K, V>).hash_code();
    }

public:

    template<class K, class V>
    bool contains(Any_Key<K ,V> key) const {
        return m_any_map.find(hash(key)) != m_any_map.end();
    }

    template<class K, class V>
    auto& operator [] (Any_Key<K, V> key) {
        static auto deleter = [](void* data) {
            delete reinterpret_cast<V*>(data);
        };

        if (!contains(key)) {
            void* data = reinterpret_cast<void*>(new V());
            m_any_map[hash(key)] = any_ptr(data, deleter);
        }

        return *reinterpret_cast<V*>(m_any_map[hash(key)].get());
    }

    template<class K, class V>
    auto& at (Any_Key<K, V> key) {
        return this->operator[](key);
    }


    template<class K, class V, class... DefaultArgs>
    auto& get(Any_Key<K, V> key, DefaultArgs&&... args) {
        if (!contains(key)) {
            return m_any_map[hash(key)] = V(std::forward(args)...);
        } else {
            return m_any_map[hash(key)];
        }
    }

    template<class K, class V>
    auto& get(Any_Key<K, V> key, V&& value) {
        if (!contains(key)) {
            return m_any_map[hash(key)] = value;
        } else {
            return m_any_map[hash(key)];
        }
    }

    template<class K, class V, class... Args>
    auto emplace(Any_Key<K, V> key, Args&&... args) {
        auto result = m_any_map.emplace(hash(key), args...);
        return std::pair<K&, bool> { *(result.first), result.second };
    }

    int empty() const  { return (int)m_any_map.empty(); }
    int size()  const  { return (int)m_any_map.size(); }
    int max_size() const { return (int)m_any_map.size(); }

    auto begin() const { return m_any_map.begin(); }
    auto end() const { return m_any_map.end(); }

    auto begin() { return m_any_map.begin(); }
    auto end() { return m_any_map.end(); }
    auto cbegin() { return m_any_map.cbegin(); }
    auto cend() { return m_any_map.cend(); }
};



}
}



#endif /* TYPEMAP_H_ */