#include <GIOP_Message_Base.h>
Inheritance diagram for TAO_GIOP_Message_Base:
This class will hold the specific details common to all the GIOP versions. Some of them which are here may be shifted if things start changing between versions.
TAO_BEGIN_VERSIONED_NAMESPACE_DECL TAO_GIOP_Message_Base::TAO_GIOP_Message_Base | ( | TAO_ORB_Core * | orb_core, | |
size_t | input_cdr_size = ACE_CDR::DEFAULT_BUFSIZE | |||
) |
Constructor.
TAO_GIOP_Message_Base::~TAO_GIOP_Message_Base | ( | void | ) | [virtual] |
Dtor.
int TAO_GIOP_Message_Base::consolidate_fragmented_message | ( | TAO_Queued_Data * | qd, | |
TAO_Queued_Data *& | msg | |||
) | [virtual] |
Consolidate fragmented message with associated fragments, being stored withi this class. If reliable transport is used (like TCP) fragments are partialy ordered on stack, last fragment on top. Otherwise If un-reliable transport is used (like UDP) fragments may be dis-ordered, and must be ordered before consolidation.
Implements TAO_Pluggable_Messaging.
int TAO_GIOP_Message_Base::consolidate_node | ( | TAO_Queued_Data * | qd, | |
ACE_Message_Block & | incoming | |||
) | [virtual] |
int TAO_GIOP_Message_Base::discard_fragmented_message | ( | const TAO_Queued_Data * | cancel_request | ) | [virtual] |
Discard all fragments associated to request-id encoded in cancel_request. This operation will never be called concurrently by multiplpe threads nor concurrently to consolidate_fragmented_message
Implements TAO_Pluggable_Messaging.
void TAO_GIOP_Message_Base::dump_msg | ( | const char * | label, | |
const u_char * | ptr, | |||
size_t | len | |||
) | [protected] |
Print out a debug messages..
int TAO_GIOP_Message_Base::extract_next_message | ( | ACE_Message_Block & | incoming, | |
TAO_Queued_Data *& | qd | |||
) | [virtual] |
Extract the details of the next message from the incoming through qd. Returns 0 if the message header could not be parsed completely, returns a 1 if the message header could be parsed completely and returns -1 on error.
Implements TAO_Pluggable_Messaging.
int TAO_GIOP_Message_Base::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.
Implements TAO_Pluggable_Messaging.
size_t TAO_GIOP_Message_Base::fragment_header_length | ( | CORBA::Octet | major, | |
CORBA::Octet | minor | |||
) | const [virtual] |
int TAO_GIOP_Message_Base::generate_exception_reply | ( | TAO_OutputCDR & | cdr, | |
TAO_Pluggable_Reply_Params_Base & | params, | |||
CORBA::Exception & | x | |||
) | [virtual] |
int TAO_GIOP_Message_Base::generate_locate_reply_header | ( | TAO_OutputCDR & | , | |
TAO_Pluggable_Reply_Params_Base & | ||||
) | [protected, virtual] |
int TAO_GIOP_Message_Base::generate_locate_request_header | ( | TAO_Operation_Details & | op, | |
TAO_Target_Specification & | spec, | |||
TAO_OutputCDR & | cdr | |||
) | [virtual] |
int TAO_GIOP_Message_Base::generate_reply_header | ( | TAO_OutputCDR & | cdr, | |
TAO_Pluggable_Reply_Params_Base & | params | |||
) | [virtual] |
int TAO_GIOP_Message_Base::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.
Implements TAO_Pluggable_Messaging.
size_t TAO_GIOP_Message_Base::header_length | ( | void | ) | const [virtual] |
void TAO_GIOP_Message_Base::init | ( | CORBA::Octet | major, | |
CORBA::Octet | minor | |||
) | [virtual] |
Initialize the underlying state object based on the major and minor revision numbers
Implements TAO_Pluggable_Messaging.
void TAO_GIOP_Message_Base::init_queued_data | ( | TAO_Queued_Data * | qd, | |
const TAO_GIOP_Message_State & | state | |||
) | const [protected] |
Initialize the TAO_Queued_Data from the relevant portions of a GIOP_Message_State.
int TAO_GIOP_Message_Base::is_ready_for_bidirectional | ( | TAO_OutputCDR & | msg | ) | [protected, virtual] |
Is the messaging object ready for processing BiDirectional request/response?
Implements TAO_Pluggable_Messaging.
TAO_Queued_Data * TAO_GIOP_Message_Base::make_queued_data | ( | size_t | sz | ) | [protected] |
Creates a new node for the queue with a message block in the node of size sz.
int TAO_GIOP_Message_Base::make_send_locate_reply | ( | TAO_Transport * | transport, | |
TAO_GIOP_Locate_Request_Header & | request, | |||
TAO_GIOP_Locate_Status_Msg & | status, | |||
TAO_OutputCDR & | output, | |||
TAO_GIOP_Message_Generator_Parser * | ||||
) | [protected] |
Make a GIOP_LOCATEREPLY and hand that over to the transport so that it can be sent over the connection.
TAO_Pluggable_Message_Type TAO_GIOP_Message_Base::message_type | ( | const TAO_GIOP_Message_State & | state | ) | const [protected] |
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.
TAO_OutputCDR & TAO_GIOP_Message_Base::out_stream | ( | void | ) | [virtual] |
int TAO_GIOP_Message_Base::parse_incoming_messages | ( | ACE_Message_Block & | incoming | ) | [private] |
int TAO_GIOP_Message_Base::parse_next_message | ( | ACE_Message_Block & | incoming, | |
TAO_Queued_Data & | qd, | |||
size_t & | mesg_length | |||
) | [virtual] |
Parse the details of the next message from the incoming and initializes attributes of qd. Returns 0 if the message header could not be parsed completely, returns a 1 if the message header could be parsed completely and returns -1 on error.
Implements TAO_Pluggable_Messaging.
int TAO_GIOP_Message_Base::parse_request_id | ( | const TAO_InputCDR & | cdr, | |
CORBA::ULong & | request_id | |||
) | const [private] |
Parse GIOP request-id of TAO_InputCDR cdr.
int TAO_GIOP_Message_Base::parse_request_id | ( | const TAO_Queued_Data * | qd, | |
CORBA::ULong & | request_id | |||
) | const [private] |
Parse GIOP request-id of TAO_Queued_Data qd
int TAO_GIOP_Message_Base::process_locate_request | ( | TAO_Transport * | transport, | |
TAO_InputCDR & | input, | |||
TAO_OutputCDR & | output, | |||
TAO_GIOP_Message_Generator_Parser * | ||||
) | [protected, virtual] |
Processes the GIOP_LOCATE_REQUEST messages.
int TAO_GIOP_Message_Base::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 through reply_info
Implements TAO_Pluggable_Messaging.
int TAO_GIOP_Message_Base::process_request | ( | TAO_Transport * | transport, | |
TAO_InputCDR & | input, | |||
TAO_OutputCDR & | output, | |||
TAO_GIOP_Message_Generator_Parser * | ||||
) | [protected, virtual] |
Processes the GIOP_REQUEST messages.
int TAO_GIOP_Message_Base::process_request_message | ( | TAO_Transport * | transport, | |
TAO_Queued_Data * | qd | |||
) | [virtual] |
Process the request message that we have received on the connection
Implements TAO_Pluggable_Messaging.
void TAO_GIOP_Message_Base::reset | ( | void | ) | [virtual] |
void TAO_GIOP_Message_Base::send_close_connection | ( | const TAO_GIOP_Message_Version & | version, | |
TAO_Transport * | transport, | |||
void * | ctx | |||
) | [protected] |
Close a connection, first sending GIOP::CloseConnection.
int TAO_GIOP_Message_Base::send_error | ( | TAO_Transport * | transport | ) | [protected] |
Send error messages.
int TAO_GIOP_Message_Base::send_reply_exception | ( | TAO_Transport * | transport, | |
TAO_OutputCDR & | cdr, | |||
CORBA::ULong | request_id, | |||
IOP::ServiceContextList * | svc_info, | |||
CORBA::Exception * | x | |||
) | [protected] |
We must send a LocateReply through transport, this request resulted in some kind of exception.
void TAO_GIOP_Message_Base::set_state | ( | CORBA::Octet | major, | |
CORBA::Octet | minor, | |||
TAO_GIOP_Message_Generator_Parser *& | ||||
) | const [protected] |
Set the state.
int TAO_GIOP_Message_Base::write_protocol_header | ( | TAO_GIOP_Message_Type | t, | |
TAO_OutputCDR & | msg | |||
) | [protected] |
char TAO_GIOP_Message_Base::buffer_[ACE_CDR::DEFAULT_BUFSIZE] [protected] |
Buffer used for both the output and input CDR streams, this is "safe" because we only one of the streams at a time.
All Fragments being received are stored on stack in reverse order, last top
The message handler object that does reading and parsing of the incoming messages
TAO_ORB_Core* TAO_GIOP_Message_Base::orb_core_ [private] |
Cached ORB_Core pointer...
TAO_OutputCDR TAO_GIOP_Message_Base::out_stream_ [protected] |
Buffer where the request is placed.
All the implementations of GIOP message generator and parsers.