TripleContainer.h

Go to the documentation of this file.

/*
 * This file is part of KnowRob, please consult
 * https://github.com/knowrob/knowrob for license details.
 */
 
#ifndef KNOWROB_TRIPLE_CONTAINER_H
#define KNOWROB_TRIPLE_CONTAINER_H
 
#include <boost/iterator/iterator_facade.hpp>
#include <utility>
#include <vector>
#include <memory>
#include <functional>
#include "knowrob/semweb/Triple.h"
 
namespace knowrob {
    class TripleContainer {
    public:
        using ConstGenerator = std::function<const TriplePtr *()>;
 
        struct iterator : boost::iterator_facade<iterator, const TriplePtr, boost::forward_traversal_tag> {
            explicit iterator(const ConstGenerator &generator)
                    : generator_(generator), ptr_(generator_()) {
            }
 
            bool equal(iterator const &other) const { return ptr_ == other.ptr_; }
 
            const TriplePtr &dereference() const { return *ptr_; }
 
            void increment() { ptr_ = generator_(); }
 
        private:
            ConstGenerator generator_;
            const TriplePtr *ptr_;
        };
 
        virtual ~TripleContainer() = default;
 
        iterator begin() const {
            return iterator(cgenerator());
        }
 
        static iterator end() {
            return iterator([] { return nullptr; });
        }
 
        bool empty() const {
            return begin().equal(end());
        }
 
        virtual bool isMutable() const { return false; }
 
        virtual ConstGenerator cgenerator() const = 0;
    };
 
    class MutableTripleContainer : public TripleContainer {
    public:
        using MutableGenerator = std::function<TriplePtr *()>;
 
        struct iterator : boost::iterator_facade<iterator, TriplePtr, boost::forward_traversal_tag> {
            explicit iterator(MutableGenerator generator)
                    : generator_(std::move(generator)), ptr_(generator_()) {
            }
 
            bool equal(iterator const &other) const { return ptr_ == other.ptr_; }
 
            TriplePtr &dereference() const { return *ptr_; }
 
            void increment() { ptr_ = generator_(); }
 
        private:
            MutableGenerator generator_;
            TriplePtr *ptr_;
        };
 
        iterator begin() {
            return iterator(generator());
        }
 
        static iterator end() {
            return iterator([] { return nullptr; });
        }
 
        virtual MutableGenerator generator() = 0;
 
        // Override TripleContainer
        bool isMutable() const override { return true; }
    };
 
    class ProxyTripleContainer : public TripleContainer {
    public:
        explicit ProxyTripleContainer(const std::vector<TriplePtr> *triples);
 
        explicit ProxyTripleContainer(const std::vector<TriplePtr> &triples);
 
        // Override TripleContainer
        ConstGenerator cgenerator() const override;
 
    protected:
        const std::vector<TriplePtr> *triples_;
        const std::vector<TriplePtr> triplesData_;
    };
 
    class TripleViewBatch : public MutableTripleContainer {
    public:
        explicit TripleViewBatch(uint32_t batchSize);
 
        auto size() const { return actualSize_; }
 
        void reset() { actualSize_ = 0; }
 
        void add(const TriplePtr &triple);
 
        // Override TripleContainer
        ConstGenerator cgenerator() const override;
 
        // Override MutableTripleContainer
        MutableGenerator generator() override;
 
    protected:
        std::vector<TriplePtr> data_;
        uint32_t batchSize_;
        std::size_t actualSize_;
    };
 
    using TripleContainerPtr = std::shared_ptr<TripleContainer>;
    using TripleHandler = std::function<void(const TripleContainerPtr &)>;
    using TripleVisitor = std::function<void(const TriplePtr &)>;
 
    using MutableTripleContainerPtr = std::shared_ptr<MutableTripleContainer>;
    using MutableTripleHandler = std::function<void(const MutableTripleContainerPtr &)>;
 
    using TripleFilter = std::function<bool(const Triple &)>;
}
 
#endif //KNOWROB_TRIPLE_CONTAINER_H