llfio_v2_xxx::byte_io_multiplexer::_unsynchronised_io_operation_state Struct Reference

An unsynchronised i/o operation state. More...

#include "byte_io_multiplexer.hpp"

Inheritance diagram for llfio_v2_xxx::byte_io_multiplexer::_unsynchronised_io_operation_state:

Classes
union	payload_t
	Variant storage. More...

Public Member Functions
constexpr	_unsynchronised_io_operation_state ()
	Construct an unknown state.
	_unsynchronised_io_operation_state (byte_io_handle *_h, io_operation_state_visitor *_v, registered_buffer_type &&b, deadline d, io_request< buffers_type > reqs)
	Construct a read operation state.
	_unsynchronised_io_operation_state (byte_io_handle *_h, io_operation_state_visitor *_v, registered_buffer_type &&b, deadline d, io_request< const_buffers_type > reqs)
	Construct a write operation state.
	_unsynchronised_io_operation_state (byte_io_handle *_h, io_operation_state_visitor *_v, registered_buffer_type &&b, deadline d, io_request< const_buffers_type > reqs, barrier_kind kind)
	Construct a barrier operation state.
	_unsynchronised_io_operation_state (io_result< buffers_type > &&res)
	Construct a finished read operation state.
	_unsynchronised_io_operation_state (io_result< const_buffers_type > &&res)
	Construct a finished write or barrier operation state.
	_unsynchronised_io_operation_state (const _unsynchronised_io_operation_state &)=delete
_unsynchronised_io_operation_state &	operator= (const _unsynchronised_io_operation_state &)=delete
_unsynchronised_io_operation_state &	operator= (_unsynchronised_io_operation_state &&)=delete
void	clear_storage ()
	Used to clear the storage in this operation state.
virtual void *	invoke (function_ptr< void *(io_operation_state_type)> c) const noexcept override
	Invoke the callable with the per-i/o state lock held, if any.
virtual io_operation_state_type	current_state () const noexcept override
	Used to retrieve the current state of the i/o operation.
virtual io_result< buffers_type >	get_completed_read () &&noexcept override
	After an i/o operation has finished, can be used to retrieve the result if the visitor did not.
virtual io_result< const_buffers_type >	get_completed_write_or_barrier () &&noexcept override
	After an i/o operation has finished, can be used to retrieve the result if the visitor did not.
virtual io_operation_state *	relocate_to (byte *to_) noexcept override
	Relocate the state to new storage, clearing the original state. Terminates the process if the state is in use.
void	_read_initiated (lock_guard &g)
void	_read_completed (lock_guard &g, io_result< buffers_type > &&res)
void	_read_finished (lock_guard &g)
void	_write_initiated (lock_guard &g)
void	_write_completed (lock_guard &g, io_result< const_buffers_type > &&res)
void	_barrier_initiated (lock_guard &g)
void	_barrier_completed (lock_guard &g, io_result< const_buffers_type > &&res)
void	_write_or_barrier_finished (lock_guard &g)
virtual void	read_initiated ()
virtual void	read_completed (io_result< buffers_type > &&res)
virtual void	read_finished ()
virtual void	write_initiated ()
virtual void	write_completed (io_result< const_buffers_type > &&res)
virtual void	barrier_initiated ()
virtual void	barrier_completed (io_result< const_buffers_type > &&res)
virtual void	write_or_barrier_finished ()

Public Attributes
io_operation_state_type	state {io_operation_state_type::unknown}
	The current lifecycle state of this i/o operation.
union llfio_v2_xxx::byte_io_multiplexer::_unsynchronised_io_operation_state::payload_t	payload
byte_io_handle *	h {nullptr}
	The i/o handle the i/o operation is upon.
io_operation_state_visitor *	visitor {nullptr}
	The state visitor supplied when the operation was initialised.

Protected Member Functions
	_unsynchronised_io_operation_state (_unsynchronised_io_operation_state &&o) noexcept
virtual void	_lock () noexcept
virtual void	_unlock () noexcept

Detailed Description

An unsynchronised i/o operation state.

This implementation does NOT use atomics during access.

Constructor & Destructor Documentation

_unsynchronised_io_operation_state() [1/7]

constexpr llfio_v2_xxx::byte_io_multiplexer::_unsynchronised_io_operation_state::_unsynchronised_io_operation_state ( )

inlineconstexpr

Construct an unknown state.

{}

_unsynchronised_io_operation_state() [2/7]

llfio_v2_xxx::byte_io_multiplexer::_unsynchronised_io_operation_state::_unsynchronised_io_operation_state ( byte_io_handle *  _h, io_operation_state_visitor *  _v, registered_buffer_type &&  b, deadline  d, io_request< buffers_type >  reqs  )

inline

Construct a read operation state.

        : io_operation_state(_h, _v)
        , state(io_operation_state_type::read_initialised)
        , payload(std::move(b), d, std::move(reqs))
    {
    }

_unsynchronised_io_operation_state() [3/7]

llfio_v2_xxx::byte_io_multiplexer::_unsynchronised_io_operation_state::_unsynchronised_io_operation_state ( byte_io_handle *  _h, io_operation_state_visitor *  _v, registered_buffer_type &&  b, deadline  d, io_request< const_buffers_type >  reqs  )

inline

Construct a write operation state.

        : io_operation_state(_h, _v)
        , state(io_operation_state_type::write_initialised)
        , payload(std::move(b), d, std::move(reqs))
    {
    }

_unsynchronised_io_operation_state() [4/7]

llfio_v2_xxx::byte_io_multiplexer::_unsynchronised_io_operation_state::_unsynchronised_io_operation_state ( byte_io_handle *  _h, io_operation_state_visitor *  _v, registered_buffer_type &&  b, deadline  d, io_request< const_buffers_type >  reqs, barrier_kind  kind  )

inline

Construct a barrier operation state.

        : io_operation_state(_h, _v)
        , state(io_operation_state_type::barrier_initialised)
        , payload(std::move(b), d, std::move(reqs), kind)
    {
    }

_unsynchronised_io_operation_state() [5/7]

llfio_v2_xxx::byte_io_multiplexer::_unsynchronised_io_operation_state::_unsynchronised_io_operation_state ( io_result< buffers_type > &&  res )

inlineexplicit

Construct a finished read operation state.

        : state(io_operation_state_type::read_finished)
        , payload(std::move(res))
    {
    }

_unsynchronised_io_operation_state() [6/7]

llfio_v2_xxx::byte_io_multiplexer::_unsynchronised_io_operation_state::_unsynchronised_io_operation_state ( io_result< const_buffers_type > &&  res )

inlineexplicit

Construct a finished write or barrier operation state.

        : state(io_operation_state_type::write_or_barrier_finished)
        , payload(std::move(res))
    {
    }

_unsynchronised_io_operation_state() [7/7]

llfio_v2_xxx::byte_io_multiplexer::_unsynchronised_io_operation_state::_unsynchronised_io_operation_state ( _unsynchronised_io_operation_state &&  o )

inlineprotectednoexcept

        : io_operation_state(std::move(o))
        , state(o.state)
    {
    }

~_unsynchronised_io_operation_state()

virtual llfio_v2_xxx::byte_io_multiplexer::_unsynchronised_io_operation_state::~_unsynchronised_io_operation_state ( )

inlinevirtual

{ clear_storage(); }

Member Function Documentation

_barrier_completed()

void llfio_v2_xxx::byte_io_multiplexer::_unsynchronised_io_operation_state::_barrier_completed ( lock_guard &  g, io_result< const_buffers_type > &&  res  )

inline

    {
      if(state == io_operation_state_type::barrier_initialised || state == io_operation_state_type::barrier_initiated)
      {
        clear_storage();
        new(&payload.completed_write_or_barrier) io_result<const_buffers_type>(std::move(res));
        auto old = state;
        state = io_operation_state_type::write_or_barrier_completed;
        if(this->visitor != nullptr)
        {
          this->visitor->barrier_completed(g, old, std::move(payload.completed_write_or_barrier));
        }
      }
    }

_barrier_initiated()

void llfio_v2_xxx::byte_io_multiplexer::_unsynchronised_io_operation_state::_barrier_initiated ( lock_guard &  g )

inline

    {
      if(state == io_operation_state_type::barrier_initialised)
      {
        state = io_operation_state_type::barrier_initiated;
        if(this->visitor != nullptr)
        {
          this->visitor->barrier_initiated(g, io_operation_state_type::barrier_initialised);
        }
      }
    }

_lock()

virtual void llfio_v2_xxx::byte_io_multiplexer::io_operation_state::_lock ( )

inlineprotectedvirtualnoexceptinherited

{}

_read_completed()

void llfio_v2_xxx::byte_io_multiplexer::_unsynchronised_io_operation_state::_read_completed ( lock_guard &  g, io_result< buffers_type > &&  res  )

inline

    {
      if(state == io_operation_state_type::read_initialised || state == io_operation_state_type::read_initiated)
      {
        clear_storage();
        new(&payload.completed_read) io_result<buffers_type>(std::move(res));
        auto old = state;
        state = io_operation_state_type::read_completed;
        if(this->visitor != nullptr)
        {
          this->visitor->read_completed(g, old, std::move(payload.completed_read));
        }
      }
    }

_read_finished()

void llfio_v2_xxx::byte_io_multiplexer::_unsynchronised_io_operation_state::_read_finished ( lock_guard &  g )

inline

    {
      if(state == io_operation_state_type::read_completed)
      {
        state = io_operation_state_type::read_finished;
        if(this->visitor != nullptr)
        {
          this->visitor->read_finished(g, io_operation_state_type::read_completed);
        }
      }
    }

_read_initiated()

void llfio_v2_xxx::byte_io_multiplexer::_unsynchronised_io_operation_state::_read_initiated ( lock_guard &  g )

inline

    {
      if(state == io_operation_state_type::read_initialised)
      {
        state = io_operation_state_type::read_initiated;
        if(this->visitor != nullptr)
        {
          this->visitor->read_initiated(g, io_operation_state_type::read_initialised);
        }
      }
    }

_unlock()

virtual void llfio_v2_xxx::byte_io_multiplexer::io_operation_state::_unlock ( )

inlineprotectedvirtualnoexceptinherited

{}

_write_completed()

void llfio_v2_xxx::byte_io_multiplexer::_unsynchronised_io_operation_state::_write_completed ( lock_guard &  g, io_result< const_buffers_type > &&  res  )

inline

    {
      if(state == io_operation_state_type::write_initialised || state == io_operation_state_type::write_initiated)
      {
        clear_storage();
        new(&payload.completed_write_or_barrier) io_result<const_buffers_type>(std::move(res));
        auto old = state;
        state = io_operation_state_type::write_or_barrier_completed;
        if(this->visitor != nullptr)
        {
          this->visitor->write_completed(g, old, std::move(payload.completed_write_or_barrier));
        }
      }
    }

_write_initiated()

void llfio_v2_xxx::byte_io_multiplexer::_unsynchronised_io_operation_state::_write_initiated ( lock_guard &  g )

inline

    {
      if(state == io_operation_state_type::write_initialised)
      {
        state = io_operation_state_type::write_initiated;
        if(this->visitor != nullptr)
        {
          this->visitor->write_initiated(g, io_operation_state_type::write_initialised);
        }
      }
    }

_write_or_barrier_finished()

void llfio_v2_xxx::byte_io_multiplexer::_unsynchronised_io_operation_state::_write_or_barrier_finished ( lock_guard &  g )

inline

    {
      if(state == io_operation_state_type::write_or_barrier_completed)
      {
        state = io_operation_state_type::write_or_barrier_finished;
        if(this->visitor != nullptr)
        {
          this->visitor->write_or_barrier_finished(g, io_operation_state_type::write_or_barrier_completed);
        }
      }
    }

barrier_completed()

virtual void llfio_v2_xxx::byte_io_multiplexer::_unsynchronised_io_operation_state::barrier_completed ( io_result< const_buffers_type > &&  res )

inlinevirtual

    {
      lock_guard g(this, false);
      _barrier_completed(g, std::move(res));
    }

barrier_initiated()

virtual void llfio_v2_xxx::byte_io_multiplexer::_unsynchronised_io_operation_state::barrier_initiated ( )

inlinevirtual

    {
      lock_guard g(this, false);
      _barrier_initiated(g);
    }

clear_storage()

void llfio_v2_xxx::byte_io_multiplexer::_unsynchronised_io_operation_state::clear_storage ( )

inline

Used to clear the storage in this operation state.

    {
      switch(state)
      {
      case io_operation_state_type::unknown:
        break;
      case io_operation_state_type::read_initialised:
      case io_operation_state_type::read_initiated:
        payload.noncompleted.base.~registered_buffer_type();
        payload.noncompleted.d.~deadline();
        payload.noncompleted.params.read.~read_params_t();
        break;
      case io_operation_state_type::read_completed:
      case io_operation_state_type::read_finished:
        payload.completed_read.~io_result<buffers_type>();
        break;
      case io_operation_state_type::write_initialised:
      case io_operation_state_type::write_initiated:
        payload.noncompleted.base.~registered_buffer_type();
        payload.noncompleted.d.~deadline();
        payload.noncompleted.params.write.~write_params_t();
        break;
      case io_operation_state_type::barrier_initialised:
      case io_operation_state_type::barrier_initiated:
        payload.noncompleted.base.~registered_buffer_type();
        payload.noncompleted.d.~deadline();
        payload.noncompleted.params.barrier.~barrier_params_t();
        break;
      case io_operation_state_type::write_or_barrier_completed:
      case io_operation_state_type::write_or_barrier_finished:
        payload.completed_write_or_barrier.~io_result<const_buffers_type>();
        break;
      }
      state = io_operation_state_type::unknown;
    }

current_state()

virtual io_operation_state_type llfio_v2_xxx::byte_io_multiplexer::_unsynchronised_io_operation_state::current_state ( ) const

inlineoverridevirtualnoexcept

Used to retrieve the current state of the i/o operation.

Implements llfio_v2_xxx::byte_io_multiplexer::io_operation_state.

Reimplemented in llfio_v2_xxx::byte_io_multiplexer::_synchronised_io_operation_state.

{ return state; }

get_completed_read()

virtual io_result< buffers_type > llfio_v2_xxx::byte_io_multiplexer::_unsynchronised_io_operation_state::get_completed_read ( ) &&

inlineoverridevirtualnoexcept

After an i/o operation has finished, can be used to retrieve the result if the visitor did not.

Implements llfio_v2_xxx::byte_io_multiplexer::io_operation_state.

Reimplemented in llfio_v2_xxx::byte_io_multiplexer::_synchronised_io_operation_state.

    {
      assert(state == io_operation_state_type::read_completed || state == io_operation_state_type::read_finished);
      io_result<buffers_type> ret(std::move(payload.completed_read));
      clear_storage();
      return ret;
    }

get_completed_write_or_barrier()

virtual io_result< const_buffers_type > llfio_v2_xxx::byte_io_multiplexer::_unsynchronised_io_operation_state::get_completed_write_or_barrier ( ) &&

inlineoverridevirtualnoexcept

After an i/o operation has finished, can be used to retrieve the result if the visitor did not.

Implements llfio_v2_xxx::byte_io_multiplexer::io_operation_state.

Reimplemented in llfio_v2_xxx::byte_io_multiplexer::_synchronised_io_operation_state.

    {
      assert(state == io_operation_state_type::write_or_barrier_completed || state == io_operation_state_type::write_or_barrier_finished);
      io_result<const_buffers_type> ret(std::move(payload.completed_write_or_barrier));
      clear_storage();
      return ret;
    }

invoke()

virtual void * llfio_v2_xxx::byte_io_multiplexer::_unsynchronised_io_operation_state::invoke ( function_ptr< void *(io_operation_state_type)>  c ) const

inlineoverridevirtualnoexcept

Invoke the callable with the per-i/o state lock held, if any.

Implements llfio_v2_xxx::byte_io_multiplexer::io_operation_state.

Reimplemented in llfio_v2_xxx::byte_io_multiplexer::_synchronised_io_operation_state.

{ return c(state); }

read_completed()

virtual void llfio_v2_xxx::byte_io_multiplexer::_unsynchronised_io_operation_state::read_completed ( io_result< buffers_type > &&  res )

inlinevirtual

    {
      lock_guard g(this, false);
      _read_completed(g, std::move(res));
    }

read_finished()

virtual void llfio_v2_xxx::byte_io_multiplexer::_unsynchronised_io_operation_state::read_finished ( )

inlinevirtual

    {
      lock_guard g(this, false);
      _read_finished(g);
    }

read_initiated()

virtual void llfio_v2_xxx::byte_io_multiplexer::_unsynchronised_io_operation_state::read_initiated ( )

inlinevirtual

    {
      lock_guard g(this, false);
      _read_initiated(g);
    }

relocate_to()

virtual io_operation_state * llfio_v2_xxx::byte_io_multiplexer::_unsynchronised_io_operation_state::relocate_to ( byte *  to )

inlineoverridevirtualnoexcept

Relocate the state to new storage, clearing the original state. Terminates the process if the state is in use.

Implements llfio_v2_xxx::byte_io_multiplexer::io_operation_state.

    {
      auto *to = new(to_) _unsynchronised_io_operation_state(std::move(*this));
      switch(state)
      {
      case io_operation_state_type::unknown:
        break;
      case io_operation_state_type::read_initialised:
      case io_operation_state_type::read_initiated:
        new(&to->payload) _unsynchronised_io_operation_state::payload_t(std::move(payload.noncompleted.base), payload.noncompleted.d,
                                                                        std::move(payload.noncompleted.params.read.reqs));
        break;
      case io_operation_state_type::read_completed:
      case io_operation_state_type::read_finished:
        new(&to->payload.completed_read) io_result<buffers_type>(std::move(payload.completed_read));
        break;
      case io_operation_state_type::write_initialised:
      case io_operation_state_type::write_initiated:
        new(&to->payload) _unsynchronised_io_operation_state::payload_t(std::move(payload.noncompleted.base), payload.noncompleted.d,
                                                                        std::move(payload.noncompleted.params.write.reqs));
        break;
      case io_operation_state_type::barrier_initialised:
      case io_operation_state_type::barrier_initiated:
        new(&to->payload)
        _unsynchronised_io_operation_state::payload_t(std::move(payload.noncompleted.base), payload.noncompleted.d,
                                                      std::move(payload.noncompleted.params.barrier.reqs), payload.noncompleted.params.barrier.kind);
        break;
      case io_operation_state_type::write_or_barrier_completed:
      case io_operation_state_type::write_or_barrier_finished:
        new(&to->payload.completed_write_or_barrier) io_result<const_buffers_type>(std::move(payload.completed_write_or_barrier));
        break;
      }
      clear_storage();
      return to;
    }

write_completed()

virtual void llfio_v2_xxx::byte_io_multiplexer::_unsynchronised_io_operation_state::write_completed ( io_result< const_buffers_type > &&  res )

inlinevirtual

    {
      lock_guard g(this, false);
      _write_completed(g, std::move(res));
    }

write_initiated()

virtual void llfio_v2_xxx::byte_io_multiplexer::_unsynchronised_io_operation_state::write_initiated ( )

inlinevirtual

    {
      lock_guard g(this, false);
      _write_initiated(g);
    }

write_or_barrier_finished()

virtual void llfio_v2_xxx::byte_io_multiplexer::_unsynchronised_io_operation_state::write_or_barrier_finished ( )

inlinevirtual

    {
      lock_guard g(this, false);
      _write_or_barrier_finished(g);
    }

Member Data Documentation

h

byte_io_handle* llfio_v2_xxx::byte_io_multiplexer::io_operation_state::h {nullptr}

inherited

The i/o handle the i/o operation is upon.

{nullptr};

state

io_operation_state_type llfio_v2_xxx::byte_io_multiplexer::_unsynchronised_io_operation_state::state {io_operation_state_type::unknown}

The current lifecycle state of this i/o operation.

{io_operation_state_type::unknown};

visitor

io_operation_state_visitor* llfio_v2_xxx::byte_io_multiplexer::io_operation_state::visitor {nullptr}

inherited

The state visitor supplied when the operation was initialised.

{nullptr};

---

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

• include/llfio/v2.0/byte_io_multiplexer.hpp