mtcore::thread::FutureState< T, void > Struct Template Reference

Represents the state-setter part of a future. More...

#include <future.hpp>

Inheritance diagram for mtcore::thread::FutureState< T, void >:

Collaboration diagram for mtcore::thread::FutureState< T, void >:

Classes
struct	make_res

Public Member Functions
void	set_val (const T &v)
	Sets the value of the associated future.
T	wait ()
	Called by the future, don't call this directly.
void	set_val (const T &v)
T	wait ()
	Called by the future, don't call this directly.
void	deinit (Allocator &alloc)

Static Public Member Functions
static Result< make_res, AllocationError >	make (Allocator &alloc)
	Makes a future and associated future state.
static Result< make_res, AllocationError >	make (Allocator &alloc, std::function< Result< Arc< void >, AllocationError >(Allocator &alloc, Arc< FutureState > &)> getExtra)
	Makes a future and associated future state.

Public Attributes
std::mutex	mux = {}
std::condition_variable	cv = {}
Optional< T >	value = nullopt
std::mutex	mux
std::condition_variable	cv
Optional< T >	value
Arc< void >	extra

Detailed Description

template<typename T>
struct mtcore::thread::FutureState< T, void >

Represents the state-setter part of a future.

When you return a future, your code that sets the future value needs to retain this part so it can actually set the future value. ONLY GET THIS USING THE make FUNCTION! That function will properly link the state to the future. Also, when calling make it will be wrapped in an Arc which you will need to deinit to clean up memory properly

Template Parameters

T	Future result type

Definition at line 87 of file future.hpp.

Member Function Documentation

deinit()

void mtcore::thread::FutureState< T, void >::deinit ( Allocator & alloc )

inline

Definition at line 164 of file future.hpp.

                                  {
      if (extra) {
        extra.deinit(alloc);
      }
    }

make() [1/2]

template<typename T>

static Result< make_res, AllocationError > mtcore::thread::FutureState< T, void >::make ( Allocator & alloc )

inlinestatic

Makes a future and associated future state.

Will return both

Parameters

alloc

Allocator for heap allocations

Definition at line 118 of file future.hpp.

                                                                    {
      Arc<FutureState> state;
      if (auto err = state.init(alloc); err.is_error()) {
        return err.error();
      }
      auto futureArc = state.acquire(alloc);
      if (futureArc.is_error()) {
        state.deinit(alloc);
        return error(AllocationError::ALLOCATION_FAILED);
      }
      return make_res{.future = Future<T>{.state = futureArc.value()}, .state = state};
    }

Here is the call graph for this function:

make() [2/2]

static Result< make_res, AllocationError > mtcore::thread::FutureState< T, void >::make ( Allocator & alloc, std::function< Result< Arc< void >, AllocationError >(Allocator &alloc, Arc< FutureState< T, void > > &)> getExtra )

inlinestatic

Makes a future and associated future state.

Will return both

Parameters

alloc	Allocator for heap allocations
getExtra	Callback to get extra state that you may later need to properly work with the future. Don't set it directly on the future state, just return your extra state and the make function will take it from there

Definition at line 182 of file future.hpp.

                                                                                                      {
      Arc<FutureState> state;
      if (auto err = state.init(alloc); err.is_error()) {
        return err.error();
      }
      Result<Arc<E>, AllocationError> extra = getExtra(alloc, state);
      if (extra.is_error()) {
        state.deinit(alloc);
        return extra.error();
      }
 
      state->extra   = extra.value();
      auto futureArc = state.acquire(alloc);
      if (futureArc.is_error()) {
        state.deinit(alloc);
        return error(AllocationError::ALLOCATION_FAILED);
      }
      return make_res{.future = Future<T, E>{.state = futureArc.value()}, .state = state};
    }

set_val() [1/2]

template<typename T>

void mtcore::thread::FutureState< T, void >::set_val ( const T & v )

inline

Sets the value of the associated future.

Definition at line 93 of file future.hpp.

                             {
      auto l = std::unique_lock{mux};
      ensure(value.empty(), "CANNOT SET FUTURE VALUE MULTIPLE TIMES! CONSIDER USING A CANNEL OR INBOX!");
      value = v;
      cv.notify_all();
    }

set_val() [2/2]

void mtcore::thread::FutureState< T, void >::set_val ( const T & v )

inline

Definition at line 147 of file future.hpp.

                             {
      auto l = std::unique_lock{mux};
      ensure(value.empty(), "CANNOT SET FUTURE VALUE MULTIPLE TIMES! CONSIDER USING A "
                            "CANNEL OR INBOX!");
      value = v;
      cv.notify_all();
    }

wait() [1/2]

template<typename T>

T mtcore::thread::FutureState< T, void >::wait ( )

inline

Called by the future, don't call this directly.

Definition at line 101 of file future.hpp.

             {
      auto l = std::unique_lock{mux};
      while (value.empty()) {
        cv.wait(l);
      }
      return *value;
    }

wait() [2/2]

T mtcore::thread::FutureState< T, void >::wait ( )

inline

Called by the future, don't call this directly.

Definition at line 156 of file future.hpp.

             {
      auto l = std::unique_lock{mux};
      while (value.empty()) {
        cv.wait(l);
      }
      return *value;
    }

Member Data Documentation

cv [1/2]

template<typename T>

std::condition_variable mtcore::thread::FutureState< T, void >::cv = {}

Definition at line 89 of file future.hpp.

{};

cv [2/2]

std::condition_variable mtcore::thread::FutureState< T, void >::cv

Definition at line 143 of file future.hpp.

{};

extra

Arc<void> mtcore::thread::FutureState< T, void >::extra

Definition at line 145 of file future.hpp.

{};

mux [1/2]

template<typename T>

std::mutex mtcore::thread::FutureState< T, void >::mux = {}

Definition at line 88 of file future.hpp.

{};

mux [2/2]

std::mutex mtcore::thread::FutureState< T, void >::mux

Definition at line 142 of file future.hpp.

{};

value [1/2]

template<typename T>

Optional<T> mtcore::thread::FutureState< T, void >::value = nullopt

Definition at line 90 of file future.hpp.

value [2/2]

Optional<T> mtcore::thread::FutureState< T, void >::value

Definition at line 144 of file future.hpp.

---

The documentation for this struct was generated from the following file:

• future.hpp