#pragma once
#include "Exception.h"
#include <wtf/CrossThreadCopier.h>
#include <wtf/Expected.h>
namespace WebCore {
template<typename ReturnType> class ExceptionOr {
public:
ExceptionOr(Exception&&);
ExceptionOr(ReturnType&&);
template<typename OtherType> ExceptionOr(const OtherType&, typename std::enable_if<std::is_scalar<OtherType>::value && std::is_convertible<OtherType, ReturnType>::value>::type* = nullptr);
bool hasException() const;
const Exception& exception() const;
Exception&& releaseException();
const ReturnType& returnValue() const;
ReturnType&& releaseReturnValue();
private:
Expected<ReturnType, Exception> m_value;
};
template<typename ReturnReferenceType> class ExceptionOr<ReturnReferenceType&> {
public:
ExceptionOr(Exception&&);
ExceptionOr(ReturnReferenceType&);
bool hasException() const;
const Exception& exception() const;
Exception&& releaseException();
const ReturnReferenceType& returnValue() const;
ReturnReferenceType& releaseReturnValue();
private:
ExceptionOr<ReturnReferenceType*> m_value;
};
template<> class ExceptionOr<void> {
public:
ExceptionOr(Exception&&);
ExceptionOr() = default;
bool hasException() const;
const Exception& exception() const;
Exception&& releaseException();
private:
Expected<void, Exception> m_value;
};
ExceptionOr<void> isolatedCopy(ExceptionOr<void>&&);
template<typename ReturnType> inline ExceptionOr<ReturnType>::ExceptionOr(Exception&& exception)
: m_value(makeUnexpected(WTFMove(exception)))
{
}
template<typename ReturnType> inline ExceptionOr<ReturnType>::ExceptionOr(ReturnType&& returnValue)
: m_value(WTFMove(returnValue))
{
}
template<typename ReturnType> template<typename OtherType> inline ExceptionOr<ReturnType>::ExceptionOr(const OtherType& returnValue, typename std::enable_if<std::is_scalar<OtherType>::value && std::is_convertible<OtherType, ReturnType>::value>::type*)
: m_value(static_cast<ReturnType>(returnValue))
{
}
template<typename ReturnType> inline bool ExceptionOr<ReturnType>::hasException() const
{
return !m_value.has_value();
}
template<typename ReturnType> inline const Exception& ExceptionOr<ReturnType>::exception() const
{
return m_value.error();
}
template<typename ReturnType> inline Exception&& ExceptionOr<ReturnType>::releaseException()
{
return WTFMove(m_value.error());
}
template<typename ReturnType> inline const ReturnType& ExceptionOr<ReturnType>::returnValue() const
{
return m_value.value();
}
template<typename ReturnType> inline ReturnType&& ExceptionOr<ReturnType>::releaseReturnValue()
{
return WTFMove(m_value.value());
}
template<typename ReturnReferenceType> inline ExceptionOr<ReturnReferenceType&>::ExceptionOr(Exception&& exception)
: m_value(WTFMove(exception))
{
}
template<typename ReturnReferenceType> inline ExceptionOr<ReturnReferenceType&>::ExceptionOr(ReturnReferenceType& returnValue)
: m_value(&returnValue)
{
}
template<typename ReturnReferenceType> inline bool ExceptionOr<ReturnReferenceType&>::hasException() const
{
return m_value.hasException();
}
template<typename ReturnReferenceType> inline const Exception& ExceptionOr<ReturnReferenceType&>::exception() const
{
return m_value.exception();
}
template<typename ReturnReferenceType> inline Exception&& ExceptionOr<ReturnReferenceType&>::releaseException()
{
return m_value.releaseException();
}
template<typename ReturnReferenceType> inline const ReturnReferenceType& ExceptionOr<ReturnReferenceType&>::returnValue() const
{
return *m_value.returnValue();
}
template<typename ReturnReferenceType> inline ReturnReferenceType& ExceptionOr<ReturnReferenceType&>::releaseReturnValue()
{
return *m_value.releaseReturnValue();
}
inline ExceptionOr<void>::ExceptionOr(Exception&& exception)
: m_value(makeUnexpected(WTFMove(exception)))
{
}
inline bool ExceptionOr<void>::hasException() const
{
return !m_value.has_value();
}
inline const Exception& ExceptionOr<void>::exception() const
{
return m_value.error();
}
inline Exception&& ExceptionOr<void>::releaseException()
{
return WTFMove(m_value.error());
}
inline ExceptionOr<void> isolatedCopy(ExceptionOr<void>&& value)
{
if (value.hasException())
return isolatedCopy(value.releaseException());
return { };
}
}
namespace WTF {
template<typename T> struct CrossThreadCopierBase<false, false, WebCore::ExceptionOr<T> > {
typedef WebCore::ExceptionOr<T> Type;
static Type copy(const Type& source)
{
if (source.hasException())
return crossThreadCopy(source.exception());
return crossThreadCopy(source.returnValue());
}
};
}