GraphIteratorBiMap.h

// WARNING: Changes to this file must be contributed back to Sawyer or else they will
//          be clobbered by the next update from Sawyer.  The Sawyer repository is at
//          https://github.com/matzke1/sawyer.




#ifndef Sawyer_GraphIteratorBiMap_H
#define Sawyer_GraphIteratorBiMap_H

#include <Sawyer/GraphIteratorMap.h>

namespace Sawyer {
namespace Container {

template<class LhsIterator, class RhsIterator>
class GraphIteratorBiMap {
public:
    typedef GraphIteratorMap<LhsIterator, RhsIterator> ForwardMap;
    typedef GraphIteratorMap<RhsIterator, LhsIterator> ReverseMap;

private:
    ForwardMap forward_;
    ReverseMap reverse_;

public:
    GraphIteratorBiMap() {}
    
    template<class U>
    GraphIteratorBiMap(const GraphIteratorBiMap<LhsIterator, U> &a, const GraphIteratorBiMap<U, RhsIterator> &b) {
        BOOST_FOREACH (const typename ForwardMap::Node &anode, a.forward_.nodes()) {
            if (b.forward_.exists(anode.value())) {
                const RhsIterator &target = b.forward_[anode.value()];
                insert(anode.key(), target);
            }
        }
    }

    void updateIdNumbers() {
        forward_.updateIdNumbers();
        reverse_.updateIdNumbers();
    }

    void insert(const LhsIterator &a, const RhsIterator &b) {
        if (Sawyer::Optional<RhsIterator> found = forward_.find(a)) {
            if (*found == b)
                return;
            reverse_.erase(b);
        }
        forward_.insert(a, b);
        reverse_.insert(b, a);
    }

    void eraseSource(const LhsIterator &a) {
        if (Sawyer::Optional<RhsIterator> found = forward_.find(a)) {
            reverse_.erase(*found);
            forward_.erase(a);
        }
    }

    void eraseTarget(const RhsIterator &b) {
        if (Sawyer::Optional<LhsIterator> found = reverse_.find(b)) {
            forward_.erase(*found);
            reverse_.erase(b);
        }
    }
    
    const ForwardMap& forward() const {
        return forward_;
    }

    const ReverseMap& reverse() const {
        return reverse_;
    }
    
    void clear() {
        forward_.clear();
        reverse_.clear();
    }
};

} // namespace
} // namespace

#endif