AdjacencyContainerDecorator.hpp

Go to the documentation of this file.

#pragma once
#include <algorithm>
#include <fishnet/CollectionConcepts.hpp>
 
#include "AdjacencyContainer.hpp"
 
namespace fishnet::graph{
 
template<class AdjDelegate>
class AdjacencyContainerDecorator{
private:
    using N = typename AdjDelegate::node_type;
    static_assert(AdjacencyContainer<AdjDelegate,N>, "AdjDelegate must be an AdjacencyContainer");
    AdjDelegate delegate;
public:
    using node_type = typename AdjDelegate::node_type;
    using equality_predicate = typename AdjDelegate::equality_predicate;
    using hash_function = typename AdjDelegate::hash_function;
 
    AdjacencyContainerDecorator(const AdjDelegate & delegate): delegate(delegate) {}
 
    AdjacencyContainerDecorator(AdjDelegate && delegate) : delegate(std::move(delegate)) {}
 
    void addAdjacency(const N & from, const N & to) {
        delegate.addAdjacency(from, to);
    }
 
    void addAdjacency(N && from, N && to) {
        delegate.addAdjacency(std::move(from), std::move(to));
    }
 
    void addAdjacencies(util::forward_range_of<std::pair<N,N>> auto && pairs){
        delegate.addAdjacencies(std::forward<decltype(pairs)>(pairs));
    }
 
    bool addNode(const N & node){
        return delegate.addNode(node);
    }
 
    bool addNode(N && node){
        return delegate.addNode(std::move(node));
    }
 
    bool addNodes(util::forward_range_of<N> auto && nodes){
        return delegate.addNodes(std::forward<decltype(nodes)>(nodes));
    }
 
    void removeNode(const N & node){
        delegate.removeNode(node);
    }
 
    void removeNodes(util::forward_range_of<N> auto && nodes){
        delegate.removeNodes(std::forward<decltype(nodes)>(nodes));
    }
 
    void removeAdjacency(const N & from, const N & to){
        delegate.removeAdjacency(from,to);
    }
 
    void removeAdjacencies(util::forward_range_of<std::pair<N,N>> auto && pairs){
        delegate.removeAdjacencies(std::forward<decltype(pairs)>(pairs));
    }
 
    bool contains(const N & node) const noexcept {
        return delegate.contains(node);
    }
 
    bool hasAdjacency(const N & from, const N & to) const noexcept {
        return delegate.hasAdjacency(from,to);
    }
 
    auto adjacency(const N & node) const noexcept {
        return delegate.adjacency(node);
    }
 
    auto nodes() const noexcept {
        return delegate.nodes();
    }
 
    auto getAdjacencyPairs() const noexcept {
        return delegate.getAdjacencyPairs();
    }
 
    void clear() noexcept{
        delegate.clear();
    }
 
};
}