shared.hpp

Go to the documentation of this file.

#ifndef LIBFILEZILLA_SHARED_HEADER
#define LIBFILEZILLA_SHARED_HEADER
 
#include <memory>

namespace fz {

template<typename T, bool Init = false> class shared_optional final
{
public:
    shared_optional() noexcept(!Init || std::is_nothrow_constructible_v<T>);
    shared_optional(shared_optional<T, Init> const& v) = default;
    shared_optional(shared_optional<T, Init> && v) noexcept = default;
    explicit shared_optional(const T& v);
 
    void clear();

    T& get();
 
    const T& operator*() const;
    const T* operator->() const;

    bool operator==(shared_optional<T, Init> const& cmp) const;
    bool operator==(T const& cmp) const;
    bool operator<(shared_optional<T, Init> const& cmp) const;
    bool operator<(T const& cmp) const;

    bool is_same(shared_optional<T, Init> const& cmp) const;
 
    inline bool operator!=(const shared_optional<T, Init>& cmp) const { return !(*this == cmp); }
    inline bool operator!=(T const& cmp) const { return !(*this == cmp); }
 
    shared_optional<T, Init>& operator=(shared_optional<T, Init> const& v) = default;
    shared_optional<T, Init>& operator=(shared_optional<T, Init> && v) noexcept = default;
 
    explicit operator bool() const { return static_cast<bool>(data_); }
 
    bool empty() const { return !data_; }
 
    long use_count() const { return data_.use_count(); }
 
private:
    std::shared_ptr<T> data_;
};

template<typename T>
using shared_value = shared_optional<T, true>;
 
 
template<typename T, bool Init> shared_optional<T, Init>::shared_optional() noexcept(!Init || std::is_nothrow_constructible_v<T>)
    : data_(Init ? std::make_shared<T>() : nullptr)
{
}
 
template<typename T, bool Init> shared_optional<T, Init>::shared_optional(const T& v)
    : data_(std::make_shared<T>(v))
{
}
 
template<typename T, bool Init> bool shared_optional<T, Init>::operator==(shared_optional<T, Init> const& cmp) const
{
    if (data_ == cmp.data_) {
        return true;
    }
    else if (!Init && (!data_ || !cmp.data_)) {
        return false;
    }
 
    return *data_ == *cmp.data_;
}
 
template<typename T, bool Init> bool shared_optional<T, Init>::operator==(T const& cmp) const
{
    if (!Init && !data_) {
        return false;
    }
    return *data_ == cmp;
}
 
template<typename T, bool Init> bool shared_optional<T, Init>::is_same(shared_optional<T, Init> const& cmp) const
{
    return data_ == cmp.data_;
}
 
template<typename T, bool Init> T& shared_optional<T, Init>::get()
{
    if (!Init && !data_) {
        data_ = std::make_shared<T>();
    }
    if (data_.use_count() > 1) {
        data_ = std::make_shared<T>(*data_);
    }
 
    return *data_;
}
 
template<typename T, bool Init> bool shared_optional<T, Init>::operator<(shared_optional<T, Init> const& cmp) const
{
    if (data_ == cmp.data_) {
        return false;
    }
    else if (!Init && !data_) {
        return static_cast<bool>(cmp.data_);
    }
    else if (!Init && !cmp.data_) {
        return false;
    }
    return *data_ < *cmp.data_;
}
 
template<typename T, bool Init> bool shared_optional<T, Init>::operator<(T const& cmp) const
{
    if (!Init && !data_) {
        return true;
    }
    return *data_ < cmp;
}
 
template<typename T, bool Init> void shared_optional<T, Init>::clear()
{
    if (!Init) {
        data_.reset();
    }
    else if (data_.use_count() <= 1) {
        *data_ = T();
    }
    else {
        data_ = std::make_shared<T>();
    }
}
 
template<typename T, bool Init> const T& shared_optional<T, Init>::operator*() const
{
    return *data_;
}
 
template<typename T, bool Init> const T* shared_optional<T, Init>::operator->() const
{
    return data_.get();
}
 
}
 
#endif