Main Page Class Hierarchy Alphabetical List Compound List File List Compound Members File Members Related Pages

# ACE_Task Class Template Reference

Primary interface for application message processing, as well as input and output message queueing. More...

`#include <Task_T.h>`

Inheritance diagram for ACE_Task:

[legend]
Collaboration diagram for ACE_Task:

[legend]
List of all members.

## Public Methods
| ACE_Task (ACE_Thread_Manager *thr_mgr=0, ACE_Message_Queue< ACE_SYNCH_USE > *mq=0)
virtual | ~ACE_Task (void)
| Destructor. More...
ACE_Message_Queue< ACE_SYNCH_USE > * | msg_queue (void)
| Gets the message queue associated with this task. More...
void | msg_queue (ACE_Message_Queue< ACE_SYNCH_USE > *)
| Sets the message queue associated with this task. More...
int | putq (ACE_Message_Block *, ACE_Time_Value *timeout=0)
| Insert message into the message queue. Note that <timeout> uses <{absolute}> time rather than <{relative}> time. More...
int | getq (ACE_Message_Block *&mb, ACE_Time_Value *timeout=0)
int | ungetq (ACE_Message_Block *, ACE_Time_Value *timeout=0)
| Return a message to the queue. Note that <timeout> uses <{absolute}> time rather than <{relative}> time. More...
int | reply (ACE_Message_Block *, ACE_Time_Value *timeout=0)
int | put_next (ACE_Message_Block *msg, ACE_Time_Value *timeout=0)
int | can_put (ACE_Message_Block *)
| Tests whether we can enqueue a message without blocking. More...
const ACE_TCHAR * | name (void) const
| Return the name of the enclosing Module if there's one associated with the Task, else returns 0. More...
ACE_Task< ACE_SYNCH_USE > * | next (void)
| Get next Task pointer. More...
void | next (ACE_Task< ACE_SYNCH_USE > *)
| Set next Task pointer. More...
ACE_Task< ACE_SYNCH_USE > * | sibling (void)
| Return the Task's sibling if there's one associated with the Task's Module, else returns 0. More...
int | flush (u_long flag=ACE_Task_Flags::ACE_FLUSHALL)
void | water_marks (ACE_IO_Cntl_Msg::ACE_IO_Cntl_Cmds, size_t)
| Manipulate watermarks. More...
void | dump (void) const
| Dump the state of an object. More...
## Public Attributes
module void | const
| Return the Task's Module if there is one, else returns 0. More...
ACE_Message_Queue< ACE_SYNCH_USE > * | msg_queue_
| Queue of messages on the ACE_Task.. More...
int | delete_msg_queue_
| 1 if should delete Message_Queue, 0 otherwise. More...
ACE_Module< ACE_SYNCH_USE > * | mod_
| Back-pointer to the enclosing module. More...
ACE_Task< ACE_SYNCH_USE > * | next_
| Pointer to adjacent ACE_Task. More...
| ACE_ALLOC_HOOK_DECLARE
| Declare the dynamic allocation hooks. More...
## Private Methods
void | operator= (const ACE_Task< _ACE_SYNCH > &)
| ACE_Task (const ACE_Task< _ACE_SYNCH > &)
## Friends
class | ACE_Module< ACE_SYNCH_USE >
class | ACE_Module_Type

## Detailed Description

### template<ACE_SYNCH_DECL>
class ACE_Task<>

Primary interface for application message processing, as well as input and output message queueing.

This class serves as the basis for passive and active objects in ACE.

## Constructor & Destructor Documentation

template<ACE_SYNCH_DECL >
ACE_Task<>::ACE_Task | ( | ACE_Thread_Manager * | thr_mgr = 0,
|  | ACE_Message_Queue< ACE_SYNCH_USE > * | mq = 0
| ) |

| Initialize a Task, supplying a thread manager and a message queue. If the user doesn't supply a ACE_Message_Queue pointer then we'll allocate one dynamically. Otherwise, we'll use the one passed as a parameter.

template<ACE_SYNCH_DECL >
virtual ACE_Task<>::~ACE_Task | ( | void |  | ) | `[virtual]`

| Destructor.

template<ACE_SYNCH_DECL >
ACE_Task<>::ACE_Task | ( | const ACE_Task< _ACE_SYNCH > & |  | ) | `[private]`

## Member Function Documentation

template<ACE_SYNCH_DECL >
int ACE_Task<>::can_put | ( | ACE_Message_Block * |  | ) |

| Tests whether we can enqueue a message without blocking.

template<ACE_SYNCH_DECL >
void ACE_Task<>::dump | ( | void |  | ) | const

| Dump the state of an object. Reimplemented in ACE_Stream_Head, ACE_Stream_Tail, ACE_Thru_Task, ACE_Svc_Handler, ACE_Buffered_Svc_Handler, and ACE_Svc_Handler< ACE_PEER_STREAM_2, ACE_SYNCH_USE >.

template<ACE_SYNCH_DECL >
int ACE_Task<>::flush | ( | u_long | flag = ACE_Task_Flags::ACE_FLUSHALL | ) |

| Flush the task's queue, i.e., free all of the enqueued message blocks and releases any threads blocked on the queue. Note that if this conflicts with the C++ iostream <flush> function, just rewrite the iostream function as ::<flush>.

template<ACE_SYNCH_DECL >
int ACE_Task<>::getq | ( | ACE_Message_Block *& | mb,
|  | ACE_Time_Value * | timeout = 0
| ) |

| Extract the first message from the queue (blocking). Note that <timeout> uses <{absolute}> time rather than <{relative}> time. Returns number of items in queue if the call succeeds or -1 otherwise.

template<ACE_SYNCH_DECL >
void ACE_Task<>::msg_queue | ( | ACE_Message_Queue< ACE_SYNCH_USE > * |  | ) |

| Sets the message queue associated with this task.

template<ACE_SYNCH_DECL >
ACE_Message_Queue<ACE_SYNCH_USE>* ACE_Task<>::msg_queue | ( | void |  | ) |

| Gets the message queue associated with this task.

template<ACE_SYNCH_DECL >
const ACE_TCHAR* ACE_Task<>::name | ( | void |  | ) | const

| Return the name of the enclosing Module if there's one associated with the Task, else returns 0. Reimplemented in ACE_NT_Service.

template<ACE_SYNCH_DECL >
void ACE_Task<>::next | ( | ACE_Task< ACE_SYNCH_USE > * |  | ) |

| Set next Task pointer.

template<ACE_SYNCH_DECL >
ACE_Task<ACE_SYNCH_USE>* ACE_Task<>::next | ( | void |  | ) |

| Get next Task pointer.

template<ACE_SYNCH_DECL >
void ACE_Task<>::operator= | ( | const ACE_Task< _ACE_SYNCH > & |  | ) | `[private]`

template<ACE_SYNCH_DECL >
int ACE_Task<>::put_next | ( | ACE_Message_Block * | msg,
|  | ACE_Time_Value * | timeout = 0
| ) |

| Transfer message to the adjacent ACE_Task in a ACE_Stream. Note that <timeout> uses <{absolute}> time rather than <{relative}> time.

template<ACE_SYNCH_DECL >
int ACE_Task<>::putq | ( | ACE_Message_Block * | ,
|  | ACE_Time_Value * | timeout = 0
| ) |

| Insert message into the message queue. Note that <timeout> uses <{absolute}> time rather than <{relative}> time.

template<ACE_SYNCH_DECL >
int ACE_Task<>::reply | ( | ACE_Message_Block * | ,
|  | ACE_Time_Value * | timeout = 0
| ) |

| Turn the message around and send it back down the Stream. Note that <timeout> uses <{absolute}> time rather than <{relative}> time.

template<ACE_SYNCH_DECL >
ACE_Task<ACE_SYNCH_USE>* ACE_Task<>::sibling | ( | void |  | ) |

| Return the Task's sibling if there's one associated with the Task's Module, else returns 0.

template<ACE_SYNCH_DECL >
int ACE_Task<>::ungetq | ( | ACE_Message_Block * | ,
|  | ACE_Time_Value * | timeout = 0
| ) |

| Return a message to the queue. Note that <timeout> uses <{absolute}> time rather than <{relative}> time.

template<ACE_SYNCH_DECL >
void ACE_Task<>::water_marks | ( | ACE_IO_Cntl_Msg::ACE_IO_Cntl_Cmds | ,
|  | size_t |
| ) |

| Manipulate watermarks.

## Friends And Related Function Documentation

template<ACE_SYNCH_DECL >
friend class ACE_Module< ACE_SYNCH_USE >`[friend]`

template<ACE_SYNCH_DECL >
friend class ACE_Module_Type`[friend]`

## Member Data Documentation

template<ACE_SYNCH_DECL >
ACE_Task::ACE_ALLOC_HOOK_DECLARE

| Declare the dynamic allocation hooks. Reimplemented in ACE_NT_Service, ACE_Stream_Head, ACE_Stream_Tail, and ACE_Thru_Task.

template<ACE_SYNCH_DECL >
module void ACE_Task::const

| Return the Task's Module if there is one, else returns 0.

template<ACE_SYNCH_DECL >
int ACE_Task::delete_msg_queue_

| 1 if should delete Message_Queue, 0 otherwise.

template<ACE_SYNCH_DECL >
ACE_Module<ACE_SYNCH_USE>* ACE_Task::mod_

| Back-pointer to the enclosing module.

template<ACE_SYNCH_DECL >
ACE_Message_Queue<ACE_SYNCH_USE>* ACE_Task::msg_queue_

| Queue of messages on the ACE_Task..

template<ACE_SYNCH_DECL >
ACE_Task<ACE_SYNCH_USE>* ACE_Task::next_

| Pointer to adjacent ACE_Task.

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

- Task_T.h