pair.h

Go to the documentation of this file.

// Evo C++ Library
/* Copyright 2019 Justin Crowell
Distributed under the BSD 2-Clause License -- see included file LICENSE.txt for details.
*/

#pragma once
#ifndef INCL_evo_pair_h
#define INCL_evo_pair_h

#include "impl/container.h"

namespace evo {


template<class TA, class TB>
struct Pair {
    typedef Pair<TA, TB> This;  

    typedef TA A;               
    typedef TA First;           
    typedef TA Key;             
    typedef TB B;               
    typedef TB Second;          
    typedef TB Value;           

    TA first;       
    TB second;      

    Pair() {
        DataCopy<TA>::set_default_pod(first);
        DataCopy<TB>::set_default_pod(second);
    }

    Pair(const TA& a) : first(a) {
        DataCopy<TB>::set_default_pod(second);
    }

    Pair(const TA& a, const TB& b) : first(a), second(b) {
    }

    Pair(const This& src) : first(src.first), second(src.second) {
    }

    This& operator=(const This& src) {
        first  = src.first;
        second = src.second;
        return *this;
    }

#if defined(EVO_CPP11)

    Pair(This&& src) : first(std::move(src.first)), second(std::move(src.second)) {
    }

    This& operator=(This&& src) {
        first = std::move(src.first);
        second = std::move(src.second);
        return *this;
    }
#endif

    const A& a() const
        { return first; }

    A& a()
        { return first; }

    const Key& key() const
        { return first; }

    Key& key()
        { return first; }

    const B& b() const
        { return second; }

    B& b()
        { return second; }

    const Value& value() const
        { return second; }

    Value& value()
        { return second; }

    ulong hash(ulong seed=0) const {
        seed = DataHash<TA>::hash(first, seed);
        return DataHash<TB>::hash(second, seed);
    }

    int compare(const This& src) const {
        int result = DataCompare<A>::compare(first, src.first);
        if (result == 0)
            result = DataCompare<B>::compare(second, src.second);
        return result;
    }

    bool operator==(const This& src) const
        { return (first == src.first && second == src.second); }

    bool operator!=(const This& src) const
        { return (first != src.first || second != src.second); }

    bool operator<(const This& src) const
        { return (first < src.first || (first == src.first && second < src.second)); }

    bool operator<=(const This& src) const
        { return (first < src.first || (first == src.first && second <= src.second)); }

    bool operator>(const This& src) const
        { return (first > src.first || (first == src.first && second > src.second)); }

    bool operator>=(const This& src) const
        { return (first > src.first || (first == src.first && second >= src.second)); }
};


}
#endif