TipcMsg

Name

TipcMsg — user class for constructing, manipulating, and eventually destroying messages

Synopsis 

TipcMsg msg; 
TipcMsg msg(mt_obj); 
TipcMsg msg(mt_num); 
TipcMsg msg(mt_num, destination); 
TipcMsg msg(mt_num, destination, sender); 
TipcMsg msg(mt_name); 
TipcMsg msg(c_api_msg); 
TipcMsg msg(msg_object);

Inheritance

Description

The TipcMsg class acts as a C++ interface to the SmartSockets TipcMsg* C language API functions. The methods of the TipcMsg class allow you to construct messages and to manipulate the data of a message. See the TIBCO SmartSockets User’s Guide for more information on message composition in SmartSockets applications.

The TipcMsg class has two ways of appending and accessing data fields from a message. The first is designed to provide an interface similar to the C API and consists of several overloaded Append and Next member functions. The Append() and Next() member functions replace the prefixed TipcMsgAppend* and TipcMsgNext* functions of the C API. See Using Append and Next Functions for examples using insertion and extraction operators.

The second method of appending and accessing data fields is designed to provide an interface similar to C++ IOstream classes. Overloaded insertion (operator<<) and extraction (operator>>) operators replace the prefixed TipcMsgAppend* and TipcMsgNext* functions of the C API. Examples using insertion and extraction operators are presented in Using Append and Next Functions.

The TipcMsg class contains a private SmartSockets C API T_IPC_MSG message.

Caution

None

See Also

Tobj

Construction/Destruction

TipcMsg::TipcMsg

Syntax: 
TipcMsg();
Remarks:
Create a vacant TipcMsg object. When this constructor is used, the created object is vacant until it is either assigned a T_IPC_MSG message or a non-empty TipcMsg object with operator=.
 
 
Syntax: 
TipcMsg(const TipcMt& mt_obj);
Remarks:
Create a TipcMsg object with mt_obj. mt_obj is a SmartSockets TipcMt object used to create the message contained in a TipcMsg object. The object’s internal T_IPC_MSG variable is initialized by a call to TipcMsgCreate().
 
 
Syntax: 
TipcMsg(T_INT4 mt_num, T_STR destination = (T_STR)NULL, 
        T_STR sender = (T_STR)NULL);
Remarks:
Create a TipcMsg object with mt_num, destination, and sender. mt_num is the number of the message type used to create the message contained in a TipcMsg object by a call to TipcMsgCreate(). destination is the destination of the message. sender is the sender of the message. sender and destination default to NULL, meaning no sender or destination is to be specified, respectively, when the object is constructed.
 
 
Syntax: 
TipcMsg(T_STR mt_name);
Remarks:
Create a TipcMsg object with mt_name. mt_name is the name of a message type (not case sensitive) to be used to create a TipcMsg object. The object’s internal T_IPC_MSG variable is initialized by a call to TipcMsgCreate().
 
 
Syntax: 
TipcMsg(const T_IPC_MSG msg);
Remarks:
Create a TipcMsg object with msg. msg is a SmartSockets C API T_IPC_MSG message used in creating a TipcMsg object. The internal T_IPC_MSG variable of the object is assigned the value of msg and the reference count of msg is incremented by a call to TipcMsgIncrRefCount().
 
 
Syntax: 
TipcMsg(const TipcMsg msg_obj);
Remarks:
This constructor is a copy constructor used to create a TipcMsg object with another TipcMsg object called msg_obj. The internal T_IPC_MSG pointer of the created object is assigned the value of the internal T_IPC_MSG pointer of msg_obj and the reference count for that particular T_IPC_MSG message is incremented by calling TipcMsgIncrRefCount().

TipcMsg::~TipcMsg()

Syntax: 
~TipcMsg();
Remarks:
Destroy a TipcMsg object. The destructor calls TipcMsgDestroy() if the internal T_IPC_MSG variable of the object is not null and not read only. See the detailed description of TipcMsgDestroy in the TIBCO SmartSockets Application Programming Interface for more information regarding how the T_IPC_MSG variable’s reference count mechanism is used to control when the memory of the T_IPC_MSG is freed.

Public Member Functions

TipcMsg::Ack

Syntax: 
T_BOOL Ack();
Remarks:
Acknowledge delivery of a message.
C API:
TipcMsgAck

TipcMsg::AddNamed

Syntax: 
T_BOOL AddNamed(T_STR name, T_PTR value, T_INT4 size);
Remarks:
Add a BINARY field to a message using a name.
C API:
TipcMsgAddNamedBinary
  
 
Syntax: 
T_BOOL AddNamed(T_STR name, T_PTR ptr, T_INT4 size, 
                T_IPC_MSG_FIELD *field_return);
Remarks:
Add a BINARY field to a message using a name and a pointer to the field value, rather than a copy.
C API:
TipcMsgAddNamedBinaryPtr
  
 
Syntax: 
T_BOOL AddNamedBool(T_STR name, T_BOOL value);
Remarks:
Add a BOOL field to a message using a name.
C API:
TipcMsgAddNamedBool
  
 
Syntax: 
T_BOOL AddNamedBool(T_STR name, T_BOOL *value, 
                    T_INT4 size);
Remarks:
Add a field containing an array of BOOL fields to a message using a name.
C API:
TipcMsgAddNamedBoolArray
  
 
Syntax: 
T_BOOL AddNamedBool(T_STR name, T_BOOL *value, T_INT4 size, 
                    T_IPC_MSG_FIELD *field_return);
Remarks:
Add a field containing an array of BOOL fields to a message using a name and a pointer to the field value, rather than a copy.
C API:
TipcMsgAddNamedBoolArrayPtr
  
 
Syntax: 
T_BOOL AddNamed(T_STR name, T_UCHAR value);
Remarks:
Add a BYTE field to a message using a name.
C API:
TipcMsgAddNamedByte
  
 
Syntax: 
T_BOOL AddNamed(T_STR name, T_CHAR value);
Remarks:
Add a CHAR field to a message using a name.
C API:
TipcMsgAddNamedChar
  
 
Syntax: 
T_BOOL AddNamed(T_STR name, T_INT2 value);
Remarks:
Add an INT2 field to a message using a name.
C API:
TipcMsgAddNamedInt2
  
 
Syntax: 
T_BOOL AddNamed(T_STR name, T_INT2 *value, T_INT4 size);
Remarks:
Add a field containing an array of INT2 fields to a message using a name.
C API:
TipcMsgAddNamedInt2Array
  
 
Syntax: 
T_BOOL AddNamed(T_STR name, T_INT2 *value, T_INT4 size,  
                T_IPC_MSG_FIELD *field_return);
Remarks:
Add a field containing an array of INT2 fields to a message using a name and a pointer to the field value, rather than a copy.
C API:
TipcMsgAddNamedInt2ArrayPtr
  
 
Syntax: 
T_BOOL AddNamed(T_STR name, T_INT4 value);
Remarks:
Add an INT4 field to a message using a name.
C API:
TipcMsgAddNamedInt4
  
 
Syntax: 
T_BOOL AddNamed(T_STR name, T_INT4 *value, T_INT4 size);
Remarks:
Add a field containing an array of INT4 fields to a message using a name.
C API:
TipcMsgAddNamedInt4Array
  
 
Syntax: 
T_BOOL AddNamed(T_STR name, T_INT4 *value, T_INT4 size,  
                T_IPC_MSG_FIELD *field_return);
Remarks:
Add a field containing an array of INT4 fields to a message using a name and a pointer to the field value, rather than a copy.
C API:
TipcMsgAddNamedInt4ArrayPtr
  
 
Syntax: 
T_BOOL AddNamed(T_STR name, T_INT8 value);
Remarks:
Add an INT8 field to a message using a name.
C API:
TipcMsgAddNamedInt8
  
 
Syntax: 
T_BOOL AddNamed(T_STR name, T_INT8 *value, T_INT4 size);
Remarks:
Add a field containing an array of INT8 fields to a message using a name.
C API:
TipcMsgAddNamedInt8Array
  
 
Syntax: 
T_BOOL AddNamed(T_STR name, T_INT8 *value, T_INT4 size,  
                T_IPC_MSG_FIELD *field_return);
Remarks:
Add a field containing an array of INT8 fields to a message using a name and a pointer to the field value, rather than a copy.
C API:
TipcMsgAddNamedInt8ArrayPtr
  
 
Syntax: 
T_BOOL AddNamed(T_STR name, T_IPC_MSG value);
Remarks:
Add a T_IPC_MSG field to a message using a name.
C API:
TipcMsgAddNamedMsg
  
 
Syntax: 
T_BOOL AddNamed(T_STR name, T_PTR ptr);
Remarks:
Add a MSG field to a message using a name and a pointer to the field value, rather than a copy.
C API:
TipcMsgAddNamedMsgPtr
  
 
Syntax: 
T_BOOL AddNamed(T_STR name, T_MSG *value, T_INT4 size);
Remarks:
Add a field containing an array of MSG fields to a message using a name.
C API:
TipcMsgAddNamedMsgArray
  
 
Syntax: 
T_BOOL AddNamed(T_STR name, T_MSG *value, T_INT4 size,  
                T_IPC_MSG_FIELD *field_return);
Remarks:
Add a field containing an array of MSG fields to a message using a name and a pointer to the field value, rather than a copy.
C API:
TipcMsgAddNamedMsgArrayPtr
  
 
Syntax: 
T_BOOL AddNamed(T_STR name, T_PTR ptr, T_INT4 size, 
                T_IPC_MSG_FIELD *field_return);
Remarks:
Add a MSG field to a message using a pointer.
C API:
TipcMsgAddNamedMsgPtr
  
 
Syntax: 
T_BOOL AddNamed(T_STR name, T_REAL4 value);
Remarks:
Add a REAL4 field to a message using a name.
C API:
TipcMsgAddNamedReal4
  
 
Syntax: 
T_BOOL AddNamed(T_STR name, T_REAL4 *value, T_INT4 size);
Remarks:
Add a field containing an array of REAL4 fields to a message using a name.
C API:
TipcMsgAddNamedReal4Array
  
 
Syntax: 
T_BOOL AddNamed(T_STR name, T_REAL4 *value, T_INT4 size,  
                T_IPC_MSG_FIELD *field_return);
Remarks:
Add a field containing an array of REAL4 fields to a message using a name and a pointer to the field value, rather than a copy.
C API:
TipcMsgAddNamedReal4ArrayPtr
  
 
Syntax: 
T_BOOL AddNamed(T_STR name, T_REAL8 value);
Remarks:
Add a REAL8 field to a message using a name.
C API:
TipcMsgAddNamedReal8
  
 
Syntax: 
T_BOOL AddNamed(T_STR name, T_REAL8 *value, T_INT4 size);
Remarks:
Add a field containing an array of REAL8 fields to a message using a name.
C API:
TipcMsgAddNamedReal8Array
  
 
Syntax: 
T_BOOL AddNamed(T_STR name, T_REAL8 *value, T_INT4 size,  
                T_IPC_MSG_FIELD *field_return);
Remarks:
Add a field containing an array of REAL8 fields to a message using a name and a pointer to the field value, rather than a copy.
C API:
TipcMsgAddNamedReal8ArrayPtr
  
 
Syntax: 
T_BOOL AddNamed(T_STR name, T_REAL16 value);
Remarks:
Add a REAL16 field to a message using a name.
C API:
TipcMsgAddNamedReal16
  
 
Syntax: 
T_BOOL AddNamed(T_STR name, T_REAL16 *value, T_INT4 size);
Remarks:
Add a field containing an array of REAL16 fields to a message using a name.
C API:
TipcMsgAddNamedReal16Array
  
 
Syntax: 
T_BOOL AddNamed(T_STR name, T_REAL16 *value, T_INT4 size,  
                T_IPC_MSG_FIELD *field_return);
Remarks:
Add a field containing an array of REAL16 fields to a message using a name and a pointer to the field value, rather than a copy.
C API:
TipcMsgAddNamedReal16ArrayPtr
  
 
Syntax: 
T_BOOL AddNamed(T_STR name, T_STR value);
Remarks:
Add a STR field to a message using a name.
C API:
TipcMsgAddNamedStr
  
 
Syntax: 
T_BOOL AddNamed(T_STR name, T_STR *value, T_INT4 size);
Remarks:
Add a field containing an array of STR fields to a message using a name.
C API:
TipcMsgAddNamedStrArray
  
 
Syntax: 
T_BOOL AddNamed(T_STR name, T_STR *value, T_INT4 size,  
                T_IPC_MSG_FIELD *field_return);
Remarks:
Add a field containing an array of STR fields to a message using a name and a pointer to the field value, rather than a copy.
C API:
TipcMsgAddNamedStrArrayPtr
  
 
Syntax: 
T_BOOL AddNamed(T_STR name, T_PTR ptr);
Remarks:
Add a STR field to a message using a name and a pointer to the field value, rather than a copy.
C API:
TipcMsgAddNamedStrPtr
  
 
Syntax: 
T_BOOL AddNamedUnknown(T_STR name, T_IPC_FT type);
Remarks:
Add a field with an unknown or non-existent value to a message using a name.
C API:
TipcMsgAddNamedUnknown
  
 
Syntax: 
T_BOOL AddNamedUtf8(T_STR name, T_STR value);
Remarks:
Add a UTF8 field to a message using a name.
C API:
TipcMsgAddNamedUtf8
  
 
Syntax: 
T_BOOL AddNamedUtf8(T_STR name, T_STR *value, T_INT4 size);
Remarks:
Add a field containing an array of UTF8 fields to a message using a name.
C API:
TipcMsgAddNamedUtf8Array
  
 
Syntax: 
T_BOOL AddNamedUtf8(T_STR name, T_STR *value, T_INT4 size,  
                    T_IPC_MSG_FIELD *field_return);
Remarks:
Add a field containing an array of UTF8 fields to a message using a name and a pointer to the field value, rather than a copy.
C API:
TipcMsgAddNamedUtf8ArrayPtr
  
 
Syntax: 
T_BOOL AddNamedUtf8(T_STR name, T_STR value,  
                    T_IPC_MSG_FIELD *field_return);
Remarks:
Add a UTF8 field to a message using a name and a pointer to the field value, rather than a copy.
C API:
TipcMsgAddNamedUtf8Ptr
  
 
Syntax: 
T_BOOL AddNamed(T_STR name, T_XML value);
Remarks:
Add the named XML field to a message.
C API:
TipcMsgAddNamedXml
  
 
Syntax: 
T_BOOL AddNamed(T_STR name, T_XML value,  
                T_IPC_MSG_FIELD field_return);
Remarks:
Add the named XML field pointer to a message.
C API:
TipcMsgAddNamedXmlPtr

TipcMsg::Append

Syntax: 
virtual T_BOOL Append(T_PTR binary_data, T_INT4 binary_size);
Remarks:
Append a BINARY field to a message.
C API:
TipcMsgAppendBinary
 
 
Syntax: 
virtual T_BOOL AppendBool(T_BOOL bool_data);
Remarks:
Append a BOOL field to a message.
C API:
TipcMsgAppendBool
 
 
Syntax: 
virtual T_BOOL AppendBool(T_BOOL *bool_array_data,  
                          T_INT4 array_size);
Remarks:
Append a BOOL_ARRAY field to a message.
C API:
TipcMsgAppendBoolArray
 
 
Syntax: 
virtual T_BOOL Append(T_UCHAR byte_data, T_INT4 byte_size);
Remarks:
Append a BYTE field to a message.
C API:
TipcMsgAppendByte
 
 
Syntax: 
virtual T_BOOL Append(T_CHAR char_data);
Remarks:
Append a CHAR field to a message.
C API:
TipcMsgAppendChar
 
 
Syntax: 
virtual T_BOOL Append(T_INT2 int2_data);
Remarks:
Append an INT2 field to a message.
C API:
TipcMsgAppendInt2
 
 
Syntax: 
virtual T_BOOL Append(T_INT2 *int2_array_data, 
                      T_INT4 int2_array_size);
Remarks:
Append an INT2_ARRAY field to a message.
C API:
TipcMsgAppendInt2Array
 
 
Syntax: 
virtual T_BOOL Append(T_INT4 int4_data);
Remarks:
Append an INT4 field to a message.
C API:
TipcMsgAppendInt4
  
 
Syntax: 
virtual T_BOOL Append(T_INT4 *int4_array_data, 
                      T_INT4 int4_array_size);
Remarks:
Append an INT4_ARRAY field to a message.
C API:
TipcMsgAppendInt4Array
 
 
Syntax: 
virtual T_BOOL Append(T_INT8 int8_data);
Remarks:
Append an INT8 field to a message.
C API:
TipcMsgAppendInt8
 
 
Syntax: 
virtual T_BOOL Append(T_INT8 *int8_array_data, 
                      T_INT4 int8_array_size);
Remarks:
Append an INT8_ARRAY field to a message.
C API:
TipcMsgAppendInt8Array
 
 
Syntax: 
virtual T_BOOL Append(TipcMsg& msg_data);
Remarks:
Append the internal MSG field of a TipcMsg object to a message.
C API:
TipcMsgAppendMsg
 
 
Syntax: 
virtual T_BOOL Append(TipcMsg& *msg_array_data, 
                      T_INT4 msg_array_size);
Remarks:
Append a TipcMsg object array to message. The internal T_IPC_MSG of each object of the array is transformed in an array of MSG messages and inserted into a message.
C API:
TipcMsgAppendMsgArray
 
 
Syntax: 
virtual T_BOOL Append(T_REAL4 real4_data);
Remarks:
Append a REAL4 field to a message.
C API:
TipcMsgAppendReal4
 
 
Syntax: 
virtual T_BOOL Append(T_REAL4 *real4_array_data, 
                      T_INT4 real4_array_size);
Remarks:
Append a REAL4_ARRAY field to a message.
C API:
TipcMsgAppendReal4Array
 
 
Syntax: 
virtual T_BOOL Append(T_REAL8 real8_data);
Remarks:
Append a REAL8 field to message.
C API:
TipcMsgAppendReal8
 
 
Syntax: 
virtual T_BOOL Append(T_REAL8 *real8_array_data, 
                      T_INT4 real8_array_size);
Remarks:
Append a REAL8_ARRAY field to a message.
C API:
TipcMsgAppendReal8Array
 
 
Syntax: 
virtual T_BOOL Append(T_REAL16 real16_data);
Remarks:
Append a REAL16 field to a message.
C API:
TipcMsgAppendReal16
 
 
Syntax: 
virtual T_BOOL Append(T_REAL16 *real16_array_data, 
                      T_INT4 real16_array_size);
Remarks:
Append a REAL16_ARRAY field to a message.
C API:
TipcMsgAppendReal16Array
 
 
Syntax: 
virtual T_BOOL Append(T_STR str_data);
Remarks:
Append a STR field to a message.
C API:
TipcMsgAppendStr
 
 
Syntax: 
virtual T_BOOL Append(T_STR *str_array_data, 
                      T_INT4 str_array_size);
Remarks:
Append a STR_ARRAY field to a message.
C API:
TipcMsgAppendStrArray
 
 
Syntax: 
virtual T_BOOL Append(T_STR str_data, T_REAL8 real8_data);
Remarks:
Append a STR field and a REAL8 field to a message.
C API:
TipcMsgAppendStrReal8
 
 
Syntax: 
virtual T_BOOL AppendUtf8(T_STR str_data);
Remarks:
Append a UTF8 field to a message.
C API:
TipcMsgAppendUtf8
 
 
Syntax: 
virtual T_BOOL AppendUtf8(T_STR *str_array_data, 
                          T_INT4 array_size);
Remarks:
Append a UTF8_ARRAY field to a message.
C API:
TipcMsgAppendUtf8Array
 
 
Syntax: 
virtual T_BOOL Append(T_XML xml_data);
Remarks:
Append an XML field to a message.
C API:
TipcMsgAppendXml

TipcMsg::AppendPtr

Syntax: 
virtual T_BOOL  
AppendPtr(T_PTR binary_data, T_INT4 binary_data_size, 
          T_IPC_MSG_FIELD *field_return);
Remarks:
Append a BINARY pointer field to a message.
C API:
TipcMsgAppendBinaryPtr
  
 
Syntax: 
	virtual T_BOOL AppendBoolPtr(T_BOOL *bool_array_data,  
                         T_INT4 guid_array_size,  
                         T_IPC_MSG_FIELD *field_return);
Remarks:
Append a field containing an array of BOOL fields to a message using a pointer.
C API:
TipcMsgAppendBoolArrayPtr
 
 
Syntax: 
virtual T_BOOL AppendPtr(T_IPC_MSG msg_data, 
                         T_IPC_MSG_FIELD *field_return);
Remarks:
Append a message pointer field to a message.
C API:
TipcMsgAppendMsgPtr
 
 
Syntax: 
virtual T_BOOL AppendPtr(T_INT2 *int2_array_data, 
                         T_INT4 int2_array_size, 
                         T_IPC_MSG_FIELD *field_return);
Remarks:
Append an INT2_ARRAY pointer field to a message.
C API:
TipcMsgAppendInt2ArrayPtr
 
 
Syntax: 
virtual T_BOOL AppendPtr(T_INT4 *int4_array_data, 
                         T_INT4 int4_array_size, 
                         T_IPC_MSG_FIELD *field_return);
Remarks:
Append an INT4_ARRAY pointer field to a message.
C API:
TipcMsgAppendInt4ArrayPtr
 
 
Syntax: 
virtual T_BOOL AppendPtr(T_INT8 *int8_array_data, 
                         T_INT4 int8_array_size, 
                         T_IPC_MSG_FIELD *field_return);
Remarks:
Append an INT8_ARRAY pointer field to a message.
C API:
TipcMsgAppendInt8ArrayPtr
 
 
Syntax: 
virtual T_BOOL AppendPtr(T_IPC_MSG *msg_array_data, 
                         T_INT4 msg_array_size, 
                         T_IPC_MSG_FIELD *field_return);
Remarks:
Append a MSG_ARRAY pointer field to a message.
C API:
TipcMsgAppendMsgArrayPtr
 
 
Syntax: 
virtual T_BOOL AppendPtr(T_REAL4 *real4_array_data, 
                         T_INT4 real4_array_size, 
                         T_IPC_MSG_FIELD *field_return);
Remarks:
Append a REAL4_ARRAY pointer field to a message.
C API:
TipcMsgAppendReal4ArrayPtr
 
 
Syntax: 
virtual T_BOOL AppendPtr(T_REAL8 *real8_array_data, 
                         T_INT4 real8_array_size, 
                         T_IPC_MSG_FIELD *field_return);
Remarks:
Append a REAL8_ARRAY pointer field to a message.
C API:
TipcMsgAppendReal8ArrayPtr
 
 
Syntax: 
virtual T_BOOL AppendPtr(T_REAL16 *real16_array_data, 
                         T_INT4 real16_array_size, 
                         T_IPC_MSG_FIELD *field_return);
Remarks:
Append a REAL16_ARRAY pointer field to a message.
C API:
TipcMsgAppendReal16ArrayPtr
 
 
Syntax: 
virtual T_BOOL AppendPtr(T_IPC_STR str_data,  
                         T_IPC_MSG_FIELD *field_return);
Remarks:
Append a STR pointer field to a message.
C API:
TipcMsgAppendStrPtr
 
 
Syntax: 
virtual T_BOOL AppendPtr(T_STR *str_array_data, 
                         T_INT4 str_array_size, 
                         T_IPC_MSG_FIELD *field_return);
Remarks:
Append a STR_ARRAY pointer field to a message.
C API:
TipcMsgAppendStrArrayPtr
 
 
Syntax: 
virtual T_BOOL AppendUtf8Ptr(T_STR *str_array_data,  
                             T_INT4 str_array_size,  
                             T_IPC_MSG_FIELD *field_return);
Remarks:
Append a UTF8_ARRAY pointer field to a message.
C API:
TipcMsgAppendUtf8ArrayPtr
 
 
Syntax: 
virtual T_BOOL AppendUtf8Ptr(T_STR str_data,  
                             T_IPC_MSG_FIELD *field_return);
Remarks:
Append a UTF8 pointer field to a message.
C API:
TipcMsgAppendUtf8Ptr
 
 
Syntax: 
virtual T_BOOL AppendPtr(T_XML xml_data, 
                         T_IPC_MSG_FIELD *field_return);
Remarks:
Append an XML pointer field to a message.
C API:
TipcMsgAppendXmlPtr

TipcMsg::AppendUnknown

Syntax: 
virtual T_BOOL AppendUnknown(T_IPC_FT field_type);
Remarks:
Appends a field of the given type with an unknown value.
C API:
TipcMsgAppendUnknown

TipcMsg::Clone

Syntax: 
T_BOOL Clone(TipcMsg& msg);
Remarks:
Make a clone of a message and assign it to the internal T_IPC_MSG field of msg. See the detailed description of TipcMsgClone in the TIBCO SmartSockets Application Programming Interface for a detailed description of message cloning. Any message that the object was managing at the time of the call is passed to TipcMsgDestroy().
C API:
TipcMsgClone

TipcMsg::CorrelationId

Syntax: 
T_STR CorrelationId();
Remarks:
Get the correlation identifier property of a message.
C API:
TipcMsgGetCorrelationId
  
 
Syntax: 
T_BOOL CorrelationId(T_STR correlation_id);
Remarks:
Set the correlation identifier property of a message.
C API:
TipcMsgSetCorrelationId

TipcMsg::Create

Syntax: 
T_BOOL Create(TipcMt& mt);
Remarks:
Create a new message. Any message that the object was managing at the time of the call is passed to TipcMsgDestroy().
C API:
TipcMsgCreate
 
 
Syntax: 
T_BOOL Create(T_INT4 mt_num);
Remarks:
Create a new message using mt_num. mt_num is the message type number. Any message that the object was managing at the time of the call is passed to TipcMsgDestroy().
C API:
TipcMsgCreate
 
 
Syntax: 
T_BOOL Create(T_STR mt_name);
Remarks:
Create a new message using mt_name. mt_name is the message type name. Any message that the object was managing at the time of the call is passed to TipcMsgDestroy().
C API:
TipcMsgCreate

TipcMsg::Current

Syntax: 
T_INT4 Current();
Remarks:
Get the current field of a message.
C API:
TipcMsgGetCurrent
 
 
Syntax: 
T_BOOL Current(T_INT4 field_num);
Remarks:
Set the current field of a message.
C API:
TipcMsgSetCurrent

TipcMsg::CurrentFieldKnown

Syntax: 
T_BOOL CurrentFieldKnown();
Remarks:
Returns TRUE if the value of the current field is known.
C API:
TipcMsgCurrentFieldKnown

TipcMsg::DeleteCurrent

Syntax: 
T_BOOL DeleteField();
Remarks:
Delete the current field in a message, whether it is named or unnamed.
C API:
TipcMsgDeleteCurrent

TipcMsg::DeleteField

Syntax: 
T_BOOL DeleteField(T_INT4 field_num);
Remarks:
Delete the specified field in a message.
C API:
TipcMsgDeleteField

TipcMsg::DeleteNamedField

Syntax: 
T_BOOL DeleteNamedField(T_STR name);
Remarks:
Delete the field in a message with the specified name.
C API:
TipcMsgDeleteNamedField

TipcMsg::DeliveryMode

Syntax: 
T_IPC_DELIVERY_MODE DeliveryMode();
Remarks:
Get the delivery mode of a message.
C API:
TipcMsgGetDeliveryMode
 
 
Syntax: 
T_BOOL DeliveryMode(T_IPC_DELIVERY_MODE delivery_mode);
Remarks:
Set the delivery mode of a message.
C API:
TipcMsgSetDeliveryMode

TipcMsg::DeliveryTimeout

Syntax: 
T_REAL8 DeliveryTimeout();
Remarks:
Get the delivery timeout of a message.
C API:
TipcMsgGetDeliveryTimeout
 
 
Syntax: 
T_BOOL DeliveryTimeout(T_REAL8 delivery_timeout);
Remarks:
Set the delivery timeout of a message.
C API:
TipcMsgSetDeliveryTimeout

TipcMsg::Dest

Syntax: 
T_STR Dest();
Remarks:
Get the destination property of a message.
C API:
TipcMsgGetDest
 
 
Syntax: 
T_BOOL Dest(T_STR dest);
Remarks:
Set the destination property of a message.
C API:
TipcMsgSetDest

TipcMsg::Destroy

Syntax: 
T_BOOL Destroy();
Remarks:
Destroy a message. This call leaves the object vacant after calling TipcMsgDestroy().
C API:
TipcMsgDestroy

TipcMsg::Expiration

Syntax: 
T_REAL8 Expiration();
Remarks:
Get the time to live property of a message.
C API:
TipcMsgGetExpiration
  
 
Syntax: 
T_BOOL Expiration(T_REAL8 expiration);
Remarks:
Set the time to live property of a message.
C API:
TipcMsgSetExpiration

TipcMsg::GetNamed

Syntax: 
T_BOOL GetNamed(T_STR name, T_PTR *value_return; 
                T_INT4 *size_return);
Remarks:
Get a field containing a BINARY value from a message, using a name.
C API:
TipcMsgGetNamedBinary
 
 
Syntax: 
T_BOOL GetNamedBool(T_STR name, T_BOOL *value_return);
Remarks:
Get a field with a BOOL value from a message, using a name.
C API:
TipcMsgGetNamedBool
 
 
Syntax: 
T_BOOL GetNamedBool(T_STR name, T_BOOL **value_return,  
                T_INT4 *size_return);
Remarks:
Get a field containing an array of BOOL values from a message, using a name.
C API:
TipcMsgGetNamedBoolArray
 
 
Syntax: 
T_BOOL GetNamed(T_STR name, T_UCHAR *value_return);
Remarks:
Get a field with a BYTE value from a message, using a name.
C API:
TipcMsgGetNamedByte
 
 
Syntax: 
T_BOOL GetNamed( T_STR name, T_CHAR *value_return);
Remarks:
Get a field with a character value from a message, using a name.
C API:
TipcMsgGetNamedChar
 
 
Syntax: 
T_BOOL GetNamed(T_STR name, T_INT2 *value_return);
Remarks:
Get a field with an INT2 value from a message, using a name.
C API:
TipcMsgGetNamedInt2
 
 
Syntax: 
T_BOOL GetNamed(T_STR name, T_INT2 **value_return,  
                T_INT4 *size_return);
Remarks:
Get a field containing an array of INT2 values from a message, using a name.
C API:
TipcMsgGetNamedInt2Array
 
 
Syntax: 
T_BOOL GetNamed(T_STR name, T_INT4 *value_return);
Remarks:
Get a field with an INT4 value from a message, using a name.
C API:
TipcMsgGetNamedInt4
 
 
Syntax: 
T_BOOL GetNamed(T_STR name, T_INT4 **value_return,  
                T_INT4 *size_return);
Remarks:
Get a field containing an array of INT4 values from a message, using a name.
C API:
TipcMsgGetNamedInt4Array
 
 
Syntax: 
T_BOOL GetNamed(T_STR name, T_INT8 *value_return);
Remarks:
Get a field with an INT8 value from a message, using a name.
C API:
TipcMsgGetNamedInt8
 
 
Syntax: 
T_BOOL GetNamed(T_STR name, T_INT8 **value_return,  
                T_INT4 *size_return);
Remarks:
Get a field containing an array of INT8 values from a message, using a name.
C API:
TipcMsgGetNamedInt8Array
 
 
Syntax: 
T_BOOL GetNamed(T_STR name, T_IPC_MSG *value_return);
Remarks:
Get a field with a MSG value from a message, using a name.
C API:
TipcMsgGetNamedMsg
 
 
Syntax: 
T_BOOL GetNamed(T_STR name, T_IPC_MSG **value_return,  
                T_INT4 *size_return);
Remarks:
Get a field containing an array of MSG values from a message, using a name.
C API:
TipcMsgGetNamedMsgArray
 
 
Syntax: 
T_BOOL GetNamed(T_STR name, T_REAL4 *value_return);
Remarks:
Get a field with a REAL4 value from a message, using a name.
C API:
TipcMsgGetNamedReal4
 
 
Syntax: 
T_BOOL GetNamed(T_STR name, T_REAL4 **value_return,  
                T_INT4 *size_return);
Remarks:
Get a field containing an array of REAL4 values from a message, using a name.
C API:
TipcMsgGetNamedReal4Array
 
 
Syntax: 
T_BOOL GetNamed(T_STR name, T_REAL8 *value_return);
Remarks:
Get a field with a REAL8 value from a message, using a name.
C API:
TipcMsgGetNamedReal8
 
 
Syntax: 
T_BOOL GetNamed(T_STR name, T_REAL8 **value_return,  
                T_INT4 *size_return);
Remarks:
Get a field containing an array of REAL8 values from a message, using a name.
C API:
TipcMsgGetNamedReal8Array
 
 
Syntax: 
T_BOOL GetNamed(T_STR name, T_REAL16 *value_return);
Remarks:
Get a field with a REAL16 value from a message, using a name.
C API:
TipcMsgGetNamedReal16
 
 
Syntax: 
T_BOOL GetNamed(T_STR name, T_REAL16 **value_return,  
                T_INT4 *size_return);
Remarks:
Get a field containing an array of REAL16 values from a message, using a name.
C API:
TipcMsgGetNamedReal16Array
 
 
Syntax: 
T_BOOL GetNamed(T_STR name, T_STR *value_return);
Remarks:
Get a field with a STR value from a message, using a name.
C API:
TipcMsgGetNamedStr
 
 
Syntax: 
T_BOOL GetNamed(T_STR name, T_STR **value_return,  
                T_INT4 *size_return);
Remarks:
Get a field containing an array of STR values from a message, using a name.
C API:
TipcMsgGetNamedStrArray
 
 
Syntax: 
T_BOOL GetNamedUnknown(T_STR name);
Remarks:
Get a field with an unknown or non-existent value from a message, using a name.
C API:
TipcMsgGetNamedUnknown
 
 
Syntax: 
T_BOOL GetNamedUtf8(T_STR name, T_STR *value_return);
Remarks:
Get a field with a UTF8 value from a message, using a name.
C API:
TipcMsgGetNamedUtf8
 
 
Syntax: 
T_BOOL GetNamedUtf8(T_STR name, T_STR **value_return,  
                    T_INT4 *size_return);
Remarks:
Get a field containing an array of UTF8 values from a message, using a name.
C API:
TipcMsgGetNamedUtf8Array
 
 
Syntax: 
T_BOOL GetNamed(T_STR name, T_XML *xml_return);
Remarks:
Get a field containing an XML value from a message, using a name.
C API:
TipcMsgGetNamedXml

TipcMsg::HeaderStrEncode

Syntax: 
T_BOOL HeaderStrEncode();
Remarks:
Get the header string encoding mode of a message.
C API:
TipcMsgGetHeaderStrEncode
 
 
Syntax: 
T_BOOL HeaderStrEncode(T_BOOL header_str_encode);
Remarks:
Set the header string encoding mode of a message.
C API:
TipcMsgSetHeaderStrEncode

TipcMsg::IncrRefCount

Syntax: 
T_BOOL IncrRefCount();
Remarks:
Increment the reference count of a message.
C API:
TipcMsgIncrRefCount

TipcMsg::LbMode

Syntax: 
T_IPC_LB_MODE LbMode();
Remarks:
Get the load balancing mode of a message.
C API:
TipcMsgGetLbMode
 
 
Syntax: 
T_BOOL LbMode(T_IPC_LB_MODE lb_mode);
Remarks:
Set the load balancing mode of a message.
C API:
TipcMsgSetLbMode

TipcMsg::Message

Syntax: 
T_IPC_MSG Message();
Remarks:
Return the internal T_IPC_MSG of the TipcMsg object.

TipcMsg::MessageId

Syntax: 
T_STR MessageId();
Remarks:
Get the message identifier property of a message.
C API:
TipcMsgGetMessageId
  
 
Syntax: 
T_BOOL GenerateMessageId();
Remarks:
Generate the message identifier property for the message.
C API:
TipcMsgGenerateMessageId

TipcMsg::Next

Syntax: 
virtual T_BOOL Next(T_PTR *binary_data, T_INT4 *binary_size);
Remarks:
Get a BINARY field from a message.
C API:
TipcMsgNextBinary
 
 
Syntax: 
virtual T_BOOL NextBool(T_BOOL *bool_return);
Remarks:
Get a BOOL field from a message.
C API:
TipcMsgNextBool
 
 
Syntax: 
virtual T_BOOL NextBool(T_BOOL **bool_array_data,  
                        T_INT4 *array_size);
Remarks:
Get a BOOL_ARRAY field from a message.
C API:
TipcMsgNextBoolArray
 
 
Syntax: 
virtual T_BOOL Next(T_UCHAR byte_return);
Remarks:
Get a BYTE field from a message.
C API:
TipcMsgNextByte
 
 
Syntax: 
virtual T_BOOL Next(T_CHAR *char_data);
Remarks:
Get a CHAR field from a message.
C API:
TipcMsgNextChar
 
 
Syntax: 
virtual T_BOOL Next(T_INT2 *int2_data);
Remarks:
Get an INT2 field from a message.
C API:
TipcMsgNextInt2
 
 
Syntax: 
virtual T_BOOL Next(T_INT2 **int2_array_data, 
                    T_INT4 *int2_array_size);
Remarks:
Get an INT2_ARRAY field from a message.
C API:
TipcMsgNextInt2Array
 
 
Syntax: 
virtual T_BOOL Next(T_INT4 *int4_data);
Remarks:
Get an INT4 field from a message.
C API:
TipcMsgNextInt4
 
 
Syntax: 
virtual T_BOOL Next(T_INT4 **int4_array_data, 
                    T_INT4 *int4_array_size);
Remarks:
Get an INT4_ARRAY field from a message.
C API:
TipcMsgNextInt4Array
 
 
Syntax: 
virtual T_BOOL Next(T_INT8 *int8_data);
Remarks:
Get an INT8 field from a message.
C API:
TipcMsgNextInt8
 
 
Syntax: 
virtual T_BOOL Next(TipcMsg **msg_array_data, 
                    T_INT4 *msg_array_size);
Remarks:
Get a MSG_ARRAY field from a message and assign each element of the array to an element of a TipcMsg object array.
C API:
TipcMsgNextMsgArray
 
 
Syntax: 
virtual T_BOOL Next(TipcMsg *msg_data);
Remarks:
Get a message field from a message and assign it to the internal field of a TipcMsg object.
C API:
TipcMsgNextMsg
 
 
Syntax: 
virtual T_BOOL Next(T_INT8 **int8_data, T_INT4 *int8_array_size);
Remarks:
Get an INT8_ARRAY field from a message.
C API:
TipMsgNextInt8Array
 
 
Syntax: 
virtual T_BOOL Next(T_REAL4 *real4_data);
Remarks:
Get a REAL4 field from a message.
C API:
TipcMsgNextReal4
 
 
Syntax: 
virtual T_BOOL Next(T_REAL4 **real4_array_data, 
                    T_INT4 *real4_array_size);
Remarks:
Get a REAL4_ARRAY field from a message.
C API:
TipcMsgNextReal4Array
 
 
Syntax: 
virtual T_BOOL Next(T_REAL8 *real8_data);
Remarks:
Get a REAL8 field from a message.
C API:
TipcMsgNextReal8
 
 
Syntax: 
virtual T_BOOL Next(T_REAL8 **real8_array_data, 
                    T_INT4 *real8_array_size);
Remarks:
Get a REAL8_ARRAY field from a message.
C API:
TipcMsgNextReal8Array
 
 
Syntax: 
virtual T_BOOL Next(T_REAL16 *real16_data);
Remarks:
Get a REAL16 field from a message
C API:
TipcMsgNextReal16
 
 
Syntax: 
virtual T_BOOL Next(T_REAL16 **real16_array_data, 
                    T_INT4 *real16_array_size);
Remarks:
Get a REAL16_ARRAY field from a message
C API:
TipcMsgNextReal16Array
 
 
Syntax: 
virtual T_BOOL Next(T_STR *str_data);
Remarks:
Get a STR field from a message.
C API:
TipcMsgNextStr
 
 
Syntax: 
virtual T_BOOL Next(T_STR **str_array_data, 
                    T_INT4 *str_array_size);
Remarks:
Get a STR_ARRAY field from a message.
C API:
TipcMsgNextStrArray
 
 
Syntax: 
virtual T_BOOL Next(T_STR *str_data, T_REAL8 *real8_data);
Remarks:
Get a STR field and a REAL8 field from a message.
C API:
TipcMsgNextStrReal8
 
 
Syntax: 
virtual T_BOOL NextUtf8(T_STR *str_data);
Remarks:
Get a UTF8 field from a message.
C API:
TipcMsgNextUtf8
 
 
Syntax: 
virtual T_BOOL NextUtf8(T_STR **str_array_data, 
                        T_INT4 *array_size);
Remarks:
Get a UTF_ARRAY field from a message.
C API:
TipcMsgNextUtf8
 
 
Syntax: 
virtual T_BOOL Next(T_XML *xml_data)
Remarks:
Get an XML string from a message.
C API:
TipcMsgNextXml

TipcMsg::NextUnknown

Syntax: 
T_BOOL NextUnknown();
Remarks:
Get an unknown field from a message.
C API:
TipcMsgNextUnknown

TipcMsg::NumFields

Syntax: 
T_INT4 NumFields();
Remarks:
Get the number of fields in a message.
C API:
TipcMsgGetNumFields
 
 
Syntax: 
T_BOOL NumFields(T_INT4 num_fields);
Remarks:
Set the number of fields in a message.
C API:
TipcMsgSetNumFields

TipcMsg::PacketSize

Syntax: 
T_UINT4 PacketSize();
Remarks:
Get the packet size of a message.
C API:
TipcMsgGetPacketSize

TipcMsg::Print

Syntax: 
virtual T_BOOL Print(T_OUT_FUNC func);
Remarks:
Print all information in a message.
C API:
TipcMsgPrint

TipcMsg::PrintError

Syntax: 
virtual T_BOOL PrintError();
Remarks:
Report an error about an unexpected message.
C API:
TipcMsgPrintError

TipcMsg::Priority

Syntax: 
T_INT2 Priority();
Remarks:
Get the priority of a message.
C API:
TipcMsgGetPriority
  
 
Syntax: 
T_BOOL Priority(T_INT2 priority);
Remarks:
Set the priority of a message.
C API:
TipcMsgSetPriority

TipcMsg::ReadOnly

Syntax: 
T_BOOL ReadOnly();
Remarks:
Get the read-only status of a message.
C API:
TipcMsgGetReadOnly

TipcMsg::RefCount

Syntax: 
T_INT4 RefCount();
Remarks:
Get the reference count of a message.
C API:
TipcMsgGetRefCount

TipcMsg::ReplyTo

Syntax: 
T_STR ReplyTo();
Remarks:
Get the reply to destination property of a message.
C API:
TipcMsgGetReplyTo
  
 
Syntax: 
T_BOOL ReplyTo(T_STR subj);
Remarks:
Set the reply to destination property of a message.
C API:
TipcMsgSetReplyTo

TipcMsg::ResetCheck

Syntax: 
void ResetCheck();
Remarks:
Reset the internal problem flag used by insertion and extraction operators to FALSE. See also the description of the Check manipulator in the Manipulators section on page 151.

TipcMsg::Sender

Syntax: 
T_STR Sender();
Remarks:
Get the sender property of a message.
C API:
TipcMsgGetSender
 
 
Syntax: 
T_BOOL Sender(T_STR sender);
Remarks:
Set the sender property of a message.
C API:
TipcMsgSetSender

TipcMsg::SeqNum

Syntax: 
T_INT4 SeqNum();
Remarks:
Get the sequence number of a message.
C API:
TipcMsgGetSeqNum

TipcMsg::Timestamp

Syntax: 
T_REAL8 SenderTimestamp();
Remarks:
Get the sender timestamp property of a message.
C API:
TipcMsgGetSenderTimestamp
  
 
Syntax: 
T_BOOL SenderTimestamp(T_REAL8 timestamp);
Remarks:
Set the sender timestamp property of a message.
C API:
TipcMsgSetSenderTimestamp
  
 
Syntax: 
T_REAL8 ArrivalTimestamp();
Remarks:
Get the arrival timestamp property of a message.
C API:
TipcMsgGetArrivalTimestamp
  
 
Syntax: 
T_BOOL ArrivalTimestamp(T_REAL8 timestamp);
Remarks:
Set the arrival timestamp property of a message.
C API:
TipcMsgSetArrivalTimestamp

TipcMsg::Traverse

Syntax: 
T_PTR Traverse(T_IPC_MSG_TRAV_FUNC func, T_PTR arg);
Remarks:
Traverse all fields in a message.
C API:
TipcMsgTraverse

TipcMsg::Type

Syntax: 
TipcMt& Type();
Remarks:
Get the type of a message.
C API:
TipcMsgGetType
 
 
Syntax: 
T_BOOL Type(TipcMt& mt);
Remarks:
Set the type of a message.
C API:
TipcMsgSetType

TipcMsg::UpdateNamed

Syntax: 
T_BOOL UpdateNamed(T_STR name, T_PTR value, T_INT4 size);
Remarks:
Update a named BINARY field in a message.
C API:
TipcMsgUpdateNamedBinary
  
 
Syntax: 
T_BOOL UpdateNamed(T_STR name, T_PTR value, T_INT4 size, 
                   T_IPC_MSG_FIELD *field_return);
Remarks:
Update a named BINARY pointer field in a message.
C API:
TipcMsgUpdateNamedBinaryPtr
  
 
Syntax: 
T_BOOL UpdateNamedBool(T_STR name, T_BOOL value);
Remarks:
Update a named BOOL field in a message.
C API:
TipcMsgUpdateNamedBool
  
 
Syntax: 
T_BOOL UpdateNamedBool(T_STR name, T_BOOL *value,  
                       T_INT4 size);
Remarks:
Update a named BOOL_ARRAY field in a message.
C API:
TipcMsgUpdateNamedBoolArray
  
 
Syntax: 
T_BOOL UpdateNamedBool(T_STR name, T_BOOL *value,  
                       T_INT4 size,  
                       T_IPC_MSG_FIELD *field_return);
Remarks:
Update a named BOOL_ARRAY pointer field in a message.
C API:
TipcMsgUpdateNamedBoolArrayPtr
  
 
Syntax: 
T_BOOL UpdateNamed(T_STR name, T_UCHAR value);
Remarks:
Update a named BYTE field in a message.
C API:
TipcMsgUpdateNamedByte
  
 
Syntax: 
T_BOOL UpdateNamed(T_STR name, T_CHAR value);
Remarks:
Update a named CHAR data field in a message.
C API:
TipcMsgUpdateNamedChar
  
 
Syntax: 
T_BOOL UpdateNamed(T_STR name, T_INT2 value);
Remarks:
Update a named INT2 data field in a message.
C API:
TipcMsgUpdateNamedInt2
  
 
Syntax: 
T_BOOL UpdateNamed(T_STR name, T_INT2 *value, T_INT4 size);
Remarks:
Update a named INT2_ARRAY field in a message.
C API:
TipcMsgUpdateNamedInt2Array
  
 
Syntax: 
T_BOOL UpdateNamed(T_STR name, T_INT2 *value, T_INT4 size, 
                   T_IPC_MSG_FIELD *field_return);
Remarks:
Update a named INT2_ARRAY pointer field in a message.
C API:
TipcMsgUpdateNamedInt2ArrayPtr
  
 
Syntax: 
T_BOOL UpdateNamed(T_STR name, T_INT4 value);
Remarks:
Update a named INT4 data field in a message.
C API:
TipcMsgUpdateNamedInt4
  
 
Syntax: 
T_BOOL UpdateNamed(T_STR name, T_INT4 *value, T_INT4 size);
Remarks:
Update a named INT4_ARRAY field in a message.
C API:
TipcMsgUpdateNamedInt4Array
  
 
Syntax: 
T_BOOL UpdateNamed(T_STR name, T_INT4 *value, T_INT4 size, 
                   T_IPC_MSG_FIELD *field_return);
Remarks:
Update a named INT4_ARRAY pointer field in a message.
C API:
TipcMsgUpdateNamedInt4ArrayPtr
  
 
Syntax: 
T_BOOL UpdateNamed(T_STR name, T_INT8 value);
Remarks:
Update a named INT8 field in a message.
C API:
TipcMsgUpdateNamedInt8
  
 
Syntax: 
T_BOOL UpdateNamed(T_STR name, T_INT8 *value, T_INT4 size);
Remarks:
Update a named INT8_ARRAY field in a message.
C API:
TipcMsgUpdateNamedInt8Array
  
 
Syntax: 
T_BOOL UpdateNamed(T_STR name, T_INT8 *value, T_INT4 size, 
                   T_IPC_MSG_FIELD *field_return);
Remarks:
Update a named INT8_ARRAY pointer field in a message.
C API:
TipcMsgUpdateNamedInt8ArrayPtr
  
 
Syntax: 
T_BOOL UpdateNamed(T_STR name, T_IPC_MSG value);
Remarks:
Update a named MSG field in a message.
C API:
TipcMsgUpdateNamedMsg
  
 
Syntax: 
T_BOOL UpdateNamed(T_STR name, T_IPC_MSG *value, T_INT4 
size);
Remarks:
Update a named MSG array data field in a message.
C API:
TipcMsgUpdateNamedMsgArray
  
 
Syntax: 
T_BOOL pdateNamed(T_STR name, T_IPC_MSG value, 
                  T_IPC_MSG_FIELD *field_return);
Remarks:
Update a named MSG pointer field in a message.
C API:
TipcMsgUpdateNamedMsgPtr
  
 
Syntax: 
T_BOOL UpdateNamed(T_STR name, T_IPC_MSG *value, T_INT4 size, 
                   T_IPC_MSG_FIELD *field_return);
Remarks:
Update a named MSG_ARRAY pointer field in a message.
C API:
TipcMsgUpdateNamedMsgArrayPtr
  
 
Syntax: 
T_BOOL UpdateNamed(T_STR name, T_REAL4 value);
Remarks:
Update a named REAL4 data field in a message.
C API:
TipcMsgUpdateNamedReal4
  
 
Syntax: 
T_BOOL UpdateNamed(T_STR name, T_REAL4 *value, T_INT4 size);
Remarks:
Update a named REAL4_ARRAY field in a message.
C API:
TipcMsgUpdateNamedReal4Array
  
 
Syntax: 
T_BOOL UpdateNamed(T_STR name, T_REAL4 *value, T_INT4 size, 
                   T_IPC_MSG_FIELD *field_return);
Remarks:
Update a named REAL4_ARRAY pointer field in a message.
C API:
TipcMsgUpdateNamedReal4ArrayPtr
  
 
Syntax: 
T_BOOL UpdateNamed(T_STR name, T_REAL8 value);
Remarks:
Update a named REAL8 data field in a message.
C API:
TipcMsgUpdateNamedReal8
  
 
Syntax: 
T_BOOL UpdateNamed(T_STR name, T_REAL8 *value, T_INT4 size);
Remarks:
Update a named REAL8_ARRAY field in a message.
C API:
TipcMsgUpdateNamedReal8Array
  
 
Syntax: 
T_BOOL UpdateNamed(T_STR name, T_REAL8 *value, T_INT4 size, 
                   T_IPC_MSG_FIELD *field_return);
Remarks:
Update a named REAL8_ARRAY pointer field in a message.
C API:
TipcMsgUpdateNamedReal8ArrayPtr
  
 
Syntax: 
T_BOOL UpdateNamed(T_STR name, T_REAL16 value);
Remarks:
Update a named REAL16 data field in a message.
C API:
TipcMsgUpdateNamedReal16
  
 
Syntax: 
T_BOOL UpdateNamed(T_STR name, T_REAL16 *value, T_INT4 size);
Remarks:
Update a named REAL16_ARRAY field in a message.
C API:
TipcMsgUpdateNamedReal16Array
  
 
Syntax: 
T_BOOL UpdateNamed(T_STR name, T_REAL16 *value, T_INT4 size, 
                   T_IPC_MSG_FIELD *field_return);
Remarks:
Update a named REAL16_ARRAY pointer field in a message.
C API:
TipcMsgUpdateNamedReal16ArrayPtr
  
 
Syntax: 
T_BOOL UpdateNamed(T_STR name, T_STR value);
Remarks:
Update a named STR field in a message.
C API:
TipcMsgUpdateNamedStr
  
 
Syntax: 
T_BOOL UpdateNamed(T_STR name, T_STR value, 
                   T_IPC_MSG_FIELD *field_return);
Remarks:
Update a named STR pointer field in a message.
C API:
TipcMsgUpdateNamedStrPtr
  
 
Syntax: 
T_BOOL UpdateNamed(T_STR name, T_STR *value, T_INT4 size);
Remarks:
Update a named STR_ARRAY field in a message.
C API:
TipcMsgUpdateNamedStrArray
  
 
Syntax: 
T_BOOL UpdateNamed(T_STR name, T_STR *value, T_INT4 size, 
                   T_IPC_MSG_FIELD *field_return);
Remarks:
Update a named STR_ARRAY pointer field in a message.
C API:
TipcMsgUpdateNamedStrArrayPtr
  
 
Syntax: 
T_BOOL UpdateNamedUtf8(T_STR name, T_STR value);
Remarks:
Update a named UTF8 data field in a message.
C API:
TipcMsgUpdateNamedUtf8
  
 
Syntax: 
T_BOOL UpdateNamedUtf8(T_STR name, T_STR *value,  
                       T_INT4 size);
Remarks:
Update a named UTF8_ARRAY field in a message.
C API:
TipcMsgUpdateNamedUtf8Array
  
 
Syntax: 
T_BOOL UpdateNamedUtf8(T_STR name, T_STR *value, T_INT4 size, 
                       T_IPC_MSG_FIELD field_return);
Remarks:
Update a named UTF8_ARRAY pointer field in a message.
C API:
TipcMsgUpdateNamedUtf8ArrayPtr
  
 
Syntax: 
T_BOOL UpdateNamedUtf8(T_STR name, T_STR *value, 
                       T_IPC_MSG_FIELD *field_return);
Remarks:
Update a named UTF8 pointer field in a message.
C API:
TipcMsgUpdateNamedUtf8Ptr
  
 
Syntax: 
T_BOOL UpdateNamed(T_STR name, T_XML value);
Remarks:
Update a named XML data field in a message.
C API:
TipcMsgUpdateNamedXml
  
 
Syntax: 
T_BOOL UpdateNamed(T_STR name, T_XML value, 
                   T_IPC_MSG_FIELD *field_return);
Remarks:
Update a named XML pointer field in a message.
C API:
TipcMsgUpdateNamedXmlPtr

TipcMsg::UserProp

Syntax: 
T_INT4 UserProp();
Remarks:
Get user-defined property from a message.
C API:
TipcMsgGetUserProp
 
 
Syntax: 
T_BOOL UserProp(T_INT4 user_prop);
Remarks:
Set user-defined property of a message.
C API:
TipcMsgSetUserProp

TipcMsg::Vacant

Syntax: 
T_BOOL Vacant();
Remarks:
Return TRUE if the object is vacant, FALSE otherwise.

Conversion Operators

TipcMsg::T_IPC_MSG

Syntax: 
operator T_IPC_MSG() const;
Remarks:
Convert a TipcMsg object to a C API T_IPC_MSG by returning the internal T_IPC_MSG of the TipcMsg object.

Operators

TipcMsg::operator=

Syntax: 
TipcMsg& operator=(const T_IPC_MSG msg);
Remarks:
Assign a T_IPC_MSG message to a TipcMsg object. msg is a SmartSockets C API T_IPC_MSG message assigned to the internal T_IPC_MSG message of a TipcMsg object. The reference count for that particular T_IPC_MSG message is incremented by calling TipcMsgIncrRefCount(). Any message that the object was managing at the time of the call is passed to TipcMsgDestroy().
 
 
Syntax: 
TipcMsg& operator=(const TipcMsg& msg_obj);
Remarks:
Assign the T_IPC_MSG message contained in msg_obj to another TipcMsg object. The T_IPC_MSG pointer of the assigned object is assigned the value of the internal T_IPC_MSG pointer of msg_obj, and the reference count for that particular T_IPC_MSG message is incremented by calling TipcMsgIncrRefCount(). Any message that the object was managing at the time of the call is passed to TipcMsgDestroy().

TipcMsg::operator<<

Syntax: 
virtual TipcMsg& operator<<(T_PTR arg);
Remarks:
Insert a BINARY data field into a message.
C API:
TipcMsgAppendBinary
 
 
Syntax: 
virtual TipcMsg& operator<<(T_CHAR arg);
Remarks:
Insert a CHAR field into a message.
C API:
TipcMsgAppendChar
 
 
Syntax: 
virtual TipcMsg& operator<<(T_INT2 arg);
Remarks:
Insert an INT2 field into a message.
C API:
TipcMsgAppendInt2
 
 
Syntax: 
virtual TipcMsg& operator<<(T_INT2 *arg);
Remarks:
Insert an INT2_ARRAY field into a message.
C API:
TipcMsgAppendInt2Array
 
 
Syntax: 
virtual TipcMsg& operator<<(T_INT4 arg);
Remarks:
Insert an INT4 field into a message.
C API:
TipcMsgAppendInt4
 
 
Syntax: 
virtual TipcMsg& operator<<(T_INT4 *arg);
Remarks:
Insert an INT4_ARRAY field into a message.
C API:
TipcMsgAppendInt4Array
 
 
Syntax: 
virtual TipcMsg& operator<<(T_INT8 arg);
Remarks:
Insert an INT8 field into a message.
C API:
TipcMsgAppendInt8
 
 
Syntax: 
virtual TipcMsg& operator<<(T_INT8 *arg);
Remarks:
Insert an INT8_ARRAY field into a message.
C API:
TipcMsgAppendInt8Array
 
 
Syntax: 
virtual TipcMsg& operator<<(TipcMsg& arg);
Remarks:
Insert a message from another TipcMsg object into a message. The T_IPC_MSG contained in the TipcMsg object argument is inserted into the message being operated on by using TipcMsgAppendMsg.
C API:
TipcMsgAppendMsg
  
 
Syntax: 
virtual TipcMsg& operator<<(TipcMsg *arg);
Remarks:
Insert a TipcMsg array into a message. The internal T_IPC_MSG of each object of the array is transformed into an array of MSG messages and inserted into a message.
C API:
TipcMsgAppendMsgArray
  
 
Syntax: 
virtual TipcMsg& operator<<(T_REAL4 arg);
Remarks:
Insert a REAL4 field into a message.
C API:
TipcMsgAppendReal4
  
 
Syntax: 
virtual TipcMsg& operator<<(T_REAL4 *arg);
Remarks
Insert a REAL4_ARRAY field into a message.
C API:
TipcMsgAppendReal4Array
  
 
Syntax: 
virtual TipcMsg& operator<<(T_REAL8 arg);
Remarks:
Insert a REAL8 field into a message.
C API:
TipcMsgAppendReal8
  
 
Syntax: 
virtual TipcMsg& operator<<(T_REAL8 *arg);
Remarks:
Insert a REAL8_ARRAY field into a message.
C API:
TipcMsgAppendReal8Array
  
 
Syntax: 
virtual TipcMsg& operator<<(T_REAL16 arg);
Remarks:
Insert a REAL16 field into a message.
C API:
TipcMsgAppendReal16
  
 
Syntax: 
virtual TipcMsg& operator<<(T_REAL16 *arg);
Remarks:
Insert a REAL16_ARRAY field into a message.
C API:
TipcMsgAppendReal16Array
  
 
Syntax: 
virtual TipcMsg& operator<<(T_STR arg);
Remarks:
Insert a STR field into a message.
C API:
TipcMsgAppendStr
  
 
Syntax: 
virtual TipcMsg& operator<<(T_STR *arg);
Remarks:
Insert a STR_ARRAY field into a message.
C API:
TipcMsgAppendStrArray
  
 
Syntax: 
virtual TipcMsg& operator<<(T_XML *arg);
Remarks:
Insert an XML field into a message.
C API:
TipcMsgAppendXml

TipcMsg::operator>>

Syntax: 
virtual TipcMsg& operator>>(T_PTR& arg);
Remarks:
Extract a BINARY data field from a message.
C API:
TipcMsgNextBinary
  
 
Syntax: 
virtual TipcMsg& operator>>(T_CHAR& arg);
Remarks:
Extract a CHAR field from a message.
C API:
TipcMsgNextChar
  
 
Syntax: 
virtual TipcMsg& operator>>(T_INT2& arg);
Remarks:
Extract an INT2 field from a message.
C API:
TipcMsgNextInt2
  
 
Syntax: 
virtual TipcMsg& operator>>(T_INT2*& arg);
Remarks:
Extract an INT2_ARRAY field from a message.
C API:
TipcMsgNextInt2Array
  
 
Syntax: 
virtual TipcMsg& operator>>(T_INT4& arg);
Remarks:
Extract an INT4 field from a message.
C API:
TipcMsgNextInt4
  
 
Syntax: 
virtual TipcMsg& operator>>(T_INT4*& arg);
Remarks:
Extract an INT4_ARRAY field from a message.
C API:
TipcMsgNextInt4Array
  
 
Syntax: 
virtual TipcMsg& operator>>(T_INT8& arg);
Remarks:
Extract an INT8 field from a message.
C API:
TipcMsgNextInt8
  
 
Syntax: 
virtual TipcMsg& operator>>(T_INT8*& arg);
Remarks:
Extract an INT8_ARRAY field from a message.
C API:
TipcMsgNextInt8Array
  
 
Syntax: 
virtual TipcMsg& operator>>(TipcMsg& arg);
Remarks:
Extract a T_IPC_MSG field from a message and assign it to the TipcMsg object argument of the operator.
C API:
TipcMsgNextMsg
  
 
Syntax: 
virtual TipcMsg& operator>>(TipcMsg*& arg);
Remarks:
Extract a MSG_ARRAY field from a message and assign each element of the array to an element of a TipcMsg object array.
C API:
TipcMsgNextMsgArray
  
 
Syntax: 
virtual TipcMsg& operator>>(T_REAL4& arg);
Remarks:
Extract a REAL4 field from a message.
C API:
TipcMsgNextReal4
  
 
Syntax: 
virtual TipcMsg& operator>>(T_REAL4*& arg);
Remarks:
Extract a REAL4_ARRAY field from a message.
C API:
TipcMsgNextReal4Array
  
 
Syntax: 
virtual TipcMsg& operator>>(T_REAL8& arg);
Remarks:
Extract a REAL8 field from a message.
C API:
TipcMsgNextReal8
  
 
Syntax: 
virtual TipcMsg& operator>>(T_REAL8*& arg);
Remarks:
Extract a REAL8_ARRAY field from a message.
C API:
TipcMsgNextStrArray
  
 
Syntax: 
virtual TipcMsg& operator>>(T_REAL16& arg);
Remarks:
Extract a REAL16 field from a message.
C API:
TipcMsgNextReal16
  
 
Syntax: 
virtual TipcMsg& operator>>(T_REAL16*& arg);
Remarks:
Extract a REAL16_ARRAY field from a message.
C API:
TipcMsgNextReal16Array
  
 
Syntax: 
virtual TipcMsg& operator>>(T_STR& arg);
Remarks:
Extract a STR field from a message.
C API:
TipcMsgNextStr
  
 
Syntax: 
virtual TipcMsg& operator>>(T_STR*& arg);
Remarks:
Extract a STR_ARRAY field from a message.
C API:
TipcMsgNextStrArray
  
 
Syntax: 
virtual TipcMsg& operator>>(T_XML*& arg);
Remarks:
Extract an XML field from a message.
C API:
TipcMsgNextXml

Manipulators

TipcMsg::Check

Syntax: 
TipcMsg& Check(TipcMsg& msg);
Remarks:
Data fields can be inserted into or extracted from a TipcMsg object by chaining insertion (operator<<) and extraction (operator>>) operators. If any particular insertion or extraction operator fails, a problem flag is set inside the TipcMsg object to indicate that an error has occurred. The problem flag stays set until it is reset using TipcMsg::CheckReset(). When the Check manipulator is used in a function chain, it sets the Tobj::_status flag of the TipcMsg object to FALSE whenever the problem flag is set. Likewise, if the problem flag is unset, then the Check manipulator sets the object’s Tobj::_status flag to TRUE.
After the Check manipulator has been invoked, normal methods of accessing an object’s status can be employed.

Parameterized Manipulators

TipcMsg::GetSize

Syntax: 
TipcMsgManip GetSize(T_INT4 *size_return);
Remarks:
This manipulator returns the size of an array or binary data previously extracted using the TipcMsg extraction operator (operator>>). The size is returned in size_return.

TipcMsg::SetSize

Syntax: 
TipcMsgManip SetSize(T_INT4 size);
Remarks:
This manipulator informs the TipcMsg object of the size of the next array or binary data to be inserted into the object.

Static Public Member Functions

TipcMsg::FieldSize

Syntax: 
static T_BOOL FieldSize(T_IPC_MSG_FIELD field, T_INT4 size);
Remarks:
Set the size of a message field.
C API:
TipcMsgFieldSetSize

TipcMsg::UpdatePtr

Syntax: 
T_BOOL UpdatePtr(T_IPC_MSG_FIELD field, T_PTR binary_data, 
                 T_INT4 array_size);
Remarks:
Update the pointer of the MSG field returned by TipcMsgAppendBinaryPtr.
C API:
TipcMsgFieldUpdateBinaryPtr
  
 
Syntax: 
T_BOOL UpdateBoolPtr(T_IPC_MSG_FIELD field, T_BOOL *bool_array,  
                    T_INT4 array_size);
Remarks:
Update the pointer of the MSG field returned by TipcMsgAppendBoolArrayPtr.
C API:
TipMsgFieldUpdateBoolArrayPtr
  
 
Syntax: 
T_BOOL UpdatePtr(T_IPC_MSG_FIELD field, T_INT2 *int2_array, 
                 T_INT4 array_size);
Remarks:
Update the pointer of the MSG field returned by TipcMsgAppendInt2ArrayPtr.
C API:
TipMsgFieldUpdateInt2ArrayPtr
  
 
Syntax: 
T_BOOL UpdatePtr(T_IPC_MSG_FIELD field, T_INT4 *int4_array, 
                 T_INT4 array_size);
Remarks:
Update the pointer of the MSG field returned by TipcMsgAppendInt4ArrayPtr.
C API:
TipMsgFieldUpdateInt4ArrayPtr
  
 
Syntax: 
T_BOOL UpdatePtr(T_IPC_MSG_FIELD field, T_INT8 *int8_array, 
                 T_INT4 array_size);
Remarks:
Update the pointer of the MSG field returned by TipcMsgAppendInt8ArrayPtr.
C API:
TipMsgFieldUpdateInt8ArrayPtr
  
 
Syntax: 
T_BOOL UpdatePtr(T_IPC_MSG_FIELD field, T_REAL4 *real4_array, 
                 T_INT4 array_size);
Remarks:
Update the pointer of the MSG field returned by TipcMsgAppendReal4ArrayPtr.
C API:
TipMsgFieldUpdateReal4ArrayPtr
  
 
Syntax: 
T_BOOL UpdatePtr(T_IPC_MSG_FIELD field, T_REAL8 *real8_array, 
                 T_INT4 array_size);
Remarks:
Update the pointer of the MSG field returned by TipcMsgAppendReal8ArrayPtr.
C API:
TipMsgFieldUpdateReal8ArrayPtr
  
 
Syntax: 
T_BOOL UpdatePtr(T_IPC_MSG_FIELD field,  
                 T_REAL16 *real16_array, 
                 T_INT4 array_size);
Remarks:
Update the pointer of the MSG field returned by TipcMsgAppendReal16ArrayPtr.
C API:
TipMsgFieldUpdateReal16ArrayPtr
  
 
Syntax: 
T_BOOL UpdatePtr(T_IPC_MSG_FIELD field, T_STR *str_array_data, 
                 T_INT4 array_size);
Remarks:
Update the pointer of the MSG field returned by TipcMsgAppendStrArrayPtr.
C API:
TipMsgFieldUpdateStrArrayPtr
  
 
Syntax: 
T_BOOL UpdatePtr(T_IPC_MSG_FIELD field, T_STR str_data);
Remarks:
Update the pointer of the MSG field returned by TipcMsgAppendStrPtr.
C API:
TipMsgFieldUpdateStrPtr
  
 
Syntax: 
T_BOOL UpdatePtr(T_IPC_MSG_FIELD field,  
                 T_IPC_MSG *msg_array_data, 
                 T_INT4 array_size);
Remarks:
Update the pointer of the MSG field returned by TipcMsgAppendMsgArrayPtr.
C API:
TipMsgFieldUpdateMsgArrayPtr
  
 
Syntax: 
T_BOOL UpdatePtr(T_IPC_MSG_FIELD field, T_IPC_MSG msg_data);
Remarks:
Update the pointer of the MSG field returned by TipcMsgAppendMsgPtr.
C API:
TipMsgFieldUpdateMsgPtr
  
 
Syntax: 
T_BOOL UpdatePtrUtf8(T_IPC_MSG_FIELD field,  
                     T_STR *utf8_array_data, 
                     T_INT4 array_size);
Remarks:
Update the pointer of the MSG field returned by TipcMsgAppendUtf8ArrayPtr.
C API:
TipcMsgFieldUpdateUtf8ArrayPtr
  
 
Syntax: 
T_BOOL UpdatePtrUtf8(T_IPC_MSG_FIELD field, T_STR utf8_data);
Remarks:
Update the pointer of the MSG field returned by TipcMsgAppendUtf8Ptr.
C API:
TipcMsgFieldUpdateUtf8Ptr
  
 
Syntax: 
T_BOOL UpdatePtr(T_IPC_MSG_FIELD field, T_XML xml_data);
Remarks:
Update the pointer of the MSG field returned by TipcMsgAppendXmlPtr.
C API:
TipcMsgFieldUpdateXmlPtr

TipcMsg::FtToStr

Syntax: 
static T_BOOL FtToStr(T_IPC_FT type, T_STR *str_return);
Remarks:
Convert a field type to a string.
C API:
TipcFtToStr

TipcMsg::LbModeToStr

Syntax: 
static T_BOOL LbModeToStr(T_IPC_LB_MODE lb_mode,  
                          T_STR *str_return);
Remarks:
Convert a load balancing mode to a string for printing.
C API:
TipcLbModeToStr

TipcMsg::DeliveryModeToStr

Syntax: 
static T_BOOL DeliveryModeToStr(T_IPC_DELIVERY_MODE delivery_mode, 
                                T_STR *delivery_mode_str_return);
Remarks:
Convert a delivery mode to a string.
C API:
TipcDeliveryModeToStr

TipcMsg::StrToFt

Syntax: 
static T_BOOL StrToFt(T_STR str, T_IPC_FT *ft_return);
Remarks:
Convert a string to a field type.
C API:
TipcStrToFt

TipcMsg::StrToLbMode

Syntax: 
static T_BOOL StrToLbMode(T_STR str,  
                          T_IPC_LB_MODE *lb_mode_return);
Remarks:
Convert a string into a load balancing mode.
C API:
TipcStrToLbMode

TipcMsg::StrToDeliveryMode

Syntax: 
static T_BOOL StrToDeliveryMode(T_STR delivery_str, 
                                T_IPC_DELIVERY_MODE 
                                *deliv_mode_return);
Remarks:
Convert a string to a delivery mode.
C API:
TipcStrToDeliveryMode

Protected Member Functions

TipcMsg::size

Syntax: 
T_INT4 size() const;
Remarks:
Get the _size field of the TipcMsg object used to insert or extract array and BINARY data fields.
  
 
Syntax: 
void size(T_INT4 size_arg);
Remarks:
Set the _size field of the TipcMsg object used to insert or extract array and BINARY data fields.

Example

This code fragment shows how to construct a NUMERIC_DATA message, set some of its values, and then access this data: 

#include <rtworks/cxxipc.hxx> 
 
int main() 
{ 
  cout << "Create the message." << endl; 
  TipcMsg msg(T_MT_NUMERIC_DATA); 
  if (!msg) { 
    // error 
  } 
  cout << "Set the message properties." << endl; 
  msg.Sender("_conan"); 
  if (!msg) { 
    // error 
  } 
 
  msg.Dest("thermal"); 
  if (!msg) { 
    // error 
  } 
 
  msg.Priority(2); 
  if (!msg) { 
    // error 
  } 
   
  cout << "Append fields." << endl; 
  msg << "voltage" << (T_REAL8)33.4534 
      << "switch_pos" << (T_REAL8)0.0 << Check; 
 
  if (!msg) { 
    // error 
  } 
 
  cout << "Access fields." << endl; 
 
  msg.Current(0); 
  if (!msg) { 
    // error 
  } 
    T_STR str_val; 
  msg >> str_val; 
  if (!msg) { 
    // error 
  } 
  T_REAL8 real8_val; 
  msg >> real8_val; 
  if (!msg) { 
    // error 
  } 
  cout << str_val << " = " << real8_val << endl; 
    msg >> str_val; 
  if (!msg) { 
    // error 
  } 
  msg >> real8_val; 
  if (!msg) { 
    // error 
  } 
 
  cout << str_val << " = " << real8_val << endl; 
  cout << "Destroy the message." << endl; 
 
  return T_EXIT_SUCCESS; //  all done    
 //  main
TIBCO SmartSockets™ cxxipc Class Library
Software Release 6.8, July 2006
Copyright © TIBCO Software Inc. All rights reserved
www.tibco.com