Definitions of the GIOP specific stuff. More...
#include <GIOP_Message_Base.h>
Definitions of the GIOP specific stuff.
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_GIOP_Message_Base::TAO_GIOP_Message_Base | ( | TAO_ORB_Core * | orb_core, |
TAO_Transport * | transport, | ||
size_t | input_cdr_size = ACE_CDR::DEFAULT_BUFSIZE |
||
) |
Constructor.
TAO_GIOP_Message_Base::~TAO_GIOP_Message_Base | ( | void | ) |
Dtor.
int TAO_GIOP_Message_Base::consolidate_fragmented_message | ( | TAO_Queued_Data * | qd, |
TAO_Queued_Data *& | msg | ||
) |
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.
int TAO_GIOP_Message_Base::consolidate_node | ( | TAO_Queued_Data * | qd, |
ACE_Message_Block & | incoming | ||
) |
Check whether the node qd needs consolidation from incoming.
int TAO_GIOP_Message_Base::discard_fragmented_message | ( | const TAO_Queued_Data * | cancel_request ) |
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
int TAO_GIOP_Message_Base::dump_consolidated_msg | ( | TAO_OutputCDR & | stream ) | [private] |
Print out consolidate messages.
void TAO_GIOP_Message_Base::dump_msg | ( | const char * | label, |
const u_char * | ptr, | ||
size_t | len | ||
) | [private] |
Print out a debug messages..
int TAO_GIOP_Message_Base::extract_next_message | ( | ACE_Message_Block & | incoming, |
TAO_Queued_Data *& | qd | ||
) |
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.
int TAO_GIOP_Message_Base::format_message | ( | TAO_OutputCDR & | cdr, |
TAO_Stub * | stub | ||
) |
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.
size_t TAO_GIOP_Message_Base::fragment_header_length | ( | const TAO_GIOP_Message_Version & | giop_version ) | const |
The header length of a fragment.
TAO_GIOP_Fragmentation_Strategy * TAO_GIOP_Message_Base::fragmentation_strategy | ( | void | ) |
Outgoing GIOP message fragmentation strategy.
int TAO_GIOP_Message_Base::generate_exception_reply | ( | TAO_OutputCDR & | cdr, |
TAO_Pluggable_Reply_Params_Base & | params, | ||
const CORBA::Exception & | x | ||
) |
Generate a reply message with the exception ex.
int TAO_GIOP_Message_Base::generate_fragment_header | ( | TAO_OutputCDR & | cdr, |
CORBA::ULong | request_id | ||
) |
int TAO_GIOP_Message_Base::generate_locate_reply_header | ( | TAO_OutputCDR & | cdr, |
TAO_Pluggable_Reply_Params_Base & | params | ||
) | [private] |
Write the locate reply header.
int TAO_GIOP_Message_Base::generate_locate_request_header | ( | TAO_Operation_Details & | op, |
TAO_Target_Specification & | spec, | ||
TAO_OutputCDR & | cdr | ||
) |
Write the RequestHeader in to the cdr stream.
int TAO_GIOP_Message_Base::generate_reply_header | ( | TAO_OutputCDR & | cdr, |
TAO_Pluggable_Reply_Params_Base & | params | ||
) |
Write the reply header.
int TAO_GIOP_Message_Base::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.
TAO_GIOP_Message_Generator_Parser * TAO_GIOP_Message_Base::get_parser | ( | const TAO_GIOP_Message_Version & | version ) | const [private] |
Get the parser.
size_t TAO_GIOP_Message_Base::header_length | ( | void | ) | const |
Header length.
void TAO_GIOP_Message_Base::init | ( | CORBA::Octet | major, |
CORBA::Octet | minor | ||
) |
Initialize the underlying state object based on the major and minor revision numbers
bool TAO_GIOP_Message_Base::is_ready_for_bidirectional | ( | TAO_OutputCDR & | msg ) | const |
Is the messaging object ready for processing BiDirectional request/response?
TAO_Queued_Data * TAO_GIOP_Message_Base::make_queued_data | ( | size_t | sz ) | [private] |
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 * | parser | ||
) | [private] |
Make a GIOP_LOCATEREPLY and hand that over to the transport so that it can be sent over the connection.
TAO_OutputCDR & TAO_GIOP_Message_Base::out_stream | ( | void | ) |
int TAO_GIOP_Message_Base::parse_next_message | ( | TAO_Queued_Data & | qd, |
size_t & | mesg_length | ||
) |
Parse the details of the next message from the incoming and initializes attributes of qd.
0 | If the message header could not be parsed completely, |
1 | If the message header could be parsed completely |
-1 | On error. |
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::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::process_locate_request | ( | TAO_Transport * | transport, |
TAO_InputCDR & | input, | ||
TAO_OutputCDR & | output, | ||
TAO_GIOP_Message_Generator_Parser * | parser | ||
) | [private] |
Processes the GIOP_LOCATE_REQUEST messages.
int TAO_GIOP_Message_Base::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 through reply_info
int TAO_GIOP_Message_Base::process_request | ( | TAO_Transport * | transport, |
TAO_InputCDR & | input, | ||
TAO_OutputCDR & | output, | ||
TAO_GIOP_Message_Generator_Parser * | parser | ||
) | [private] |
Processes the GIOP_REQUEST messages.
int TAO_GIOP_Message_Base::process_request_message | ( | TAO_Transport * | transport, |
TAO_Queued_Data * | qd | ||
) |
Process the request message that we have received on the connection
void TAO_GIOP_Message_Base::send_close_connection | ( | const TAO_GIOP_Message_Version & | version, |
TAO_Transport * | transport | ||
) | [private] |
Close a connection, first sending GIOP::CloseConnection.
int TAO_GIOP_Message_Base::send_error | ( | TAO_Transport * | transport ) | [private] |
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 | ||
) | [private] |
We must send a LocateReply through transport, this request resulted in some kind of exception.
void TAO_GIOP_Message_Base::set_giop_flags | ( | TAO_OutputCDR & | msg ) | const [private] |
Set GIOP message flags in message that has been marshaled into the output CDR stream msg.
int TAO_GIOP_Message_Base::write_protocol_header | ( | GIOP::MsgType | t, |
const TAO_GIOP_Message_Version & | version, | ||
TAO_OutputCDR & | msg | ||
) | [private] |
Writes the GIOP header in to msg
TAO::Incoming_Message_Stack TAO_GIOP_Message_Base::fragment_stack_ [private] |
All Fragments being received are stored on stack in reverse order, last top
auto_ptr<TAO_GIOP_Fragmentation_Strategy> TAO_GIOP_Message_Base::fragmentation_strategy_ [protected] |
Strategy that sends data currently marshaled into this TAO_OutputCDR stream if necessary.
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.