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