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(const couple& other);

        couple& operator=(const couple& other);

        template<u_integer IDX>
        auto get() const;

        template<u_integer IDX, typename T>
        void set(const T& e);

        integer compareTo(const couple &other) const override;

        F_TYPE& first();

        S_TYPE& second();

        ~couple() override;

        [[nodiscard]] std::string className() const override;

        [[nodiscard]] std::string toString(bool enter) const override;
    };
}
 
    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(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>
    template<original::u_integer IDX>
    auto original::couple<F_TYPE, S_TYPE>::get() const {
        staticError<outOfBoundError, (IDX > 1)>{};
        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>
    void original::couple<F_TYPE, S_TYPE>::set(const T &e) {
        staticError<outOfBoundError, (IDX > 1)>{};
        if constexpr (IDX == 0){
            staticError<valueError, !std::is_convertible_v<T, F_TYPE>>{};
            this->first_ = static_cast<F_TYPE>(e);
        } else{
            staticError<valueError, !std::is_convertible_v<T, S_TYPE>>{};
            this->second_ = static_cast<S_TYPE>(e);
        }
    }
 
    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>
    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();
    }
 
#endif //COUPLE_H