folly::AsyncIOOp Class Reference

#include <AsyncIO.h>

Inheritance diagram for folly::AsyncIOOp:

Public Types
enum	State {   State::UNINITIALIZED, State::INITIALIZED, State::PENDING, State::COMPLETED,   State::CANCELED }
typedef std::function< void(AsyncIOOp *)>	NotificationCallback

Public Member Functions
	AsyncIOOp (NotificationCallback cb=NotificationCallback())
	~AsyncIOOp ()
void	pread (int fd, void *buf, size_t size, off_t start)
void	pread (int fd, Range< unsigned char * > range, off_t start)
void	preadv (int fd, const iovec *iov, int iovcnt, off_t start)
void	pwrite (int fd, const void *buf, size_t size, off_t start)
void	pwrite (int fd, Range< const unsigned char * > range, off_t start)
void	pwritev (int fd, const iovec *iov, int iovcnt, off_t start)
State	state () const
void	reset (NotificationCallback cb=NotificationCallback())
void	setNotificationCallback (NotificationCallback cb)
const NotificationCallback &	notificationCallback () const
ssize_t	result () const

Private Member Functions
void	init ()
void	start ()
void	complete (ssize_t result)
void	cancel ()

Private Attributes
NotificationCallback	cb_
iocb	iocb_
State	state_
ssize_t	result_

Friends
class	AsyncIO
std::ostream &	operator<< (std::ostream &stream, const AsyncIOOp &o)

Detailed Description

An AsyncIOOp represents a pending operation. You may set a notification callback or you may use this class's methods directly.

The op must remain allocated until it is completed or canceled.

Definition at line 45 of file AsyncIO.h.

Member Typedef Documentation

typedef std::function<void(AsyncIOOp*)> folly::AsyncIOOp::NotificationCallback

Definition at line 50 of file AsyncIO.h.

Member Enumeration Documentation

enum folly::AsyncIOOp::State

strong

Enumerator
UNINITIALIZED
INITIALIZED
PENDING
COMPLETED
CANCELED

Definition at line 55 of file AsyncIO.h.

                   {
    UNINITIALIZED,
    INITIALIZED,
    PENDING,
    COMPLETED,
    CANCELED,
  };

Constructor & Destructor Documentation

folly::AsyncIOOp::AsyncIOOp ( NotificationCallback  cb = NotificationCallback() )

explicit

Definition at line 36 of file AsyncIO.cpp.

References iocb_, and folly::UNINITIALIZED.

    : cb_(std::move(cb)), state_(State::UNINITIALIZED), result_(-EINVAL) {
  memset(&iocb_, 0, sizeof(iocb_));
}

folly::AsyncIOOp::~AsyncIOOp

(

)

Definition at line 49 of file AsyncIO.cpp.

References PENDING, and state_.

                      {
  CHECK_NE(state_, State::PENDING);
}

Member Function Documentation

void folly::AsyncIOOp::cancel ( )

private

Definition at line 67 of file AsyncIO.cpp.

References CANCELED, PENDING, and state_.

Referenced by folly::AsyncIO::doWait(), and notificationCallback().

                       {
  DCHECK_EQ(state_, State::PENDING);
  state_ = State::CANCELED;
}

void folly::AsyncIOOp::complete ( ssize_t  result )

private

Definition at line 58 of file AsyncIO.cpp.

References cb_, COMPLETED, PENDING, result(), result_, and state_.

Referenced by folly::AsyncIO::doWait(), and notificationCallback().

                                       {
  DCHECK_EQ(state_, State::PENDING);
  state_ = State::COMPLETED;
  result_ = result;
  if (cb_) {
    cb_(this);
  }
}

void folly::AsyncIOOp::init ( )

private

Definition at line 105 of file AsyncIO.cpp.

References INITIALIZED, state_, and UNINITIALIZED.

Referenced by notificationCallback(), pread(), preadv(), pwrite(), and pwritev().

                     {
  CHECK_EQ(state_, State::UNINITIALIZED);
  state_ = State::INITIALIZED;
}

const NotificationCallback& folly::AsyncIOOp::notificationCallback ( ) const

inline

Definition at line 93 of file AsyncIO.h.

References cancel(), cb_, complete(), init(), result(), and start().

                                                           {
    return cb_;
  }

void folly::AsyncIOOp::pread	(	int	fd,
		void *	buf,
		size_t	size,
		off_t	start
	)

Initiate a read request.

Definition at line 77 of file AsyncIO.cpp.

References init(), and iocb_.

Referenced by pread().

                                                                 {
  init();
  io_prep_pread(&iocb_, fd, buf, size, start);
}

void folly::AsyncIOOp::pread	(	int	fd,
		Range< unsigned char * >	range,
		off_t	start
	)

Definition at line 82 of file AsyncIO.cpp.

References folly::Range< Iter >::begin(), pread(), folly::Range< Iter >::size(), and start().

                                                                      {
  pread(fd, range.begin(), range.size(), start);
}

void folly::AsyncIOOp::preadv	(	int	fd,
		const iovec *	iov,
		int	iovcnt,
		off_t	start
	)

Definition at line 86 of file AsyncIO.cpp.

References init(), and iocb_.

                                                                        {
  init();
  io_prep_preadv(&iocb_, fd, iov, iovcnt, start);
}

void folly::AsyncIOOp::pwrite	(	int	fd,
		const void *	buf,
		size_t	size,
		off_t	start
	)

Initiate a write request.

Definition at line 91 of file AsyncIO.cpp.

References init(), and iocb_.

Referenced by pwrite().

                                                                        {
  init();
  io_prep_pwrite(&iocb_, fd, const_cast<void*>(buf), size, start);
}

void folly::AsyncIOOp::pwrite	(	int	fd,
		Range< const unsigned char * >	range,
		off_t	start
	)

Definition at line 96 of file AsyncIO.cpp.

References folly::Range< Iter >::begin(), pwrite(), folly::Range< Iter >::size(), and start().

                                                                             {
  pwrite(fd, range.begin(), range.size(), start);
}

void folly::AsyncIOOp::pwritev	(	int	fd,
		const iovec *	iov,
		int	iovcnt,
		off_t	start
	)

Definition at line 100 of file AsyncIO.cpp.

References init(), and iocb_.

                                                                         {
  init();
  io_prep_pwritev(&iocb_, fd, iov, iovcnt, start);
}

void folly::AsyncIOOp::reset

(

NotificationCallback

cb = NotificationCallback()

)

Reset the operation for reuse. It is an error to call reset() on an Op that is still pending.

Definition at line 41 of file AsyncIO.cpp.

References cb_, iocb_, folly::gen::move, PENDING, result_, state_, and UNINITIALIZED.

Referenced by state().

                                             {
  CHECK_NE(state_, State::PENDING);
  cb_ = std::move(cb);
  state_ = State::UNINITIALIZED;
  result_ = -EINVAL;
  memset(&iocb_, 0, sizeof(iocb_));
}

ssize_t folly::AsyncIOOp::result

(

)

const

Retrieve the result of this operation. Returns >=0 on success, -errno on failure (that is, using the Linux kernel error reporting conventions). Use checkKernelError (folly/Exception.h) on the result to throw a std::system_error in case of error instead.

It is an error to call this if the Op hasn't completed.

Definition at line 72 of file AsyncIO.cpp.

References COMPLETED, result_, and state_.

Referenced by complete(), and notificationCallback().

                                {
  CHECK_EQ(state_, State::COMPLETED);
  return result_;
}

void folly::AsyncIOOp::setNotificationCallback ( NotificationCallback  cb )

inline

Definition at line 90 of file AsyncIO.h.

References cb_, and folly::gen::move.

                                                        {
    cb_ = std::move(cb);
  }

void folly::AsyncIOOp::start ( )

private

Definition at line 53 of file AsyncIO.cpp.

References INITIALIZED, PENDING, and state_.

Referenced by notificationCallback(), pread(), pwrite(), and folly::AsyncIO::submit().

                      {
  DCHECK_EQ(state_, State::INITIALIZED);
  state_ = State::PENDING;
}

State folly::AsyncIOOp::state ( ) const

inline

Return the current operation state.

Definition at line 80 of file AsyncIO.h.

References reset(), and state_.

Referenced by folly::AsyncIO::submit().

                      {
    return state_;
  }

Friends And Related Function Documentation

friend class AsyncIO

friend

Definition at line 46 of file AsyncIO.h.

std::ostream& operator<< ( std::ostream &  stream, const AsyncIOOp &  o  )

friend

Definition at line 388 of file AsyncIO.cpp.

                                                            {
  os << "{" << op.state_ << ", ";

  if (op.state_ != AsyncIOOp::State::UNINITIALIZED) {
    os << op.iocb_;
  }

  if (op.state_ == AsyncIOOp::State::COMPLETED) {
    os << "result=" << op.result_;
    if (op.result_ < 0) {
      os << " (" << errnoStr(-op.result_) << ')';
    }
    os << ", ";
  }

  return os << "}";
}

Member Data Documentation

NotificationCallback folly::AsyncIOOp::cb_

private

Definition at line 113 of file AsyncIO.h.

Referenced by complete(), notificationCallback(), reset(), and setNotificationCallback().

iocb folly::AsyncIOOp::iocb_

private

Definition at line 114 of file AsyncIO.h.

Referenced by AsyncIOOp(), folly::AsyncIO::doWait(), folly::operator<<(), pread(), preadv(), pwrite(), pwritev(), reset(), and folly::AsyncIO::submit().

ssize_t folly::AsyncIOOp::result_

private

Definition at line 116 of file AsyncIO.h.

Referenced by complete(), folly::operator<<(), reset(), and result().

State folly::AsyncIOOp::state_

private

Definition at line 115 of file AsyncIO.h.

Referenced by cancel(), complete(), init(), folly::operator<<(), reset(), result(), start(), state(), and ~AsyncIOOp().

---

The documentation for this class was generated from the following files:

• proxygen/folly/folly/experimental/io/AsyncIO.h
• proxygen/folly/folly/experimental/io/AsyncIO.cpp