class TMessage: public TBufferFile

 Create a TMessage object for storing objects. The "what" integer
 describes the type of message. Predifined ROOT system message types
 can be found in MessageTypes.h. Make sure your own message types are
 unique from the ROOT defined message types (i.e. 0 - 10000 are
 reserved by ROOT). In case you OR "what" with kMESS_ACK, the message
 will wait for an acknowledgement from the remote side. This makes
 the sending process synchronous. In case you OR "what" with kMESS_ZIP,
 the message will be compressed in TSocket using the zip algorithm
 (only if message is > 256 bytes).

 Create a TMessage object for reading objects. The objects will be
 read from buf. Use the What() method to get the message type.

 Clean up compression buffer.

 Static function enabling or disabling the automatic schema evolution.
 By default schema evolution support is off.

 Static function returning status of global schema evolution.

 Force writing the TStreamerInfo to the message.

 Change a buffer that was received into one that can be send, i.e.
 forward a just received message.

 Remember that the StreamerInfo is being used in writing.

 Reset the message buffer so we can use (i.e. fill) it again.

 Set the message length at the beginning of the message buffer.
 This method is only called by TSocket::Send().

 Using this method one can change the message type a-posteriory.
 In case you OR "what" with kMESS_ACK, the message will wait for
 an acknowledgement from the remote side. This makes the sending
 process synchronous.

 Compress the message. The message will only be compressed if the
 compression level > 0 and the if the message is > 256 bytes.
 Returns -1 in case of error (when compression fails or
 when the message increases in size in some pathological cases),
 otherwise returns 0.

 Uncompress the message. The message will only be uncompressed when
 kMESS_ZIP is set. Returns -1 in case of error, 0 otherwise.

 Write object to message buffer.
 When support for schema evolution is enabled the list of TStreamerInfo
 used to stream this object is kept in fInfos. This information is used
 by TSocket::Send that sends this list through the socket. This list is in
 turn used by TSocket::Recv to store the TStreamerInfo objects in the
 relevant TClass in case the TClass does not know yet about a particular
 class version. This feature is implemented to support clients and servers
 with either different ROOT versions or different user classes versions.

 Check if the ProcessID pid is already in the message.
 If not, then:
   - mark bit 0 of fBitsPIDs to indicate that a ProcessID has been found
   - mark bit uid+1 where uid id the uid of the ProcessID

 TMessage objects cannot be copied or assigned

 used by friend TSocket