ACE: ACE_WIN32_Asynch_Result class Reference

00121   : ACE_Asynch_Result_Impl (),
00122     OVERLAPPED (),
00123     handler_proxy_ (handler_proxy),
00124     act_ (act),
00125     bytes_transferred_ (0),
00126     success_ (0),
00127     completion_key_ (0),
00128     error_ (0)
00129 {
00130   // Set the ACE_OVERLAPPED structure
00131   this->Internal = 0;
00132   this->InternalHigh = 0;
00133   this->Offset = offset;
00134   this->OffsetHigh = offset_high;
00135   this->hEvent = event;
00136 
00137   ACE_UNUSED_ARG (priority);
00138   ACE_UNUSED_ARG (signal_number);
00139 }

00030 {
00031   return this->act_;
00032 }

00024 {
00025   return this->bytes_transferred_;
00026 }

00042 {
00043   return this->completion_key_;
00044 }

00048 {
00049   return this->error_;
00050 }

00054 {
00055   return this->hEvent;
00056 }

00060 {
00061   return this->Offset;
00062 }

00066 {
00067   return this->OffsetHigh;
00068 }

00084 {
00085   // Get to the platform specific implementation.
00086   ACE_WIN32_Proactor *win32_proactor = dynamic_cast<ACE_WIN32_Proactor *> (proactor);
00087 
00088   if (win32_proactor == 0)
00089     ACE_ERROR_RETURN ((LM_ERROR,
00090                        ACE_LIB_TEXT ("Dynamic cast to WIN32 Proactor failed\n")),
00091                       -1);
00092 
00093   // Post myself.
00094   return win32_proactor->post_completion (this);
00095 }

00072 {
00073   ACE_NOTSUP_RETURN (0);
00074 }

00099 {
00100   this->bytes_transferred_ = nbytes;
00101 }

00105 {
00106   this->error_ = errcode;
00107 }

00078 {
00079   ACE_NOTSUP_RETURN (0);
00080 }

00036 {
00037   return this->success_;
00038 }


Public Member Functions
size_t	bytes_transferred (void) const
	Number of bytes transferred by the operation.
const void *	act (void) const
	ACT associated with the operation.
int	success (void) const
	Did the operation succeed?
const void *	completion_key (void) const
u_long	error (void) const
	Error value if the operation fail.
ACE_HANDLE	event (void) const
	Event associated with the OVERLAPPED structure.
u_long	offset (void) const
	This really make sense only when doing file I/O.
u_long	offset_high (void) const
	Offset_high associated with the OVERLAPPED structure.
int	priority (void) const
int	signal_number (void) const
	Returns 0.
int	post_completion (ACE_Proactor_Impl *proactor)
	Post to the Proactor's completion port.
virtual	~ACE_WIN32_Asynch_Result (void)
	Destructor.
void	set_error (u_long errcode)
	Simulate error value to use in the post_completion ().
void	set_bytes_transferred (size_t nbytes)
	Simulate value to use in the post_completion ().
Protected Member Functions
	ACE_WIN32_Asynch_Result (const ACE_Handler::Proxy_Ptr &handler_proxy, const void *act, ACE_HANDLE event, u_long offset, u_long offset_high, int priority, int signal_number=0)
	Constructor.
Protected Attributes
ACE_Handler::Proxy_Ptr	handler_proxy_
	Proxy for the ACE_Handler that will be called back.
const void *	act_
	ACT for this operation.
size_t	bytes_transferred_
	Bytes transferred by this operation.
int	success_
	Success indicator.
const void *	completion_key_
	ACT associated with handle.
u_long	error_
	Error if operation failed.
Friends
class	ACE_WIN32_Asynch_Accept
	Factory class has special permissions.
class	ACE_WIN32_Proactor
	Proactor class has special permission.

ACE_WIN32_Asynch_Result Class Reference

Public Member Functions

Protected Member Functions

Protected Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation