pair.h

#ifndef PAIR_H
#define PAIR_H

#include <utility>

namespace fnss {

// You get operators !=,<=,>,>= if you define operators < and == and inherit from
// this class using your class as the template parameter. Possible
template <typename D>
class RelOP {
public:
  RelOP() : derived(*static_cast<const D*>(this)) {}
  bool operator!=(const D &rhs) const {
    return !(derived == rhs);
  }

  bool operator<=(const D &rhs) const {
    return derived < rhs || derived == rhs;
  }

  bool operator>(const D &rhs) const {
    return !(derived < rhs) && !(derived == rhs);
  }

  bool operator>=(const D &rhs) const {
    return !(derived > rhs);
  }

private:
  const D& derived;
};

template <class T1, class T2> class Pair : public RelOP<Pair<T1, T2> >{
public:
        T1 &first;
        T2 &second;

        Pair(bool commutative_ = false) :
                first(stlPair.first), second(stlPair.second), stlPair(),
                commutative(commutative_) {}

        Pair(const T1 &first_, const T2 &second_, bool commutative_ = false) :
                first(stlPair.first), second(stlPair.second), stlPair(first_, second_),
                commutative(commutative_) {}

        Pair(const std::pair <T1, T2> &p, bool commutative_ = false) :
                first(stlPair.first), second(stlPair.second), stlPair(p),
                commutative(commutative_) {}

        Pair(const Pair<T1, T2> &other) :
                first(stlPair.first), second(stlPair.second), stlPair(other.stlPair),
                commutative(other.commutative) {}

        std::pair<T1, T2> getStlPair() const {
                return this->stlPair;
        }

        bool getCommutative() const {
                return this->commutative;
        }

        void setCommutative(bool commutative_) {
                this->commutative = commutative_;
        }

        Pair& operator=(const Pair &rhs) {
                this->stlPair = rhs.stlPair;

                return *this;
        }

        bool operator==(const Pair &rhs) const {
                if(this->commutative || rhs.commutative) {
                        if((this->first == rhs.first && this->second == rhs.second) ||
                                (this->second == rhs.first && this->first == rhs.second))
                                return true;
                        else
                                return false;
                } else {
                        return this->stlPair == rhs.stlPair;
                }
        }

        // Non-commutative pair: lexicographic order.
        // Commutative pair: behaves as if first and second were sorted inside the pair.
        bool operator<(const Pair &rhs) const {
                if (this->commutative || rhs.commutative) {
                        if (this->first < this->second) {
                                if (rhs.first < rhs.second)
                                        return this->first < rhs.first || (this->first == rhs.first && this->second < rhs.second);
                                else
                                        return this->first < rhs.second || (this->first == rhs.second && this->second < rhs.first);
                        } else {
                                if (rhs.first < rhs.second)
                                        return this->second < rhs.first || (this->second == rhs.first && this->first < rhs.second);
                                else
                                        return this->second < rhs.second || (this->second == rhs.second && this->first < rhs.first);
                        }
                } else {
                        return this->first < rhs.first || (this->first == rhs.first && this->second < rhs.second);
                }
        }

private:
        std::pair <T1, T2> stlPair;
        bool commutative;
};

} //namespace

#endif //PAIR_H