#pragma once
#include <vector>

namespace ddkit {
namespace utils {
namespace types {

template <typename T>
class Optional {

private:
    std::vector<T> &vec;

public:
    Optional(std::vector<T> &val) : vec(val) {}

    Optional() = delete;

    T& value() {
        if(vec.size()) {
            return vec[0];
        } else {
            throw std::out_of_range( "optional is empty" );
        }
    }

    T value_or(T defVal) {
        return vec.size() ? vec[0] : (defVal);
    }

    void reset() {
        if (vec.size()) {
            vec.clear();
        }
    }

    void set(const T &val) {
        if (vec.size()) {
            vec[0] = val;
        } else {
            vec.push_back(val);
        }
    }

    bool has_value() const {
        return vec.size() ? true : false;
    }

    std::vector<T> &operator*() {
        return vec[0];
    }

    std::vector<T> *operator->() {
        return vec[0];
    }

    Optional operator=(const T &val) {
        set(val);

        return *this;
    }

    operator bool() const {
        return has_value();
    }
};

}
}
}