TheCloud/thor-os
1
0
Fork 0
mirror of https://github.com/wichtounet/thor-os.git synced 2025-09-11 05:24:44 -04:00
Code Issues Packages Projects Releases Wiki Activity

Cleanup

Browse Source
This commit is contained in:
Baptiste Wicht 2016-09-25 21:30:44 +02:00
parent 4d95ac489e
commit 424e47a3aa
1 changed files with 170 additions and 134 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

172
tstl/include/expected.hpp
View File

@ -17,41 +17,47 @@
namespace std {
constexpr struct only_set_valid_t {} only_set_valid;
constexpr struct only_set_valid_t {
} only_set_valid;
template <typename E>
struct exceptional {
typedef E error_type;
using error_type = E; ///< The error type
error_type error;
error_type error; ///< The error value
exceptional(): error() {
exceptional()
: error() {
//Nothing else to init
}
explicit exceptional(error_type e) : error(e) {
explicit exceptional(error_type e)
: error(e) {
//Nothing else to init
}
};
template <typename T, typename E>
union trivial_expected_storage {
typedef T value_type;
typedef E error_type;
using value_type = T; ///< The value type
using error_type = E; ///< The error type
error_type error;
value_type value;
error_type error; ///< The error value
value_type value; ///< The value
constexpr trivial_expected_storage() : value(){
constexpr trivial_expected_storage()
: value() {
//Nothing else to init
}
constexpr trivial_expected_storage(const exceptional<error_type>& e) : error(e.error){
constexpr trivial_expected_storage(const exceptional<error_type>& e)
: error(e.error) {
//Nothing else to init
}
template <typename... Args>
constexpr trivial_expected_storage(Args&&... args): value(std::forward<Args>(args)...){
constexpr trivial_expected_storage(Args&&... args)
: value(std::forward<Args>(args)...) {
//Nothing else to init
}
@ -60,16 +66,17 @@ union trivial_expected_storage {
template <typename E>
union trivial_expected_storage<void, E> {
typedef void value_type;
typedef E error_type;
using value_type = Type; ///< The value type
using error_type = E; ///< The error type
error_type error;
error_type error; ///< The error value
constexpr trivial_expected_storage() {
//Nothing else to init
}
constexpr trivial_expected_storage(const exceptional<error_type>& e) : error(e.error){
constexpr trivial_expected_storage(const exceptional<error_type>& e)
: error(e.error) {
//Nothing else to init
}
@ -78,22 +85,25 @@ union trivial_expected_storage <void, E> {
template <typename T, typename E>
struct non_trivial_expected_storage {
typedef T value_type;
typedef E error_type;
using value_type = T; ///< The value type
using error_type = E; ///< The error type
error_type error;
value_type value;
error_type error; ///< The error value
value_type value; ///< The value
constexpr non_trivial_expected_storage() : value(){
constexpr non_trivial_expected_storage()
: value() {
//Nothing else to init
}
constexpr non_trivial_expected_storage(const exceptional<error_type>& e) : error(e.error){
constexpr non_trivial_expected_storage(const exceptional<error_type>& e)
: error(e.error) {
//Nothing else to init
}
template <typename... Args>
constexpr non_trivial_expected_storage(Args&&... args): value(std::forward<Args>(args)...){
constexpr non_trivial_expected_storage(Args&&... args)
: value(std::forward<Args>(args)...) {
//Nothing else to init
}
@ -102,16 +112,17 @@ struct non_trivial_expected_storage {
template <typename E>
struct non_trivial_expected_storage<void, E> {
typedef void value_type;
typedef E error_type;
using value_type = Type; ///< The value type
using error_type = E; ///< The error type
error_type error;
error_type error; ///< The error value
constexpr non_trivial_expected_storage() {
//Nothing else to init
}
constexpr non_trivial_expected_storage(exceptional<error_type>& e) : error(e.error){
constexpr non_trivial_expected_storage(exceptional<error_type>& e)
: error(e.error) {
//Nothing else to init
}
@ -120,29 +131,34 @@ struct non_trivial_expected_storage <void, E> {
template <typename T, typename E>
struct trivial_expected_base {
typedef T value_type;
typedef E error_type;
using value_type = T; ///< The value type
using error_type = E; ///< The error type
bool has_value;
bool has_value; ///< Indicates if the base has a value
trivial_expected_storage<T, E> storage;
trivial_expected_base() : has_value(true), storage(){
trivial_expected_base()
: has_value(true), storage() {
//Nothing else to init
}
trivial_expected_base(only_set_valid_t, bool hv) : has_value(hv){
trivial_expected_base(only_set_valid_t, bool hv)
: has_value(hv) {
//Nothing else to init
}
trivial_expected_base(const value_type& v) : has_value(true), storage(v){
trivial_expected_base(const value_type& v)
: has_value(true), storage(v) {
//Nothing else to init
}
trivial_expected_base(value_type&& v) : has_value(true), storage(std::forward<value_type>(v)){
trivial_expected_base(value_type&& v)
: has_value(true), storage(std::forward<value_type>(v)) {
//Nothing else to init
}
trivial_expected_base(const exceptional<error_type>& e) : has_value(false), storage(e) {
trivial_expected_base(const exceptional<error_type>& e)
: has_value(false), storage(e) {
//Nothing else to init
}
@ -151,20 +167,23 @@ struct trivial_expected_base {
template <typename E>
struct trivial_expected_base<void, E> {
typedef E error_type;
using error_type = E; ///< The error type
bool has_value;
bool has_value; ///< Indicates if the base has a value
trivial_expected_storage<void, E> storage;
trivial_expected_base() : has_value(true), storage(){
trivial_expected_base()
: has_value(true), storage() {
//Nothing else to init
}
trivial_expected_base(only_set_valid_t, bool hv) : has_value(hv){
trivial_expected_base(only_set_valid_t, bool hv)
: has_value(hv) {
//Nothing else to init
}
trivial_expected_base(const exceptional<error_type>& e) : has_value(false), storage(e) {
trivial_expected_base(const exceptional<error_type>& e)
: has_value(false), storage(e) {
//Nothing else to init
}
@ -173,29 +192,34 @@ struct trivial_expected_base <void, E> {
template <typename T, typename E>
struct non_trivial_expected_base {
typedef T value_type;
typedef E error_type;
using value_type = T; ///< The value type
using error_type = E; ///< The error type
bool has_value;
non_trivial_expected_storage<T, E> storage;
non_trivial_expected_base() : has_value(true), storage(){
non_trivial_expected_base()
: has_value(true), storage() {
//Nothing else to init
}
non_trivial_expected_base(only_set_valid_t, bool hv) : has_value(hv){
non_trivial_expected_base(only_set_valid_t, bool hv)
: has_value(hv) {
//Nothing else to init
}
non_trivial_expected_base(const value_type& v) : has_value(true), storage(v){
non_trivial_expected_base(const value_type& v)
: has_value(true), storage(v) {
//Nothing else to init
}
non_trivial_expected_base(value_type&& v) : has_value(true), storage(std::forward<value_type>(v)){
non_trivial_expected_base(value_type&& v)
: has_value(true), storage(std::forward<value_type>(v)) {
//Nothing else to init
}
non_trivial_expected_base(const exceptional<error_type>& e) : has_value(false), storage(e) {
non_trivial_expected_base(const exceptional<error_type>& e)
: has_value(false), storage(e) {
//Nothing else to init
}
@ -210,20 +234,23 @@ struct non_trivial_expected_base {
template <typename E>
struct non_trivial_expected_base<void, E> {
typedef E error_type;
using error_type = E; ///< The error type
bool has_value;
bool has_value; ///< Indicates if the base has a value
non_trivial_expected_storage<void, E> storage;
non_trivial_expected_base() : has_value(true), storage(){
non_trivial_expected_base()
: has_value(true), storage() {
//Nothing else to init
}
non_trivial_expected_base(only_set_valid_t, bool hv) : has_value(hv){
non_trivial_expected_base(only_set_valid_t, bool hv)
: has_value(hv) {
//Nothing else to init
}
non_trivial_expected_base(const exceptional<error_type>& e) : has_value(false), storage(e) {
non_trivial_expected_base(const exceptional<error_type>& e)
: has_value(false), storage(e) {
//Nothing else to init
}
@ -238,13 +265,12 @@ template <typename T, typename E>
using expected_base = std::conditional_t<
std::is_trivially_destructible<T>::value && std::is_trivially_destructible<E>::value,
trivial_expected_base<T, E>,
non_trivial_expected_base<T, E>
>;
non_trivial_expected_base<T, E>>;
template <typename T, typename E = size_t>
struct expected : expected_base<T, E> {
typedef T value_type;
typedef E error_type;
using value_type = T; ///< The value type
using error_type = E; ///< The error type
typedef expected<T, E> this_type;
typedef expected_base<T, E> base_type;
@ -305,15 +331,18 @@ private:
public:
/* Constructors */
constexpr expected(const value_type& v) : base_type(v){
constexpr expected(const value_type& v)
: base_type(v) {
//Nothing else to init
}
constexpr expected(value_type&& v) : base_type(std::forward<value_type>(v)){
constexpr expected(value_type&& v)
: base_type(std::forward<value_type>(v)) {
//Nothing else to init
}
expected(const expected& rhs) : base_type(only_set_valid, rhs.valid()) {
expected(const expected& rhs)
: base_type(only_set_valid, rhs.valid()) {
if (rhs.valid()) {
::new (value_ptr()) value_type(rhs.contained_value());
} else {
@ -321,7 +350,8 @@ public:
}
}
expected(expected&& rhs) : base_type(only_set_valid, rhs.valid()) {
expected(expected&& rhs)
: base_type(only_set_valid, rhs.valid()) {
if (rhs.valid()) {
new (value_ptr()) value_type(std::move(rhs.contained_value()));
} else {
@ -329,11 +359,13 @@ public:
}
}
expected(const exceptional<error_type>& e) : base_type(e) {
expected(const exceptional<error_type>& e)
: base_type(e) {
//Nothing else to init
}
expected() : base_type() {}
expected()
: base_type() {}
~expected() = default;
@ -424,8 +456,8 @@ public:
template <typename E>
struct expected<void, E> : expected_base<void, E> {
typedef void value_type;
typedef E error_type;
using value_type = void; ///< The value type
using error_type = E; ///< The error type
typedef expected<void, E> this_type;
typedef expected_base<void, E> base_type;
@ -466,23 +498,27 @@ private:
public:
/* Constructors */
expected(const expected& rhs) : base_type(only_set_valid, rhs.valid()) {
expected(const expected& rhs)
: base_type(only_set_valid, rhs.valid()) {
if (!rhs.valid()) {
::new (error_ptr()) error_type(rhs.contained_error());
}
}
expected(expected&& rhs) : base_type(only_set_valid, rhs.valid()) {
expected(expected&& rhs)
: base_type(only_set_valid, rhs.valid()) {
if (!rhs.valid()) {
new (error_ptr()) error_type(std::move(rhs.contained_error()));
}
}
expected(const exceptional<error_type>& e) : base_type(e) {
expected(const exceptional<error_type>& e)
: base_type(e) {
//Nothing else to init
}
expected() : base_type() {}
expected()
: base_type() {}
~expected() = default;