collection.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2024 - 2025 NeoN authors
//
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <unordered_map>
#include <string>
#include <memory>
#include <algorithm> // for std::sort
 
#include "NeoN/core/database/document.hpp"
 
namespace NeoN
{
 
 
// forward declaration
class Database;
 
class Collection
{
public:
 
    template<typename CollectionType>
    Collection(CollectionType collection)
        : impl_(std::make_unique<CollectionModel<CollectionType>>(std::move(collection)))
    {}
 
    Collection(const Collection& other) = delete;
 
    Collection& operator=(const Collection& other) = delete;
 
    Collection(Collection&& other) = default;
 
    Collection& operator=(Collection&& other) = default;
 
    Document& doc(const std::string& id);
 
    const Document& doc(const std::string& id) const;
 
    std::vector<std::string> find(const std::function<bool(const Document&)>& predicate) const;
 
    size_t size() const;
 
    std::string type() const;
 
    std::string name() const;
 
    Database& db();
 
    const Database& db() const;
 
    template<typename CollectionType>
    CollectionType& as()
    {
        auto derived = dynamic_cast<CollectionModel<CollectionType>*>(impl_.get());
        if (!derived)
        {
            throw std::bad_cast();
        }
        return derived->collection_;
    }
 
 
    template<typename CollectionType>
    const CollectionType& as() const
    {
        auto derived = dynamic_cast<CollectionModel<CollectionType>*>(impl_.get());
        if (!derived)
        {
            throw std::bad_cast();
        }
        return derived->collection_;
    }
 
private:
 
    struct CollectionConcept
    {
        virtual ~CollectionConcept() = default;
        virtual Document& doc(const std::string& id) = 0;
        virtual const Document& doc(const std::string& id) const = 0;
        virtual std::vector<std::string> find(const std::function<bool(const Document&)>& predicate
        ) const = 0;
        virtual size_t size() const = 0;
        virtual std::string type() const = 0;
        virtual std::string name() const = 0;
        virtual Database& db() = 0;
        virtual const Database& db() const = 0;
    };
 
    template<typename CollectionType>
    struct CollectionModel : CollectionConcept
    {
        CollectionModel(CollectionType collection) : collection_(std::move(collection)) {}
 
        Document& doc(const std::string& id) override { return collection_.doc(id); }
 
        const Document& doc(const std::string& id) const override { return collection_.doc(id); }
 
        std::vector<std::string> find(const std::function<bool(const Document&)>& predicate
        ) const override
        {
            return collection_.find(predicate);
        }
 
        size_t size() const override { return collection_.size(); }
 
        std::string type() const override { return collection_.type(); }
 
        std::string name() const override { return collection_.name(); }
 
        Database& db() override { return collection_.db(); }
 
        const Database& db() const override { return collection_.db(); }
 
        CollectionType collection_;
    };
 
    std::unique_ptr<CollectionConcept> impl_;
};
 
template<typename DocumentType>
class CollectionMixin
{
 
public:
 
    CollectionMixin(NeoN::Database& db, std::string name) : docs_(), db_(db), name_(name) {}
 
    CollectionMixin(const CollectionMixin&) = delete;
 
    CollectionMixin& operator=(const CollectionMixin&) = delete;
 
    CollectionMixin(CollectionMixin&&) = default;
 
    CollectionMixin& operator=(CollectionMixin&&) = delete;
 
    Document& doc(const std::string& id) { return docs_.at(id).doc(); }
 
    const Document& doc(const std::string& id) const { return docs_.at(id).doc(); }
 
    std::vector<std::string> find(const std::function<bool(const Document&)>& predicate) const
    {
        std::vector<std::string> result;
        for (const auto& [key, doc] : docs_)
        {
            if (predicate(doc.doc()))
            {
                result.push_back(doc.id());
            }
        }
        return result;
    }
 
    std::size_t size() const { return docs_.size(); }
 
    const NeoN::Database& db() const { return db_; }
 
    NeoN::Database& db() { return db_; }
 
    const std::string& name() const { return name_; }
 
    std::string type() const { return DocumentType::typeName(); }
 
    std::vector<std::string> sortedKeys() const
    {
        std::vector<std::string> result;
        for (const auto& [key, doc] : docs_)
        {
            result.push_back(key);
        }
        std::sort(result.begin(), result.end());
        return result;
    }
 
protected:
 
    std::unordered_map<std::string, DocumentType> docs_; 
    NeoN::Database& db_;                                 
    std::string name_;                                   
};
 
} // namespace NeoN