fsdk/html/_result_value_8h_source.html

00001 #pragma once
00002
00003 #include <fsdk/Types/Result.h>
00004
00005 #include <cassert>
00006 #include <type_traits>
00007 #include <utility>
00008
00009 namespace fsdk {
00020     template <typename R, typename V, class Enable = void>
00021     struct ResultValue : Result<R> {};
00022
00023     template <typename R, typename V>
00024     struct ResultValue<R, V, typename std::enable_if<std::is_copy_constructible<V>::value>::type> : Result<R> {
00026         typedef R EnumType;
00027
00029         typedef V ValueType;
00030
00034         ResultValue(R result) noexcept
00035             : Result<R>(result) {
00036         }
00037
00042         ResultValue(R result, const V& value) noexcept
00043             : Result<R>(result)
00044             , m_value(value) {
00045         }
00046
00051         ResultValue(R result, V&& value) noexcept
00052             : Result<R>(result)
00053             , m_value(std::move(value)) {
00054         }
00055
00060         const V& getValue() const noexcept {
00061             assert(this->isOk() && "Acessing value of erroneous result.");
00062             return m_value;
00063         }
00064
00071         V&& takeValue() noexcept {
00072             return std::move(m_value);
00073         }
00074
00079         const V* operator->() const noexcept {
00080             return &getValue();
00081         }
00082
00083     protected:
00084         V m_value;
00085     };
00086
00096     template <typename R, typename V>
00097     struct ResultValue<R, V, typename std::enable_if<std::is_copy_constructible<V>::value == false>::type> :
00098         Result<R> {
00100         typedef R EnumType;
00101
00103         typedef V ValueType;
00104
00108         ResultValue(R result) noexcept
00109             : Result<R>(result) {
00110         }
00111
00116         ResultValue(R result, V&& value) noexcept
00117             : Result<R>(result)
00118             , m_value(std::move(value)) {
00119         }
00120
00125         const V& getValue() const noexcept {
00126             assert(this->isOk() && "Acessing value of erroneous result.");
00127             return m_value;
00128         }
00129
00136         V&& takeValue() noexcept {
00137             return std::move(m_value);
00138         }
00139
00144         const V* operator->() const noexcept {
00145             return &getValue();
00146         }
00147
00148     protected:
00149         V m_value;
00150     };
00151
00162     template <typename R, typename V>
00163     inline ResultValue<R, typename std::remove_const<typename std::remove_reference<V>::type>::type>
00164     makeResultValue(R result, V&& value) noexcept {
00165         return ResultValue<R, typename std::remove_const<typename std::remove_reference<V>::type>::type>(
00166             result,
00167             std::forward<V>(value));
00168     }
00169 } // namespace fsdk