BiMap.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_BiMap_H
#define Sawyer_BiMap_H
 
#include <Sawyer/Map.h>
#include <Sawyer/Sawyer.h>
#include <boost/foreach.hpp>
 
namespace Sawyer {
namespace Container {
 
template<class S, class T>
class BiMap {
public:
    typedef S Source;                                   
    typedef T Target;                                   
    typedef Sawyer::Container::Map<Source, Target> Forward; 
    typedef Sawyer::Container::Map<Target, Source> Reverse; 
private:
    Forward forward_;
    Reverse reverse_;
public:
    BiMap() {}
 
    BiMap(const BiMap &other);
 
    template<class U>
    BiMap(const BiMap<Source, U> &a, const BiMap<U, Target> &b) {
        BOOST_FOREACH (const typename Forward::Node &anode, a.forward_.nodes()) {
            if (b.forward_.exists(anode.value())) {
                const Target &target = b.forward_[anode.value()];
                forward_.insert(anode.key(), target);
                reverse_.insert(target, anode.key());
            }
        }
    }
 
    void clear() {
        forward_.clear();
        reverse_.clear();
    }
    
    bool eraseSource(const Source &source) {
        if (!forward_.exists(source))
            return false;
        reverse_.erase(forward_[source]);
        forward_.erase(source);
        return true;
    }
 
    bool eraseTarget(const Target &target) {
        if (!reverse_.exists(target))
            return false;
        forward_.erase(reverse_[target]);
        reverse_.erase(target);
        return true;
    }
 
    bool erase(const Source &source, const Target &target) {
        if (!forward_.exists(source) || forward_[source]!=target)
            return false;
        forward_.erase(source);
        reverse_.erase(target);
        return true;
    }
 
    void insert(const Source &source, const Target &target) {
        eraseSource(source);
        eraseTarget(target);
        forward_.insert(source, target);
        reverse_.insert(target, source);
    }
 
    const Forward& forward() const {
        return forward_;
    }
 
    const Reverse& reverse() const {
        return reverse_;
    }
};
 
} // namespace
} // namespace
 
#endif