keys.hpp

/*
 * live_cells_cpp
 * Copyright (C) 2024  Alexander Gutev <alex.gutev@gmail.com>
 *
 * 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.
 */
 
#ifndef LIVE_CELLS_KEYS_HPP
#define LIVE_CELLS_KEYS_HPP
 
#include <typeinfo>
#include <functional>
#include <memory>
 
#include "util.hpp"
 
namespace live_cells {
 
    class key {
    public:
        virtual ~key() noexcept = default;
 
        virtual bool eq(const key &k) const noexcept = 0;
 
        virtual std::size_t hash() const noexcept = 0;
 
        virtual bool is_unique() const noexcept {
            return false;
        }
    };
 
    class key_ref {
    public:
        template <typename T, typename... Args>
        static key_ref create(Args... args) {
            return key_ref(
                std::static_pointer_cast<const key>(
                    std::make_shared<T>(args...)
                )
            );
        }
 
        const key &operator *() const {
            return *key_;
        }
 
        const key *operator->() const {
            return key_.get();
        }
 
    private:
        std::shared_ptr<const key> key_;
 
        key_ref(std::shared_ptr<const key> ref) : key_(ref) {}
    };
 
    class unique_key : public key {
    public:
        bool eq(const key &k) const noexcept override;
 
        std::size_t hash() const noexcept override;
 
        bool is_unique() const noexcept override {
            return true;
        }
    };
 
    template <typename T, typename... Ts>
    class value_key : public key {
        const T value;
 
        const value_key<Ts...> rest;
 
    public:
        value_key(T value, Ts... rest)
            : value(value),
              rest(rest...) {
        }
 
        bool eq(const key &other) const noexcept override {
            auto *key = dynamic_cast<const value_key<T,Ts...> *>(&other);
 
            if (key == nullptr) {
                return false;
            }
 
            const auto &t1 = typeid(*this);
            const auto &t2 = typeid(other);
 
            return t1 == t2 && values_equal(*key);
        }
 
        std::size_t hash() const noexcept override {
            return internal::hash_combine(0, typeid(*this).hash_code(), hash_values());
        }
 
    private:
        bool values_equal(const value_key<T,Ts...> key) const noexcept {
            return value == key.value && rest.values_equal(key.rest);
        }
 
        std::size_t hash_values() const noexcept {
            return internal::hash_combine(0, value, rest.hash_values());
        }
    };
 
    template <typename T>
    class value_key<T> : public key {
        const T value;
 
    public:
        value_key(T value) :
            value(value) {}
 
        bool eq(const key &other) const noexcept override {
            auto *key = dynamic_cast<const value_key<T> *>(&other);
 
            if (key == nullptr) {
                return false;
            }
 
            const auto &t1 = typeid(*this);
            const auto &t2 = typeid(other);
 
            return t1 == t2 && values_equal(*key);
        }
 
        std::size_t hash() const noexcept override {
            return internal::hash_combine(0, typeid(*this).hash_code(), hash_values());
        }
 
    private:
        bool values_equal(const value_key<T> key) const noexcept {
            return value == key.value;
        }
 
        std::size_t hash_values() const noexcept {
            return std::hash<T>{}(value);
        }
 
        template <typename T1, typename... Ts>
        friend class value_key;
    };
 
    inline bool operator ==(const key &k1, const key &k2) {
        return k1.eq(k2);
    }
 
    inline bool operator !=(const key &k1, const key &k2) {
        return !k1.eq(k2);
    }
 
    inline bool operator ==(const key_ref &k1, const key_ref &k2) {
        return *k1 == *k2;
    }
 
    inline bool operator !=(const key_ref &k1, const key_ref &k2) {
        return *k1 != *k2;
    }
 
}  // live_cells
 
template<>
struct std::hash<live_cells::key> {
    std::size_t operator()(const live_cells::key& k) const noexcept {
        return k.hash();
    }
};
 
template<>
struct std::hash<live_cells::key_ref> {
    std::size_t operator()(const live_cells::key_ref &k) const noexcept {
        return k->hash();
    }
};
 
#endif /* LIVE_CELLS_KEYS_HPP */