ACE_Message_Queue
).
#include <ace/Message_Block.h>
class ACE_Message_Block {
public:
friend class ACE_Data_Block;
enum ACE_Message_Type{ MB_DATA = 0x01, MB_PROTO = 0x02, MB_BREAK = 0x03, MB_PASSFP = 0x04, MB_EVENT = 0x05, MB_SIG = 0x06, MB_IOCTL = 0x07, MB_SETOPTS = 0x08, MB_IOCACK = 0x81, MB_IOCNAK = 0x82, MB_PCPROTO = 0x83, MB_PCSIG = 0x84, MB_READ = 0x85, MB_FLUSH = 0x86, MB_STOP = 0x87, MB_START = 0x88, MB_HANGUP = 0x89, MB_ERROR = 0x8a, MB_PCEVENT = 0x8b, MB_NORMAL = 0x00, MB_PRIORITY = 0x80, MB_USER = 0x200 };typedef u_long Message_Flags;
enum{ DONT_DELETE = 01, USER_FLAGS = 0x1000 };
ACE_Message_Block (void);
ACE_Message_Block (ACE_Data_Block *);
ACE_Message_Block (const char *data, size_t size = 0);
ACE_Message_Block ( size_t size, ACE_Message_Type type = MB_DATA, ACE_Message_Block *cont = 0, const char *data = 0, ACE_Allocator *allocator_strategy = 0, ACE_Lock *locking_strategy = 0, u_long priority = 0 );
int init (const char *data, size_t size = 0);
int init ( size_t size, ACE_Message_Type type = MB_DATA, ACE_Message_Block *cont = 0, const char *data = 0, ACE_Allocator *allocator_strategy = 0, ACE_Lock *locking_strategy = 0, u_long priority = 0 );
virtual ~ACE_Message_Block (void);
ACE_Message_Type msg_type (void) const;
void msg_type (ACE_Message_Type type);
int is_data_msg (void) const;
ACE_Message_Type msg_class (void) const;
Message_Flags set_flags (Message_Flags more_flags);
Message_Flags clr_flags (Message_Flags less_flags);
Message_Flags flags (void) const;
u_long msg_priority (void) const;
void msg_priority (u_long priority);
virtual ACE_Message_Block *clone (Message_Flags mask = 0) const;
ACE_Message_Block *duplicate (void) const;
static ACE_Message_Block *duplicate (ACE_Message_Block *mb);
ACE_Message_Block *release (void);
static ACE_Message_Block *release (ACE_Message_Block *mb);
int copy (const char *buf, size_t n);
int copy (const char *buf);
char *base (void) const;
void base (char *data, size_t size, Message_Flags = DONT_DELETE);
char *end (void) const;
char *rd_ptr (void);
void rd_ptr (char *ptr);
void rd_ptr (size_t n);
char *wr_ptr (void);
void wr_ptr (char *ptr);
void wr_ptr (size_t n);
size_t length (void) const;
void length (size_t n);
size_t size (void) const;
int size (size_t length);
ACE_Data_Block *data_block (void) const;
void data_block (ACE_Data_Block *);
ACE_Message_Block *cont (void) const;
void cont (ACE_Message_Block *);
ACE_Message_Block *next (void) const;
void next (ACE_Message_Block *);
ACE_Message_Block *prev (void) const;
void prev (ACE_Message_Block *);
ACE_Lock *locking_strategy (void);
ACE_Lock *locking_strategy (ACE_Lock *);
void dump (void) const;
ACE_ALLOC_HOOK_DECLARE;
private:
ACE_Message_Block ( size_t size, ACE_Message_Type type, ACE_Message_Block *cont, const char *data, ACE_Allocator *allocator_strategy, ACE_Lock *locking_strategy, Message_Flags flags, u_long priority, ACE_Data_Block *db );
ACE_Message_Block *release_i (ACE_Lock *lock);
int init_i ( size_t size, ACE_Message_Type type, ACE_Message_Block *cont, const char *data, ACE_Allocator *allocator_strategy, ACE_Lock *locking_strategy, Message_Flags flags, u_long priority, ACE_Data_Block *db );
char *rd_ptr_;
char *wr_ptr_;
u_long priority_;
ACE_Message_Block *cont_;
ACE_Message_Block *next_;
ACE_Message_Block *prev_;
ACE_Data_Block *data_block_;
ACE_Message_Block &operator= (const ACE_Message_Block &);
ACE_Message_Block (const ACE_Message_Block &);
};
ACE_Message_Block
is modeled after the message data
structures used in System V STREAMS. Its purpose is to
enable efficient manipulation of arbitrarily-large messages
without much incurring memory copying overhead. Here are the
main characteristics of an ACE_Message_Block
:
1. Contains a pointer to a reference-counted
ACE_Data_Block
, which in turn points to the actual data
buffer. This allows very flexible and efficient sharing of
data by multiple ACE_Message_Block
s.
2. One or more ACE_Message_Blocks
can be linked to form a
``fragment chain.''
3. ACE_Message_Blocks
can be linked together by prev_
and
next_
pointers to form a queue of messages (e.g., this is how
ACE_Message_Queue
works).
ACE_Message_Block (void);
ACE_Message_Block (ACE_Data_Block *);
ACE_Message_Block
that owns the ACE_Data_Block
*.
ACE_Message_Block (const char *data, size_t size = 0);
data
without
copying it (i.e., we don't delete it since we don't malloc it!).
Note that the size
of the Message_Block
will be size
, but
the length
will be 0 until wr_ptr
is set.
ACE_Message_Block (
size_t size,
ACE_Message_Type type = MB_DATA,
ACE_Message_Block *cont = 0,
const char *data = 0,
ACE_Allocator *allocator_strategy = 0,
ACE_Lock *locking_strategy = 0,
u_long priority = 0
);
type
containing size
bytes. The cont
argument initializes the continuation field in
the Message_Block
. If data
== 0 then we create and own the
data
, using allocator
to get the data if it's non-0. If
data
!= 0 we assume ownership of the data
(and don't delete
it). If locking_strategy
is non-0 then this is used to protect
regions of code that access shared state (e.g., reference
counting) from race conditions. Note that the size
of the
Message_Block
will be size
, but the length
will be 0 until
wr_ptr
is set.
int init (const char *data, size_t size = 0);
data
(i.e.,
doesn't delete it since it didn't malloc it!). Note that the
size
of the Message_Block
will be size
, but the length
will be 0 until wr_ptr
is set.
int init (
size_t size,
ACE_Message_Type type = MB_DATA,
ACE_Message_Block *cont = 0,
const char *data = 0,
ACE_Allocator *allocator_strategy = 0,
ACE_Lock *locking_strategy = 0,
u_long priority = 0
);
type
containing size
bytes. The cont
argument initializes the continuation field in
the Message_Block
. If data
== 0 then we create and own the
data
, using allocator
to get the data if it's non-0. If
data
!= 0 we assume ownership of the data
(and don't delete
it). If locking_strategy
is non-0 then this is used to protect
regions of code that access shared state (e.g., reference
counting) from race conditions. Note that the size
of the
Message_Block
will be size
, but the length
will be 0 until
wr_ptr
is set.
virtual ~ACE_Message_Block (void);
ACE_Message_Type msg_type (void) const;
void msg_type (ACE_Message_Type type);
int is_data_msg (void) const;
ACE_Message_Type msg_class (void) const;
normal
messages and high-priority
messages).
Message_Flags set_flags (Message_Flags more_flags);
more_flags
into the existing message flags and
return the new value.
Message_Flags clr_flags (Message_Flags less_flags);
less_flags
and return
the new value.
Message_Flags flags (void) const;
u_long msg_priority (void) const;
void msg_priority (u_long priority);
virtual ACE_Message_Block *clone (Message_Flags mask = 0) const;
ACE_Message_Block *duplicate (void) const;
static ACE_Message_Block *duplicate (ACE_Message_Block *mb);
_duplicate
method, which is useful
if you want to eliminate lots of checks for NULL mb
pointers
before calling _duplicate
on them.
ACE_Message_Block *release (void);
static ACE_Message_Block *release (ACE_Message_Block *mb);
release
, except that it
checks if mb
is 0. This is similar to CORBA::release
, which
is useful if you want to eliminate lots of checks for NULL
pointers before calling release
on them. Returns mb
.
int copy (const char *buf, size_t n);
n
bytes from buf
into the Message_Block starting at
the wr_ptr() offset. Return 0 if succeeds and -1 if the size of
the message is too small...
int copy (const char *buf);
buf
into the Message_Block starting at the wr_ptr()
offset. This call assumees that buf
is NUL-terminated. Return
0 if succeeds and -1 if the size of the message is too small...
char *base (void) const;
void base (char *data, size_t size, Message_Flags = DONT_DELETE);
char *end (void) const;
char *rd_ptr (void);
void rd_ptr (char *ptr);
ptr
.
void rd_ptr (size_t n);
n
bytes.
char *wr_ptr (void);
void wr_ptr (char *ptr);
ptr
.
void wr_ptr (size_t n);
n
bytes. This is used to compute
the length
of a message.
size_t length (void) const;
void length (size_t n);
size_t size (void) const;
int size (size_t length);
rd_ptr_
and wr_ptr_
remain at the
original offsets into the buffer, even if it is reallocated.
Returns 0 if successful, else -1.
= ACE_Data_Block
methods.
ACE_Data_Block *data_block (void) const;
void data_block (ACE_Data_Block *);
ACE_Message_Block *cont (void) const;
void cont (ACE_Message_Block *);
= Pointer to the Message_Block
directly ahead in the ACE_Message_Queue
.
ACE_Message_Block *next (void) const;
void next (ACE_Message_Block *);
= Pointer to the Message_Block
directly behind in the ACE_Message_Queue
.
ACE_Message_Block *prev (void) const;
void prev (ACE_Message_Block *);
ACE_Lock *locking_strategy (void);
ACE_Lock *locking_strategy (ACE_Lock *);
void dump (void) const;
ACE_ALLOC_HOOK_DECLARE;
ACE_Message_Block (
size_t size,
ACE_Message_Type type,
ACE_Message_Block *cont,
const char *data,
ACE_Allocator *allocator_strategy,
ACE_Lock *locking_strategy,
Message_Flags flags,
u_long priority,
ACE_Data_Block *db
);
ACE_Message_Block *release_i (ACE_Lock *lock);
int init_i (
size_t size,
ACE_Message_Type type,
ACE_Message_Block *cont,
const char *data,
ACE_Allocator *allocator_strategy,
ACE_Lock *locking_strategy,
Message_Flags flags,
u_long priority,
ACE_Data_Block *db
);
char *rd_ptr_;
char *wr_ptr_;
u_long priority_;
ACE_Message_Block *cont_;
ACE_Message_Block *next_;
ACE_Message_Block *prev_;
ACE_Data_Block *data_block_;
= Disallow these operations for now (use clone
instead).
ACE_Message_Block &operator= (const ACE_Message_Block &);
ACE_Message_Block (const ACE_Message_Block &);