pair.h

Go to the documentation of this file.

// =====================================================================================================================
//  fennec, a free and open source game engine
//  Copyright © 2025  Medusa Slockbower
//
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
 
 
#ifndef FENNEC_CONTAINERS_PAIR_H
#define FENNEC_CONTAINERS_PAIR_H
 
#include <fennec/containers/tuple.h>
#include <fennec/lang/hashing.h>
#include <fennec/lang/utility.h>
 
namespace fennec
{
 
// TODO: Document
 
template<typename TypeT0, typename TypeT1>
struct pair {
 
// Members =============================================================================================================
 
    TypeT0 first; 
    TypeT1 second; 
 
// Constructors ========================================================================================================
 
 
    constexpr pair() = default;
 
    constexpr ~pair() = default;
 
    constexpr pair(const TypeT0& x, const TypeT1& y)
        : first(x)
        , second(y) {
    }
 
    constexpr pair(TypeT0&& x, TypeT1&& y) noexcept
        : first(fennec::forward<TypeT0>(x))
        , second(fennec::forward<TypeT1>(y)) {
    }
 
    template<typename Arg1T, typename Arg2T>
    constexpr pair(Arg1T&& arg1, Arg2T&& arg2)
        : first(fennec::forward<Arg1T>(arg1))
        , second(fennec::forward<Arg2T>(arg2)) {
    }
 
    constexpr pair(const pair& pair)
        : first(fennec::copy(pair.first))
        , second(fennec::copy(pair.second)) {
    }
 
    constexpr pair(pair&& pair) noexcept
        : first(fennec::move(pair.first))
        , second(fennec::move(pair.second)) {
    }
 
    constexpr pair& operator=(const pair& pair) {
        first  = fennec::copy(pair.first);
        second = fennec::copy(pair.second);
        return *this;
    }
 
    constexpr pair& operator=(pair&& pair) {
        first  = fennec::move(pair.first);
        second = fennec::move(pair.second);
        return *this;
    }
 
 
 
// Comparison ==========================================================================================================
 
 
    constexpr bool operator==(const pair& p) const {
        return first == p.first and second == p.second;
    }
 
    constexpr bool operator!=(const pair& p) const {
        return first != p.first or second != p.second;
    }
 
    constexpr bool operator<(const pair& p) const {
        return first < p.first or (first == p.first and second < p.second);
    }
 
    constexpr bool operator<=(const pair& p) const {
        return first < p.first or (first == p.first and second <= p.second);
    }
 
    constexpr bool operator>(const pair& p) const {
        return first > p.first or (first == p.first and second > p.second);
    }
 
    constexpr bool operator>=(const pair& p) const {
        return first > p.first or (first == p.first and second >= p.second);
    }
 
};
 
template<typename TypeT0, typename TypeT1>
struct hash<pair<TypeT0, TypeT1>> : hash<TypeT0>, hash<TypeT1> {
    constexpr size_t operator()(const pair<TypeT0, TypeT1>& p) const {
        return fennec::pair_hash( // pair the hashes of both elements
            hash<TypeT0>::operator()(p.first),
            hash<TypeT1>::operator()(p.second)
        );
    }
};
 
}
 
#endif // FENNEC_CONTAINERS_PAIR_H