coffee/etl
1
0
Fork 0
mirror of https://github.com/ETLCPP/etl.git synced 2026-07-01 06:48:44 +08:00
Code Issues Packages Projects Releases Wiki Activity

Work-In-Progress

Browse Source
This commit is contained in:
John Wellbelove 2022-10-27 09:52:39 +01:00
parent cea3aea259
commit a1bf74009f
5 changed files with 229 additions and 119 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

308
include/etl/expected.h
View File

@ -35,10 +35,56 @@ SOFTWARE.
///\ingroup utilities
#include "platform.h"
#include "exception.h"
#include "error_handler.h"
#include "utility.h"
#include "variant.h"
namespace etl
{
//***************************************************************************
/// Base exception for et::expected
//***************************************************************************
class expected_exception : public etl::exception
{
public:
expected_exception(string_type reason_, string_type file_name_, numeric_type line_number_)
: exception(reason_, file_name_, line_number_)
{
}
};
//***************************************************************************
/// expected_invalid
//***************************************************************************
template <typename TError>
class expected_invalid;
//*******************************************
template<>
class expected_invalid<void> : public etl::expected_exception
{
public:
expected_invalid(string_type file_name_, numeric_type line_number_)
: expected_exception(ETL_ERROR_TEXT("expected:invalid", ETL_EXPECTED_FILE_ID"A"), file_name_, line_number_)
{
}
};
//*******************************************
template <typename TError>
class expected_invalid : etl::expected_invalid<void>
{
public:
expected_invalid(string_type file_name_, numeric_type line_number_)
: expected_invalid<void>(file_name_, line_number_)
{
}
};
//***************************************************************************
/// Unexpected type.
/// etl::unexpected represents an unexpected value stored in etl::expected.
@ -56,6 +102,7 @@ namespace etl
{
}
#if ETL_CPP11_SUPPORTED
//*******************************************
/// Move constructor.
//*******************************************
@ -63,24 +110,25 @@ namespace etl
: error_value(etl::move(other.error_value))
{
}
#endif
#if ETL_CPP11_SUPPORTED
//*******************************************
/// Construct from argument.
//*******************************************
template <typename E = TError, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<Err>::type, etl::unexpected>::value &&
!etl::is_same<typename etl::remove_cvref<Err>::type, etl::in_place_t>::value, int>::type>
constexpr explicit unexpected(E&& e)
: error_value(etl::forward<TError>(e))
template <typename TErr = TError, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TErr>::type, etl::unexpected>::value &&
!etl::is_same<typename etl::remove_cvref<TErr>::type, etl::in_place_t>::value, int>::type>
constexpr explicit unexpected(TErr&& e)
: error_value(etl::forward<TErr>(e))
{
}
#else
//*******************************************
/// Construct from argument.
//*******************************************
template <typename E>
explicit unexpected(const E& e, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<Err>::type, etl::unexpected>::value &&
!etl::is_same<typename etl::remove_cvref<Err>::type, etl::in_place_t>::value, int>::type = 0)
template <typename TErr>
explicit unexpected(const TErr& e, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TErr>::type, etl::unexpected>::value &&
!etl::is_same<typename etl::remove_cvref<TErr>::type, etl::in_place_t>::value, int>::type = 0)
: error_value(e)
{
}
@ -111,7 +159,7 @@ namespace etl
//*******************************************
/// Assign from etl::unexpected.
//*******************************************
unexpected& operator =(const etl::unexpected& rhs)
unexpected<TError>& operator =(const etl::unexpected<TError>& rhs)
{
error_value = rhs.error_value;
}
@ -120,7 +168,7 @@ namespace etl
//*******************************************
/// Move assign from etl::unexpected.
//*******************************************
unexpected& operator =(etl::unexpected&& rhs)
unexpected<TError>& operator =(etl::unexpected<TError>&& rhs)
{
error_value = etl::move(rhs.error_value);
}
@ -137,7 +185,7 @@ namespace etl
//*******************************************
/// Swap with another etl::unexpected.
//*******************************************
swap(etl::unexpected& other)
void swap(etl::unexpected<TError>& other)
{
using ETL_OR_STD::swap;
@ -195,13 +243,13 @@ namespace etl
#if ETL_CPP11_SUPPORTED
template <typename U>
using rebind = etl::expected<U, error_type>;
using rebind = etl::expected<U, TError>;
#endif
//*******************************************
/// Default constructor
//*******************************************
ETL_CONSTEXPR14 expected(const expected& other) ETL_NOEXCEPT
ETL_CONSTEXPR14 expected() ETL_NOEXCEPT
: data(TValue())
{
}
@ -209,7 +257,7 @@ namespace etl
//*******************************************
/// Copy constructor
//*******************************************
ETL_CONSTEXPR14 expected(const expected& other)
ETL_CONSTEXPR14 expected(const expected& other) ETL_NOEXCEPT
: data(other.data)
{
}
@ -224,111 +272,49 @@ namespace etl
}
#endif
template <typename U, typename F>
constexpr explicit() expected(const expected<U, F>& other)
{
}
template <typename U, typename F>
constexpr explicit(expected(expected<U, F>&& other)
{
}
#if ETL_CPP11_SUPPORTED
template <typename U = T>
constexpr explicit expected(U&& v)
{
}
#endif
template <typename F>
constexpr explicit expected(const etl::unexpected<F>& e)
ETL_CONSTEXPR14 explicit expected(const etl::unexpected<F>& ue)
: data(ue)
{
}
#if ETL_CPP11_SUPPORTED
template <typename F>
constexpr explicit expected(etl::unexpected<F>&& e)
ETL_CONSTEXPR14 explicit expected(etl::unexpected<F>&& ue)
: data(etl::move(ue))
{
}
#endif
constexpr explicit expected(etl::in_place_t) noexcept
ETL_CONSTEXPR14 explicit expected(etl::in_place_t) ETL_NOEXCEPT
: data(TValue())
{
}
template <typename... Args>
constexpr explicit expected(etl::in_place_t, Args&&... args)
ETL_CONSTEXPR14 explicit expected(etl::in_place_t, Args&&... args)
: data(etl::forward<Args>(args)...)
{
}
template <typename U, typename... Args>
constexpr explicit expected(etl::in_place_t, std::initializer_list<U> il, Args&&... args)
ETL_CONSTEXPR14 explicit expected(etl::in_place_t, std::initializer_list<U> il, Args&&... args)
: data(il, etl::forward<Args>(args)...)
{
}
template <typename... Args>
constexpr explicit expected(etl::unexpect_t, Args&&... args)
ETL_CONSTEXPR14 explicit expected(etl::unexpect_t, Args&&... args)
: data(etl::unexpected<TError>(args...))
{
}
template <typename U, typename... Args>
constexpr explicit expected(etl::unexpect_t, std::initializer_list<U> il, Args&&... args)
ETL_CONSTEXPR14 explicit expected(etl::unexpect_t, std::initializer_list<U> il, Args&&... args)
: data(etl::unexpected<TError>(il, args...))
{
}
// //*******************************************
// // Construct from a value
// //*******************************************
// expected(const TValue& value)
// : data(value)
// {
// }
//
//#if ETL_CPP11_SUPPORTED
// //*******************************************
// // Move construct from a value
// //*******************************************
// expected(TValue&& value)
// : data(etl::move(value))
// {
// }
//#endif
////*******************************************
///// Construct from error
////*******************************************
//expected(const TError& error)
// : data(error)
//{
//}
////*******************************************
///// Move construct from error
////*******************************************
//expected(TError&& error)
// : data(etl::move(error))
//{
//}
//*******************************************
/// Copy assign
//*******************************************
expected& operator =(const expected& other)
{
data = other.data;
return *this;
}
//*******************************************
/// Move assign
//*******************************************
expected& operator =(expected&& other)
{
data = etl::move(other.data);
return *this;
}
//*******************************************
/// Copy assign from value
//*******************************************
@ -365,6 +351,39 @@ namespace etl
return *this;
}
#if ETL_CPP11_SUPPORTED
//*******************************************
///
//*******************************************
ETL_CONSTEXPR14 T& value() &
{
return etl::get<TValue>(data);
}
//*******************************************
///
//*******************************************
ETL_CONSTEXPR14 const T& value() const&
{
return etl::get<TValue>(data);
}
//*******************************************
///
//*******************************************
ETL_CONSTEXPR14 T&& value() &&
{
return etl::move(etl::get<TValue>(data));
}
//*******************************************
///
//*******************************************
ETL_CONSTEXPR14 const T&& value() const&&
{
return etl::move(etl::get<TValue>(data));
}
#else
//*******************************************
/// Returns a const reference to the value.
/// Undefined if the expected does not contain an value.
@ -373,15 +392,7 @@ namespace etl
{
return etl::get<TValue>(data);
}
//*******************************************
/// Returns an rvalue reference to the value.
/// Undefined if the expected does not contain an value.
//*******************************************
ETL_CONSTEXPR14 TValue&& value()
{
return etl::move(etl::get<TValue>(etl::move(data)));
}
#endif
#if ETL_CPP11_SUPPORTED
//*******************************************
@ -433,6 +444,39 @@ namespace etl
}
#endif
#if ETL_CPP11_SUPPORTED
//*******************************************
///
//*******************************************
ETL_CONSTEXPR14 const TError& error() const& ETL_NOEXCEPT
{
return etl::get<TError>(data);
}
//*******************************************
///
//*******************************************
ETL_CONSTEXPR14 TError& error() & ETL_NOEXCEPT
{
return etl::get<TError>(data);
}
//*******************************************
///
//*******************************************
ETL_CONSTEXPR14 const TError&& error() const&& ETL_NOEXCEPT
{
return etl::move(etl::get<TError>(data));
}
//*******************************************
///
//*******************************************
ETL_CONSTEXPR14 TError&& error() && ETL_NOEXCEPT
{
return etl::move(etl::get<TError>(data));
}
#else
//*******************************************
/// Returns a const reference to the error.
/// Undefined if the expected does not contain an error.
@ -441,34 +485,82 @@ namespace etl
{
return etl::get<TError>(data);
}
#endif
#if (ETL_CPP11_SUPPORTED)
#if ETL_CPP11_SUPPORTED
//*******************************************
/// Returns an rvalue reference to the error.
/// Undefined if the expected does not contain an error.
///
//*******************************************
ETL_CONSTEXPR14 TError&& error() &&
template <typename... Args>
ETL_CONSTEXPR14 T& emplace(Args&&... args) ETL_NOEXCEPT
{
return etl::move(etl::get<TError>(data));
data.emplace(args...);
}
//*******************************************
/// Returns an rvalue reference to the error.
/// Undefined if the expected does not contain an error.
///
//*******************************************
ETL_CONSTEXPR14 TError&& error() const &&
template <typename U, typename... Args>
ETL_CONSTEXPR14 T& emplace(std::initializer_list<U>& il, Args&&... args) ETL_NOEXCEPT
{
return etl::move(etl::get<TError>(data));
data.emplace(il, args...);
}
#endif
//*******************************************
///
//*******************************************
TValue* operator ->()
{
#if ETL_IS_DEBUG_BUILD
ETL_ASSERT(valid, ETL_ERROR(expected_invalid));
#endif
return etl::addressof(data.get<TValue>());
}
//*******************************************
///
//*******************************************
const TValue* operator ->() const
{
#if ETL_IS_DEBUG_BUILD
ETL_ASSERT(valid, ETL_ERROR(expected_invalid));
#endif
return etl::addressof(data.get<TValue>());
}
//*******************************************
///
//*******************************************
TValue& operator *()
{
#if ETL_IS_DEBUG_BUILD
ETL_ASSERT(valid, ETL_ERROR(expected_invalid));
#endif
return data.get<TValue>();
}
//*******************************************
///
//*******************************************
const TValue& operator *() const
{
#if ETL_IS_DEBUG_BUILD
ETL_ASSERT(valid, ETL_ERROR(expected_invalid));
#endif
return data.get<TValue>();
}
private:
etl::variant<TValue, TError> data;
};
//*****************************************************************************
/// Result type.
/// Specialisation for void value type.
//*****************************************************************************
template<typename TError>

2
include/etl/file_error_numbers.h
View File

@ -100,5 +100,5 @@ SOFTWARE.
#define ETL_BIP_BUFFER_SPSC_ATOMIC_FILE_ID "67"
#define ETL_REFERENCE_COUNTED_OBJECT_FILE_ID "68"
#define ETL_TO_ARITHMETIC_FILE_ID "69"
#define ETL_EXPECTED_FILE_ID "70"
#endif

6
include/etl/optional.h
View File

@ -91,7 +91,7 @@ namespace etl
public:
optional_invalid(string_type file_name_, numeric_type line_number_)
: optional_exception("optional: invalid", file_name_, line_number_)
: optional_exception("optional:invalid", file_name_, line_number_)
{
}
};
@ -100,7 +100,7 @@ namespace etl
/// An optional type.
/// If the optional type is not initialised then a type is not constructed.
/// See http://en.cppreference.com/w/cpp/utility/optional
///\tparam The type to store.
///\tparam T The type to store.
///\ingroup utilities
//*****************************************************************************
template <typename T, bool is_pod = etl::is_pod<T>::value>
@ -516,6 +516,8 @@ namespace etl
//*****************************************************************************
/// For POD types.
///\tparam T The type to store.
///\ingroup utilities
//*****************************************************************************
template <typename T>
class optional<T, true>

20
include/etl/result.h
View File

@ -49,7 +49,7 @@ namespace etl
/// Result type.
//*****************************************************************************
template <typename TValue, typename TError>
class result
class ETL_DEPRECATED result
{
public:
@ -66,6 +66,7 @@ namespace etl
{
}
#if ETL_CPP11_SUPPORTED
//*******************************************
/// Move constructor
//*******************************************
@ -73,6 +74,7 @@ namespace etl
: data(etl::move(other.data))
{
}
#endif
//*******************************************
// Construct from a value
@ -85,7 +87,7 @@ namespace etl
//*******************************************
// Move construct from a value
//*******************************************
result(TValue&& value)
result(TValue&& value)
: data(etl::move(value))
{
}
@ -101,10 +103,12 @@ namespace etl
//*******************************************
/// Move construct from error
//*******************************************
#if ETL_CPP11_SUPPORTED
result(TError&& error)
: data(etl::move(error))
{
}
#endif
//*******************************************
/// Copy assign
@ -136,11 +140,13 @@ namespace etl
//*******************************************
/// Move assign from value
//*******************************************
#if ETL_CPP11_SUPPORTED
result& operator =(TValue&& value)
{
data = etl::move(value);
return *this;
}
#endif
//*******************************************
/// Copy assign from error
@ -154,11 +160,13 @@ namespace etl
//*******************************************
/// Move assign from error
//*******************************************
#if ETL_CPP11_SUPPORTED
result& operator =(TError&& error)
{
data = etl::move(error);
return *this;
}
#endif
//*******************************************
/// <b>true</b> if result contains a value
@ -215,10 +223,12 @@ namespace etl
/// Returns an rvalue reference to the error.
/// Undefined if the result does not contain an error.
//*******************************************
#if ETL_CPP11_SUPPORTED
TError&& error()
{
return etl::move(etl::get<TError>(etl::move(data)));
}
#endif
private:
@ -269,10 +279,12 @@ namespace etl
//*******************************************
/// Move construct from error
//*******************************************
#if ETL_CPP11_SUPPORTED
result(TError&& err_)
: err(etl::move(err_))
{
}
#endif
//*******************************************
/// Copy assign from error
@ -286,11 +298,13 @@ namespace etl
//*******************************************
/// Move assign from error
//*******************************************
#if ETL_CPP11_SUPPORTED
result& operator =(TError&& err_)
{
err = etl::move(err_);
return *this;
}
#endif
//*******************************************
/// <b>true</b> if result contains a value
@ -321,10 +335,12 @@ namespace etl
/// Returns an rvalue reference to the error.
/// Undefined if the result does not contain an error.
//*******************************************
#if ETL_CPP11_SUPPORTED
TError&& error()
{
return etl::move(err);
}
#endif
private:

12
test/vs2019/etl.vcxproj.filters
View File

@ -345,9 +345,6 @@
<ClInclude Include="..\..\include\etl\io_port.h">
<Filter>ETL\Utilities</Filter>
</ClInclude>
<ClInclude Include="..\..\include\etl\optional.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\include\etl\set.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
@ -1344,6 +1341,9 @@
<ClInclude Include="..\..\include\etl\expected.h">
<Filter>ETL\Utilities</Filter>
</ClInclude>
<ClInclude Include="..\..\include\etl\optional.h">
<Filter>ETL\Utilities</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="..\test_string_char.cpp">
@ -2192,9 +2192,6 @@
<ClCompile Include="..\test_random.cpp">
<Filter>Tests\Maths</Filter>
</ClCompile>
<ClCompile Include="..\test_optional.cpp">
<Filter>Tests\Containers</Filter>
</ClCompile>
<ClCompile Include="..\test_error_handler.cpp">
<Filter>Tests\Errors</Filter>
</ClCompile>
@ -3392,6 +3389,9 @@
<ClCompile Include="..\sanity-check\to_arithmetic.h.t.cpp">
<Filter>Tests\Sanity Checks\Source</Filter>
</ClCompile>
<ClCompile Include="..\test_optional.cpp">
<Filter>Tests\Misc</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<None Include="..\..\library.properties">