optional.h

Go to the documentation of this file.

#ifndef ORIGINAL_OPTIONAL_H
#define ORIGINAL_OPTIONAL_H
#include <utility>
#include "types.h"
#include "error.h"
 
namespace original {
 
    template<typename TYPE>
    class alternative {
        union storage {
            TYPE type_;     
            null null_;     
 
            storage() noexcept;
 
            storage(const storage& other) noexcept = default;
 
            storage& operator=(const storage& other) noexcept = default;
 
            ~storage();
        };
 
        bool non_null_type_; 
        storage val_;       
 
        void destroy() noexcept;
 
    public:
        explicit alternative();
 
        template<typename... Args>
        explicit alternative(Args&&... args);
 
        alternative(const alternative& other);
 
        alternative& operator=(const alternative& other);
 
        alternative(alternative&& other) noexcept;
 
        alternative& operator=(alternative&& other) noexcept;
 
        void swap(alternative& other) noexcept;
 
        const TYPE& operator*() const;
 
        TYPE& operator*();
 
        const TYPE* operator->() const;
 
        TYPE* operator->();
 
        const TYPE* get() const;
 
        TYPE* get();
 
        void reset() noexcept;
 
        template<typename... Args>
        void emplace(Args&&... args);
 
        void set(const TYPE& t);
 
        alternative& operator=(const TYPE& t);
 
        explicit operator bool() const;
 
        [[nodiscard]] bool hasValue() const;
 
        ~alternative();
    };
 
    template<>
    class alternative<void> {
        bool has_value_ = false; 
 
    public:
        explicit alternative();
 
        explicit alternative(null n);
 
        explicit alternative(std::in_place_t t);
 
        void set() noexcept;
 
        alternative& operator=(std::in_place_t t) noexcept;
 
        alternative& operator=(null n) noexcept;
 
        void reset() noexcept;
 
        [[nodiscard]] bool hasValue() const;
 
        explicit operator bool() const;
 
        alternative(const alternative& other) = default;
 
        alternative& operator=(const alternative& other) = default;
 
        alternative(alternative&& other) noexcept;
 
        alternative& operator=(alternative&& other) noexcept;
 
        void swap(alternative& other) noexcept;
 
        ~alternative() = default;
    };
}
 
namespace std {
    template<typename TYPE>
    void swap(original::alternative<TYPE>& lhs, original::alternative<TYPE>& rhs) noexcept; // NOLINT
}
template<typename TYPE>
original::alternative<TYPE>::storage::storage() noexcept
{
    new(&this->null_) null;
}
 
template<typename TYPE>
original::alternative<TYPE>::storage::~storage() {}
 
template<typename TYPE>
void original::alternative<TYPE>::destroy() noexcept {
    if (this->non_null_type_){
        this->val_.type_.~TYPE();
        this->non_null_type_ = false;
    } else {
        this->val_.null_.~null();
        this->non_null_type_ = true;
    }
}
 
template<typename TYPE>
original::alternative<TYPE>::alternative()
    : non_null_type_(false), val_() {}
 
template<typename TYPE>
template<typename... Args>
original::alternative<TYPE>::alternative(Args &&... args)
    : non_null_type_(true), val_() {
    new (&this->val_.type_) TYPE{ std::forward<Args>(args)... };
}
 
template<typename TYPE>
original::alternative<TYPE>::alternative(const alternative& other) {
    this->non_null_type_ = other.non_null_type_;
    if (other.non_null_type_) {
        new (&val_.type_) TYPE{ other.val_.type_ };
    } else {
        new (&val_.null_) null;
    }
}
 
template<typename TYPE>
original::alternative<TYPE>&
original::alternative<TYPE>::operator=(const alternative& other) {
    if (this == &other)
        return *this;
 
    this->destroy();
    this->non_null_type_ = other.non_null_type_;
    if (other.non_null_type_) {
        new (&val_.type_) TYPE{ other.val_.type_ };
    } else {
        new (&val_.null_) null;
    }
    return *this;
}
 
template<typename TYPE>
original::alternative<TYPE>::alternative(alternative&& other) noexcept {
    this->non_null_type_ = other.non_null_type_;
    if (this->non_null_type_){
        new (&val_.type_) TYPE{ std::move(other.val_.type_) };
    } else{
        new (&val_.null_) null;
    }
}
 
template<typename TYPE>
original::alternative<TYPE>&
original::alternative<TYPE>::operator=(alternative&& other)  noexcept {
    if (this == &other)
        return *this;
 
    this->destroy();
    this->non_null_type_ = other.non_null_type_;
    if (this->non_null_type_){
        new (&val_.type_) TYPE{ std::move(other.val_.type_) };
    } else{
        new (&val_.null_) null;
    }
    return *this;
}
 
template <typename TYPE>
void original::alternative<TYPE>::swap(alternative& other) noexcept
{
    if (this == &other)
        return;
 
    std::swap(this->non_null_type_, other.non_null_type_);
    std::swap(this->val_, other.val_);
}
 
template<typename TYPE>
const TYPE&
original::alternative<TYPE>::operator*() const {
    if (!this->non_null_type_)
        throw valueError("Dereferencing a original::null value");
 
    return this->val_.type_;
}
 
template<typename TYPE>
TYPE&
original::alternative<TYPE>::operator*() {
    if (!this->non_null_type_)
        throw valueError("Dereferencing a original::null value");
 
    return this->val_.type_;
}
 
template<typename TYPE>
const TYPE*
original::alternative<TYPE>::operator->() const {
    if (!this->non_null_type_)
        throw valueError("Accessing member of a original::null value");
 
    return &this->val_.type_;
}
 
template<typename TYPE>
TYPE*
original::alternative<TYPE>::operator->() {
    if (!this->non_null_type_)
        throw valueError("Accessing member of a original::null value");
 
    return &this->val_.type_;
}
 
template<typename TYPE>
const TYPE* original::alternative<TYPE>::get() const {
    return this->non_null_type_ ? &this->val_.type_ : nullptr;
}
 
template<typename TYPE>
TYPE* original::alternative<TYPE>::get() {
    return this->non_null_type_ ? &this->val_.type_ : nullptr;
}
 
template<typename TYPE>
void original::alternative<TYPE>::reset() noexcept {
    this->destroy();
}
 
template<typename TYPE>
template<typename... Args>
void original::alternative<TYPE>::emplace(Args &&... args) {
    this->destroy();
    this->non_null_type_ = true;
    new (&val_.type_) TYPE{ std::forward<Args>(args)... };
}
 
template<typename TYPE>
void original::alternative<TYPE>::set(const TYPE &t) {
    this->destroy();
    this->non_null_type_ = true;
    new (&val_.type_) TYPE{ t };
}
 
template <typename TYPE>
original::alternative<TYPE>&
original::alternative<TYPE>::operator=(const TYPE& t)
{
    this->set(t);
    return *this;
}
 
template<typename TYPE>
original::alternative<TYPE>::operator bool() const {
    return this->non_null_type_;
}
 
template <typename TYPE>
bool original::alternative<TYPE>::hasValue() const
{
    return this->operator bool();
}
 
template<typename TYPE>
original::alternative<TYPE>::~alternative() {
    this->destroy();
}
 
inline original::alternative<void>::alternative() = default;
 
inline original::alternative<void>::alternative(null) {}
 
inline original::alternative<void>::alternative(std::in_place_t) : has_value_(true) {}
 
inline void original::alternative<void>::set() noexcept
{
    this->has_value_ = true;
}
 
inline original::alternative<void>&
original::alternative<void>::operator=(std::in_place_t) noexcept
{
    this->set();
    return *this;
}
 
inline original::alternative<void>&
original::alternative<void>::operator=(null) noexcept
{
    this->reset();
    return *this;
}
 
inline void original::alternative<void>::reset() noexcept
{
    this->has_value_ = false;
}
 
inline bool original::alternative<void>::hasValue() const
{
    return this->has_value_;
}
 
inline original::alternative<void>::operator bool() const
{
    return this->has_value_;
}
 
inline original::alternative<void>::alternative(alternative&& other) noexcept
{
    this->has_value_ = other.has_value_;
    other.has_value_ = false;
}
 
inline original::alternative<void>&
original::alternative<void>::operator=(alternative&& other) noexcept
{
    if (this == &other)
        return *this;
 
    this->has_value_ = other.has_value_;
    other.has_value_ = false;
    return *this;
}
 
inline void original::alternative<void>::swap(alternative& other) noexcept
{
    if (this == &other)
        return;
 
    std::swap(this->has_value_, other.has_value_);
}
 
template <typename TYPE>
void std::swap(original::alternative<TYPE>& lhs, original::alternative<TYPE>& rhs) noexcept // NOLINT
{
    lhs.swap(rhs);
}
 
#endif //ORIGINAL_OPTIONAL_H