couple.h

Go to the documentation of this file.

#ifndef COUPLE_H
#define COUPLE_H
 
#include "printable.h"
#include "comparable.h"
#include "types.h"
#include "error.h"
 
 
namespace original
{
    template<typename F_TYPE, typename S_TYPE>
    class couple final : public printable, public comparable<couple<F_TYPE, S_TYPE>>
    {
        F_TYPE first_;  
        S_TYPE second_; 
 
    public:
        explicit couple();
 
        couple(F_TYPE* first, S_TYPE* second);
 
        couple(const F_TYPE& first, const S_TYPE& second);
 
        couple(F_TYPE&& first, S_TYPE&& second);
 
        couple(const couple& other);
 
        couple& operator=(const couple& other);
 
        couple(couple&& other) noexcept;
 
        couple& operator=(couple&& other) noexcept;
 
        void swap(couple& other) noexcept;
 
        template<u_integer IDX>
        auto& get();
 
        template<u_integer IDX>
        const auto& get() const;
 
        template<u_integer IDX, typename T>
        couple& set(const T& e);
 
        integer compareTo(const couple &other) const override;
 
        F_TYPE& first();
 
        S_TYPE& second();
 
        const F_TYPE& first() const;
 
        const S_TYPE& second() const;
 
        ~couple() override;
 
        [[nodiscard]] std::string className() const override;
 
        [[nodiscard]] std::string toString(bool enter) const override;
    };
}
 
 
namespace std {
    template<typename F, typename S>
    void swap(original::couple<F, S>& lhs, original::couple<F, S>& rhs) noexcept; // NOLINT
 
    template<typename F, typename S>
    struct tuple_size<original::couple<F, S>> : std::integral_constant<std::size_t, 2> {}; // NOLINT
 
    template<std::size_t I, typename F, typename S>
    struct tuple_element<I, original::couple<F, S>> { // NOLINT
        using type = std::conditional_t<I == 0, F, S>;
    };
 
    template<std::size_t I, typename F, typename S>
    constexpr auto& get(original::couple<F, S>& c) noexcept;  // NOLINT
 
    template<std::size_t I, typename F, typename S>
    constexpr const auto& get(const original::couple<F, S>& c) noexcept;  // NOLINT
 
    template<std::size_t I, typename F, typename S>
    constexpr auto&& get(original::couple<F, S>&& c) noexcept;  // NOLINT
}
 
 
    template <typename F_TYPE, typename S_TYPE>
    original::couple<F_TYPE, S_TYPE>::couple() : first_(), second_() {}
 
    template <typename F_TYPE, typename S_TYPE>
    original::couple<F_TYPE, S_TYPE>::couple(F_TYPE* first, S_TYPE* second)
        : first_(*first), second_(*second) {}
 
    template <typename F_TYPE, typename S_TYPE>
    original::couple<F_TYPE, S_TYPE>::couple(const F_TYPE& first, const S_TYPE& second)
        : first_(first), second_(second) {}
 
    template <typename F_TYPE, typename S_TYPE>
    original::couple<F_TYPE, S_TYPE>::couple(F_TYPE&& first, S_TYPE&& second)
        : first_(std::move(first)), second_(std::move(second)) {}
 
    template <typename F_TYPE, typename S_TYPE>
    original::couple<F_TYPE, S_TYPE>::couple(const couple& other)
        : first_(other.first_), second_(other.second_) {}
 
    template <typename F_TYPE, typename S_TYPE>
    auto original::couple<F_TYPE, S_TYPE>::operator=(const couple& other) -> couple&
    {
        if (this == &other) return *this;
        first_ = other.first_;
        second_ = other.second_;
        return *this;
    }
 
    template<typename F_TYPE, typename S_TYPE>
    original::couple<F_TYPE, S_TYPE>::couple(couple &&other) noexcept
        : first_(std::move(other.first_)), second_(std::move(other.second_)) {}
 
    template<typename F_TYPE, typename S_TYPE>
    original::couple<F_TYPE, S_TYPE>&
    original::couple<F_TYPE, S_TYPE>::operator=(couple &&other) noexcept {
        if (this == &other) return *this;
 
        first_ = std::move(other.first_);
        second_ = std::move(other.second_);
        return *this;
    }
 
    template <typename F_TYPE, typename S_TYPE>
    void original::couple<F_TYPE, S_TYPE>::swap(couple& other) noexcept
    {
        if (this == &other)
            return;
 
        std::swap(this->first_, other.first_);
        std::swap(this->second_, other.second_);
    }
 
    template<typename F_TYPE, typename S_TYPE>
    template<original::u_integer IDX>
    auto& original::couple<F_TYPE, S_TYPE>::get() {
        staticError<outOfBoundError, (IDX > 1)>::asserts();
        if constexpr (IDX == 0){
            return this->first_;
        }else {
            return this->second_;
        }
    }
 
    template<typename F_TYPE, typename S_TYPE>
    template<original::u_integer IDX>
    const auto& original::couple<F_TYPE, S_TYPE>::get() const {
        staticError<outOfBoundError, (IDX > 1)>::asserts();
        if constexpr (IDX == 0){
            return this->first_;
        }else {
            return this->second_;
        }
    }
 
    template<typename F_TYPE, typename S_TYPE>
    template<original::u_integer IDX, typename T>
    original::couple<F_TYPE, S_TYPE>& original::couple<F_TYPE, S_TYPE>::set(const T &e) {
        staticError<outOfBoundError, (IDX > 1)>::asserts();
        if constexpr (IDX == 0){
            staticError<valueError, !std::is_convertible_v<T, F_TYPE>>::asserts();
            this->first_ = static_cast<F_TYPE>(e);
        } else{
            staticError<valueError, !std::is_convertible_v<T, S_TYPE>>::asserts();
            this->second_ = static_cast<S_TYPE>(e);
        }
        return *this;
    }
 
    template<typename F_TYPE, typename S_TYPE>
    auto original::couple<F_TYPE, S_TYPE>::compareTo(const couple& other) const -> integer
    {
        if constexpr (Comparable<F_TYPE>){
            if (this->first_ < other.first_)
                return -1;
            if (this->first_ > other.first_)
                return 1;
        }
        if constexpr (Comparable<S_TYPE>){
            if (this->second_ < other.second_)
                return -1;
            if (this->second_ > other.second_)
                return 1;
        }
        return 0;
    }
 
    template <typename F_TYPE, typename S_TYPE>
    auto original::couple<F_TYPE, S_TYPE>::first() -> F_TYPE&
    {
        return this->first_;
    }
 
    template <typename F_TYPE, typename S_TYPE>
    auto original::couple<F_TYPE, S_TYPE>::second() -> S_TYPE&
    {
        return this->second_;
    }
 
    template<typename F_TYPE, typename S_TYPE>
    const F_TYPE & original::couple<F_TYPE, S_TYPE>::first() const {
        return this->first_;
    }
 
    template<typename F_TYPE, typename S_TYPE>
    const S_TYPE & original::couple<F_TYPE, S_TYPE>::second() const {
        return this->second_;
    }
 
template <typename F_TYPE, typename S_TYPE>
    original::couple<F_TYPE, S_TYPE>::~couple() = default;
 
    template <typename F_TYPE, typename S_TYPE>
    auto original::couple<F_TYPE, S_TYPE>::className() const -> std::string
    {
        return "couple";
    }
 
    template <typename F_TYPE, typename S_TYPE>
    auto original::couple<F_TYPE, S_TYPE>::toString(const bool enter) const -> std::string
    {
        std::stringstream ss;
        ss << this->className() << "(" << formatString(this->first_)
           << ", " << formatString(this->second_) << ")";
        if (enter) ss << "\n";
        return ss.str();
    }
 
    template <typename F, typename S>
    void std::swap(original::couple<F, S>& lhs, original::couple<F, S>& rhs) noexcept // NOLINT
    {
        lhs.swap(rhs);
    }
 
    template<std::size_t I, typename F, typename S>
    constexpr auto& std::get(original::couple<F, S> &c) noexcept {  // NOLINT
        return c.template get<I>();
    }
 
    template<std::size_t I, typename F, typename S>
    constexpr const auto& std::get(const original::couple<F, S> &c) noexcept {  // NOLINT
        return c.template get<I>();
    }
 
    template<std::size_t I, typename F, typename S>
    constexpr auto&& std::get(original::couple<F, S> &&c) noexcept {  // NOLINT
        return std::move(c.template get<I>());
    }
 
#endif //COUPLE_H