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

# TAO_GIOP_Message_Lite Class Reference

Definitions of GIOPLite specific stuff. More...

`#include <GIOP_Message_Lite.h>`

Inheritance diagram for TAO_GIOP_Message_Lite

[legend]
Collaboration diagram for TAO_GIOP_Message_Lite:

[legend]
List of all members.

## Public Methods
| TAO_GIOP_Message_Lite (TAO_ORB_Core *orb_core, size_t input_cdr_size = ACE_CDR::DEFAULT_BUFSIZE)
| Constructor.
virtual | ~TAO_GIOP_Message_Lite (void)
| Dtor.
virtual void | init (CORBA::Octet, CORBA::Octet)
| Initialize the object -- this is a dummy for GIOPlite.
virtual void | reset (void)
| Reset the messaging the object.
virtual int | generate_request_header (TAO_Operation_Details &op, TAO_Target_Specification &spec, TAO_OutputCDR &cdr)
| Write the RequestHeader in to the <cdr> stream. The underlying implementation of the mesaging should do the right thing.
virtual int | generate_locate_request_header ( TAO_Operation_Details &op, TAO_Target_Specification &spec, TAO_OutputCDR &cdr)
| Write the RequestHeader in to the <cdr> stream.
virtual int | generate_reply_header ( TAO_OutputCDR &cdr, TAO_Pluggable_Reply_Params_Base &params )
| Write the reply header.
virtual int | read_message (TAO_Transport *transport, int block = 0, ACE_Time_Value *max_wait_time = 0)
| Dummy method to ..
virtual int | format_message (TAO_OutputCDR &cdr)
| Format the message. As we have not written the message length in the header, we make use of this oppurtunity to insert and format the message.
virtual int | parse_incoming_messages (ACE_Message_Block &message_block)
| Parse the incoming messages..
TAO_Pluggable_Message_Type | message_type (void)
| Get the message type. The return value would be one of the following: TAO_PLUGGABLE_MESSAGE_REQUEST, TAO_PLUGGABLE_MESSAGE_REPLY, TAO_PLUGGABLE_MESSAGE_CLOSECONNECTION, TAO_PLUGGABLE_MESSAGE_MESSAGE_ERROR.
virtual ssize_t | missing_data (ACE_Message_Block &message_block)
| Calculate the amount of data that is missing in the <incoming> message block.
virtual int | extract_next_message (ACE_Message_Block &incoming, TAO_Queued_Data *&qd)
virtual int | consolidate_node (TAO_Queued_Data *qd, ACE_Message_Block &incoming)
| Check whether the node <qd> needs consolidation from <incoming>.
virtual void | get_message_data (TAO_Queued_Data *qd)
| Get the details of the message parsed through the <qd>.
virtual int | consolidate_fragments (TAO_Queued_Data *dqd, const TAO_Queued_Data *sqd)
| Bala: Docu??? More...
virtual int | process_request_message (TAO_Transport *transport, TAO_Queued_Data *qd)
| Process the request message that we have received on the connection.
virtual int | process_reply_message ( TAO_Pluggable_Reply_Params &reply_info, TAO_Queued_Data *qd)
| Parse the reply message that we received and return the reply information though <reply_info>.
virtual int | generate_exception_reply ( TAO_OutputCDR &cdr, TAO_Pluggable_Reply_Params_Base &params, CORBA::Exception &x )
| Generate a reply message with the exception <ex>.
## Private Methods
int | write_protocol_header (TAO_GIOP_Message_Type t, TAO_OutputCDR &msg)
| Writes the GIOP header in to <msg> NOTE: If the GIOP header happens to change in the future, we can push this method in to the generator_parser classes.
int | process_request (TAO_Transport *transport, TAO_InputCDR &input, TAO_OutputCDR &output)
| Processes the <GIOP_REQUEST> messages.
int | process_locate_request (TAO_Transport *transport, TAO_InputCDR &input, TAO_OutputCDR &output)
| Processes the <GIOP_LOCATE_REQUEST> messages.
int | make_send_locate_reply (TAO_Transport *transport, TAO_OutputCDR &output, TAO_GIOP_Locate_Request_Header &request, TAO_GIOP_Locate_Status_Msg &status)
| Make a <GIOP_LOCATEREPLY> and hand that over to the transport so that it can be sent over the connection. NOTE:As on date 1.1 & 1.2 seem to have similar headers. Till an unmanageable difference comes let them be implemented here.
int | send_error (TAO_Transport *transport)
| Send error messages.
void | send_close_connection (const TAO_GIOP_Message_Version &version, TAO_Transport *transport, void *ctx)
| Close a connection, first sending GIOP::CloseConnection.
int | send_reply_exception (TAO_Transport *transport, TAO_ORB_Core* orb_core, CORBA::ULong request_id, IOP::ServiceContextList *svc_info, CORBA::Exception *x)
| We must send a LocateReply through <transport>, this request resulted in some kind of exception.
void | dump_msg (const char *label, const u_char *ptr, size_t len)
| Print out a debug messages..
TAO_Queued_Data* | make_queued_data (size_t sz)
virtual int | generate_locate_reply_header ( TAO_OutputCDR & , TAO_Pluggable_Reply_Params_Base & )
| Write the locate reply header.
virtual int | is_ready_for_bidirectional (void)
| Is the messaging object ready for processing BiDirectional request/response?
int | write_request_header ( const TAO_Operation_Details &opdetails, TAO_Target_Specification &spec, TAO_OutputCDR &msg)
| Write the request header in to <msg>.
int | write_locate_request_header ( CORBA::ULong request_id, TAO_Target_Specification &spec, TAO_OutputCDR &msg)
| Write the LocateRequest header.
int | write_reply_header ( TAO_OutputCDR &output, TAO_Pluggable_Reply_Params_Base &reply, CORBA::Environment &ACE_TRY_ENV = TAO_default_environment ()) throw (CORBA::SystemException)
| Write the reply header in to <output>.
int | write_locate_reply_mesg ( TAO_OutputCDR &output, CORBA::ULong request_id, TAO_GIOP_Locate_Status_Msg &status)
| Writes the locate _reply message in to the <output>.
int | parse_request_header (TAO_ServerRequest &)
| Parse the Request Header from the incoming stream. This will do a version specific parsing of the incoming Request header.
int | parse_locate_header ( TAO_GIOP_Locate_Request_Header &)
| Parse the Loacte Request Header from the incoming stream. This will do a version specific parsing of the incoming Request header.
int | parse_reply (TAO_InputCDR &input, TAO_Pluggable_Reply_Params &params)
| Parse the reply message.
int | parse_locate_reply (TAO_InputCDR &input, TAO_Pluggable_Reply_Params &params)
| Parse the locate reply message from the server.
## Private Attributes
TAO_ORB_Core* | orb_core_
| Our copy of the ORB core...
CORBA::Octet | message_type_
| The message type that we are going to process..
CORBA::ULong | message_size_
| The pay load size.
CORBA::Octet | byte_order_

## Detailed Description

Definitions of GIOPLite specific stuff.

This protocol is a modified version of GIOP. This is more suited for homogenous platforms.

## Constructor & Destructor Documentation

TAO_GIOP_Message_Lite::TAO_GIOP_Message_Lite ( | TAO_ORB_Core * orb_core,
| size_t input_cdr_size = ACE_CDR::DEFAULT_BUFSIZE )

| Constructor.

TAO_GIOP_Message_Lite::~TAO_GIOP_Message_Lite ( | void )`[virtual]`

| Dtor.

## Member Function Documentation

int TAO_GIOP_Message_Lite::consolidate_fragments ( | TAO_Queued_Data * dqd,
| const TAO_Queued_Data * sqd )`[virtual]`

| Bala: Docu??? @ Reimplemented from TAO_Pluggable_Messaging.

int TAO_GIOP_Message_Lite::consolidate_node ( | TAO_Queued_Data * qd,
| ACE_Message_Block & incoming )`[virtual]`

| Check whether the node <qd> needs consolidation from <incoming>. Reimplemented from TAO_Pluggable_Messaging.

void TAO_GIOP_Message_Lite::dump_msg ( | const char * label,
| const u_char * ptr,
| size_t len )`[private]`

| Print out a debug messages..

int TAO_GIOP_Message_Lite::extract_next_message ( | ACE_Message_Block & incoming,
| TAO_Queued_Data *& qd )`[virtual]`

| Reimplemented from TAO_Pluggable_Messaging.

int TAO_GIOP_Message_Lite::format_message ( | TAO_OutputCDR & cdr )`[virtual]`

| Format the message. As we have not written the message length in the header, we make use of this oppurtunity to insert and format the message. Reimplemented from TAO_Pluggable_Messaging.

int TAO_GIOP_Message_Lite::generate_exception_reply ( | TAO_OutputCDR & cdr,
| TAO_Pluggable_Reply_Params_Base & params,
| CORBA::Exception & x )`[virtual]`

| Generate a reply message with the exception <ex>. Reimplemented from TAO_Pluggable_Messaging.

int TAO_GIOP_Message_Lite::generate_locate_reply_header ( | TAO_OutputCDR & cdr,
| TAO_Pluggable_Reply_Params_Base & params )`[private, virtual]`

| Write the locate reply header. Reimplemented from TAO_Pluggable_Messaging.

int TAO_GIOP_Message_Lite::generate_locate_request_header ( | TAO_Operation_Details & op,
| TAO_Target_Specification & spec,
| TAO_OutputCDR & cdr )`[virtual]`

| Write the RequestHeader in to the <cdr> stream. Reimplemented from TAO_Pluggable_Messaging.

int TAO_GIOP_Message_Lite::generate_reply_header ( | TAO_OutputCDR & cdr,
| TAO_Pluggable_Reply_Params_Base & params )`[virtual]`

| Write the reply header. Reimplemented from TAO_Pluggable_Messaging.

int TAO_GIOP_Message_Lite::generate_request_header ( | TAO_Operation_Details & op,
| TAO_Target_Specification & spec,
| TAO_OutputCDR & cdr )`[virtual]`

| Write the RequestHeader in to the <cdr> stream. The underlying implementation of the mesaging should do the right thing. Reimplemented from TAO_Pluggable_Messaging.

void TAO_GIOP_Message_Lite::get_message_data ( | TAO_Queued_Data * qd )`[virtual]`

| Get the details of the message parsed through the <qd>. Reimplemented from TAO_Pluggable_Messaging.

void TAO_GIOP_Message_Lite::init ( | CORBA::Octet major,
| CORBA::Octet minor )`[virtual]`

| Initialize the object -- this is a dummy for GIOPlite. Reimplemented from TAO_Pluggable_Messaging.

int TAO_GIOP_Message_Lite::is_ready_for_bidirectional ( | void )`[private, virtual]`

| Is the messaging object ready for processing BiDirectional request/response? Reimplemented from TAO_Pluggable_Messaging.

TAO_Queued_Data * TAO_GIOP_Message_Lite::make_queued_data ( | size_t sz )`[private]`

int TAO_GIOP_Message_Lite::make_send_locate_reply ( | TAO_Transport * transport,
| TAO_OutputCDR & output,
| TAO_GIOP_Locate_Request_Header & request,
| TAO_GIOP_Locate_Status_Msg & status )`[private]`

| Make a <GIOP_LOCATEREPLY> and hand that over to the transport so that it can be sent over the connection. NOTE:As on date 1.1 & 1.2 seem to have similar headers. Till an unmanageable difference comes let them be implemented here.

TAO_Pluggable_Message_Type TAO_GIOP_Message_Lite::message_type ( | void )

| Get the message type. The return value would be one of the following: TAO_PLUGGABLE_MESSAGE_REQUEST, TAO_PLUGGABLE_MESSAGE_REPLY, TAO_PLUGGABLE_MESSAGE_CLOSECONNECTION, TAO_PLUGGABLE_MESSAGE_MESSAGE_ERROR.

ssize_t TAO_GIOP_Message_Lite::missing_data ( | ACE_Message_Block & message_block )`[virtual]`

| Calculate the amount of data that is missing in the <incoming> message block. Reimplemented from TAO_Pluggable_Messaging.

int TAO_GIOP_Message_Lite::parse_incoming_messages ( | ACE_Message_Block & message_block )`[virtual]`

| Parse the incoming messages.. Reimplemented from TAO_Pluggable_Messaging.

int TAO_GIOP_Message_Lite::parse_locate_header ( | TAO_GIOP_Locate_Request_Header & request )`[private]`

| Parse the Loacte Request Header from the incoming stream. This will do a version specific parsing of the incoming Request header.

int TAO_GIOP_Message_Lite::parse_locate_reply ( | TAO_InputCDR & input,
| TAO_Pluggable_Reply_Params & params )`[private]`

| Parse the locate reply message from the server.

int TAO_GIOP_Message_Lite::parse_reply ( | TAO_InputCDR & input,
| TAO_Pluggable_Reply_Params & params )`[private]`

| Parse the reply message.

int TAO_GIOP_Message_Lite::parse_request_header ( | TAO_ServerRequest & request )`[private]`

| Parse the Request Header from the incoming stream. This will do a version specific parsing of the incoming Request header.

int TAO_GIOP_Message_Lite::process_locate_request ( | TAO_Transport * transport,
| TAO_InputCDR & input,
| TAO_OutputCDR & output )`[private]`

| Processes the <GIOP_LOCATE_REQUEST> messages.

int TAO_GIOP_Message_Lite::process_reply_message ( | TAO_Pluggable_Reply_Params & reply_info,
| TAO_Queued_Data * qd )`[virtual]`

| Parse the reply message that we received and return the reply information though <reply_info>. Reimplemented from TAO_Pluggable_Messaging.

int TAO_GIOP_Message_Lite::process_request ( | TAO_Transport * transport,
| TAO_InputCDR & input,
| TAO_OutputCDR & output )`[private]`

| Processes the <GIOP_REQUEST> messages.

int TAO_GIOP_Message_Lite::process_request_message ( | TAO_Transport * transport,
| TAO_Queued_Data * qd )`[virtual]`

| Process the request message that we have received on the connection. Reimplemented from TAO_Pluggable_Messaging.

int TAO_GIOP_Message_Lite::read_message ( | TAO_Transport * transport,
| int block = 0,
| ACE_Time_Value * max_wait_time = 0 )`[virtual]`

| Dummy method to .. Reimplemented from TAO_Pluggable_Messaging.

void TAO_GIOP_Message_Lite::reset ( | void )`[virtual]`

| Reset the messaging the object. Reimplemented from TAO_Pluggable_Messaging.

void TAO_GIOP_Message_Lite::send_close_connection ( | const TAO_GIOP_Message_Version & version,
| TAO_Transport * transport,
| void * ctx )`[private]`

| Close a connection, first sending GIOP::CloseConnection.

int TAO_GIOP_Message_Lite::send_error ( | TAO_Transport * transport )`[private]`

| Send error messages.

int TAO_GIOP_Message_Lite::send_reply_exception ( | TAO_Transport * transport,
| TAO_ORB_Core * orb_core,
| CORBA::ULong request_id,
| IOP::ServiceContextList * svc_info,
| CORBA::Exception * x )`[private]`

| We must send a LocateReply through <transport>, this request resulted in some kind of exception.

int TAO_GIOP_Message_Lite::write_locate_reply_mesg ( | TAO_OutputCDR & output,
| CORBA::ULong request_id,
| TAO_GIOP_Locate_Status_Msg & status )`[private]`

| Writes the locate _reply message in to the <output>.

int TAO_GIOP_Message_Lite::write_locate_request_header ( | CORBA::ULong request_id,
| TAO_Target_Specification & spec,
| TAO_OutputCDR & msg )`[private]`

| Write the LocateRequest header.

int TAO_GIOP_Message_Lite::write_protocol_header ( | TAO_GIOP_Message_Type t,
| TAO_OutputCDR & msg )`[private]`

| Writes the GIOP header in to <msg> NOTE: If the GIOP header happens to change in the future, we can push this method in to the generator_parser classes.

int TAO_GIOP_Message_Lite::write_reply_header ( | TAO_OutputCDR & output,
| TAO_Pluggable_Reply_Params_Base & reply,
| CORBA::Environment & ACE_TRY_ENV = TAO_default_environment () ) throw (CORBA::SystemException)`[private]`

| Write the reply header in to <output>.

int TAO_GIOP_Message_Lite::write_request_header ( | const TAO_Operation_Details & opdetails,
| TAO_Target_Specification & spec,
| TAO_OutputCDR & msg )`[private]`

| Write the request header in to <msg>.

## Member Data Documentation

CORBA::Octet TAO_GIOP_Message_Lite::byte_order_`[private]`

CORBA::ULong TAO_GIOP_Message_Lite::message_size_`[private]`

| The pay load size.

CORBA::Octet TAO_GIOP_Message_Lite::message_type_`[private]`

| The message type that we are going to process..

TAO_ORB_Core * TAO_GIOP_Message_Lite::orb_core_`[private]`

| Our copy of the ORB core...

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

- GIOP_Message_Lite.h
- GIOP_Message_Lite.cpp