try hard

#pragma once
#include <exception>
#include <stdexcept>
#include <cstring>
#include <cassert>
#include <string>

template <class T>
class Try {
public:
    Try() {
    }
    Try(T value) : value(value), empty(false) {
    }
    template <typename Ex>
    Try(Ex&& ex) {
        try {
            throw ex;
        } catch(...) {
            eptr = std::current_exception();
        }
    }
    template <typename Ex>
    Try(T value, Ex&& ex) : value(value), empty(false) {
        try {
            throw ex;
        } catch(...) {
            eptr = std::current_exception();
        }
    }
    const T& Value() {
        if (eptr) {
            std::rethrow_exception(eptr);
        } else if (empty) {
            throw std::runtime_error("Object is empty");
        }
        return value;
    }
    virtual void Throw() {
        if (eptr) {
            std::rethrow_exception(eptr);
        } else {
            throw std::runtime_error("No exception");
        }
    }
    bool IsFailed() {
        if (eptr) {
            return true;
        } else {
            return false;
        }
    }
private:
    bool empty = true;
    T value{};
    std::exception_ptr eptr;
};

template <>
class Try<void> {
public:
    Try() {
    }
    template <typename Ex>
    Try(Ex&& ex) {
        try {
            throw ex;
        } catch(...) {
            this->eptr = std::current_exception();
        }
    }
    virtual void Throw() {
        if (this->eptr) {
            std::rethrow_exception(this->eptr);
        } else {
            throw std::runtime_error("No exception");
        }
    }
    bool IsFailed() {
        if (this->eptr) {
            return true;
        } else {
            return false;
        }
    }
};

template <class Function, class... Args>
auto TryRun(Function func, Args... args) {
    using ReturnType = decltype(func(args...));
    try {
        func(args...);
        if constexpr(std::is_same<ReturnType, void>::value) {
            return Try<void>();
        } else {
            return Try<ReturnType>(func(args...));
        }
    } catch(std::exception& e) {
        if constexpr(std::is_same<ReturnType, void>::value) {
            return Try<void>(e);
        } else {
            return Try<ReturnType>(e);
        }
    } catch(const char* str) {
        std::runtime_error e(str);
        if constexpr(std::is_same<ReturnType, void>::value) {
            return Try<void>(e);
        } else {
            return Try<ReturnType>(e);
        }
    } catch(int i) {
        std::runtime_error e(std::strerror(i));
        if constexpr(std::is_same<ReturnType, void>::value) {
            return Try<void>(e);
        } else {
            return Try<ReturnType>(e);
        }
    } catch(...) {
        std::runtime_error e("Unknown exception");
        if constexpr(std::is_same<ReturnType, void>::value) {
            return Try<void>(e);
        } else {
            return Try<ReturnType>(e);
        }
    }
}