i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

* made the dano and r5 message more similar to use (naming).

Browse Source 
* coding style changes to structure naming.
* but no bug fixes yet...


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@15055 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Axel Dörfler
2005-11-20 22:24:03 +00:00
parent 5232a619c1
commit e489029756
7 changed files with 397 additions and 367 deletions
Download Patch File Download Diff File Expand all files Collapse all files
headers/os/app/Message4.h
+38 -43
View File
@@ -5,7 +5,6 @@
* Authors: * Authors:
* Michael Lotz <[email protected]> * Michael Lotz <[email protected]>
*/ */
#ifndef _MESSAGE_H #ifndef _MESSAGE_H
#define _MESSAGE_H #define _MESSAGE_H
@@ -23,13 +22,10 @@
#include <AppDefs.h> /* For convenience */ #include <AppDefs.h> /* For convenience */
#include <TypeConstants.h> /* For convenience */ #include <TypeConstants.h> /* For convenience */
class BBlockCache; class BBlockCache;
class BMessenger; class BMessenger;
class BHandler; class BHandler;
class BString; class BString;
struct message_header_s;
struct field_header_s;
// Private or reserved --------------------------------------------------------- // Private or reserved ---------------------------------------------------------
extern "C" void _msg_cache_cleanup_(); extern "C" void _msg_cache_cleanup_();
@@ -37,7 +33,6 @@ extern "C" int _init_message_();
extern "C" int _delete_message_(); extern "C" int _delete_message_();
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// Name lengths and Scripting specifiers --------------------------------------- // Name lengths and Scripting specifiers ---------------------------------------
#define B_FIELD_NAME_LENGTH 255 #define B_FIELD_NAME_LENGTH 255
#define B_PROPERTY_NAME_LENGTH 255 #define B_PROPERTY_NAME_LENGTH 255
@@ -55,18 +50,15 @@ enum {
B_SPECIFIERS_END = 128 B_SPECIFIERS_END = 128
// app-defined specifiers start at B_SPECIFIERS_END + 1 // app-defined specifiers start at B_SPECIFIERS_END + 1
}; };
//------------------------------------------------------------------------------
class BMessage { class BMessage {
public:
public:
uint32 what; uint32 what;
BMessage(); BMessage();
BMessage(uint32 what); BMessage(uint32 what);
BMessage(const BMessage &other); BMessage(const BMessage &other);
virtual ~BMessage(); virtual ~BMessage();
BMessage &operator=(const BMessage &other); BMessage &operator=(const BMessage &other);
@@ -265,11 +257,13 @@ virtual ~BMessage();
float FindFloat(const char *, int32 n = 0) const; float FindFloat(const char *, int32 n = 0) const;
double FindDouble(const char *, int32 n = 0) const; double FindDouble(const char *, int32 n = 0) const;
class Private; class Private;
struct message_header;
struct field_header;
private: private:
friend class Private; friend class Private;
friend class BMessageQueue; friend class BMessageQueue;
status_t _InitCommon(); status_t _InitCommon();
status_t _InitHeader(); status_t _InitHeader();
@@ -277,54 +271,55 @@ friend class BMessageQueue;
status_t _ResizeData(int32 offset, int32 change); status_t _ResizeData(int32 offset, int32 change);
uint32 _HashName(const char *name) const; uint32 _HashName(const char* name) const;
status_t _FindField(const char *name, type_code type, status_t _FindField(const char* name, type_code type,
field_header_s **result) const; field_header** _result) const;
status_t _AddField(const char *name, type_code type, status_t _AddField(const char* name, type_code type,
bool isFixedSize, field_header_s **result); bool isFixedSize, field_header** _result);
status_t _RemoveField(field_header_s *field); status_t _RemoveField(field_header* field);
ssize_t _NativeFlattenedSize() const; ssize_t _NativeFlattenedSize() const;
status_t _NativeFlatten(char *buffer, ssize_t size) const; status_t _NativeFlatten(char *buffer, ssize_t size) const;
status_t _NativeFlatten(BDataIO *stream, ssize_t *size = NULL) const; status_t _NativeFlatten(BDataIO *stream, ssize_t *size = NULL) const;
message_header_s*fHeader; private:
field_header_s *fFields; message_header* fHeader;
uint8 *fData; field_header* fFields;
uint8* fData;
mutable BMessage *fOriginal; mutable BMessage* fOriginal;
// fQueueLink is used by BMessageQueue to build a linked list BMessage* fQueueLink;
BMessage *fQueueLink; // fQueueLink is used by BMessageQueue to build a linked list
uint32 fReserved[11]; uint32 fReserved[11];
// deprecated // deprecated
BMessage(BMessage *a_message); BMessage(BMessage *message);
virtual void _ReservedMessage1(); virtual void _ReservedMessage1();
virtual void _ReservedMessage2(); virtual void _ReservedMessage2();
virtual void _ReservedMessage3(); virtual void _ReservedMessage3();
status_t _SendMessage(port_id port, int32 token, bigtime_t timeout, status_t _SendMessage(port_id port, int32 token, bigtime_t timeout,
bool replyRequired, BMessenger &replyTo) const; bool replyRequired, BMessenger &replyTo) const;
status_t _SendMessage(port_id port, team_id portOwner, status_t _SendMessage(port_id port, team_id portOwner,
int32 token, BMessage *reply, bigtime_t sendTimeout, int32 token, BMessage *reply, bigtime_t sendTimeout,
bigtime_t replyTimeout) const; bigtime_t replyTimeout) const;
static status_t _SendFlattenedMessage(void *data, int32 size, static status_t _SendFlattenedMessage(void *data, int32 size,
port_id port, int32 token, bigtime_t timeout); port_id port, int32 token, bigtime_t timeout);
static void _StaticInit(); static void _StaticInit();
static void _StaticCleanup(); static void _StaticCleanup();
static void _StaticCacheCleanup(); static void _StaticCacheCleanup();
static int32 _StaticGetCachedReplyPort(); static int32 _StaticGetCachedReplyPort();
enum { sNumReplyPorts = 3 }; enum { sNumReplyPorts = 3 };
static port_id sReplyPorts[sNumReplyPorts]; static port_id sReplyPorts[sNumReplyPorts];
static long sReplyPortInUse[sNumReplyPorts]; static long sReplyPortInUse[sNumReplyPorts];
static int32 sGetCachedReplyPort(); static int32 sGetCachedReplyPort();
static BBlockCache *sMsgCache; static BBlockCache* sMsgCache;
}; };
#endif // _MESSAGE_H #endif // _MESSAGE_H
headers/private/app/MessagePrivate4.h
+23 -23
View File
@@ -37,40 +37,40 @@ enum {
}; };
typedef struct field_header_s { struct BMessage::field_header {
uint32 flags; uint32 flags;
type_code type; type_code type;
int32 nameLength; int32 name_length;
int32 count; int32 count;
ssize_t dataSize; ssize_t data_size;
ssize_t allocated; ssize_t allocated;
int32 offset; int32 offset;
int32 nextField; int32 next_field;
} FieldHeader; };
typedef struct message_header_s { struct BMessage::message_header {
uint32 format; uint32 format;
uint32 what; uint32 what;
uint32 flags; uint32 flags;
ssize_t fieldsSize; ssize_t fields_size;
ssize_t dataSize; ssize_t data_size;
ssize_t fieldsAvailable; ssize_t fields_available;
ssize_t dataAvailable; ssize_t data_available;
int32 target; int32 target;
int32 currentSpecifier; int32 current_specifier;
// reply info // reply info
port_id replyPort; port_id reply_port;
int32 replyTarget; int32 reply_target;
team_id replyTeam; team_id reply_team;
// body info // body info
int32 fieldCount; int32 field_count;
int32 hashTableSize; int32 hash_table_size;
int32 hashTable[MESSAGE_BODY_HASH_TABLE_SIZE]; int32 hash_table[MESSAGE_BODY_HASH_TABLE_SIZE];
/* The hash table does contain indexes into the field list and /* The hash table does contain indexes into the field list and
not direct offsets to the fields. This has the advantage not direct offsets to the fields. This has the advantage
@@ -78,7 +78,7 @@ typedef struct message_header_s {
The hash table must be reevaluated when we remove a field The hash table must be reevaluated when we remove a field
though. though.
*/ */
} MessageHeader; };
class BMessage::Private { class BMessage::Private {
@@ -103,9 +103,9 @@ class BMessage::Private {
SetReply(BMessenger messenger) SetReply(BMessenger messenger)
{ {
BMessenger::Private messengerPrivate(messenger); BMessenger::Private messengerPrivate(messenger);
fMessage->fHeader->replyPort = messengerPrivate.Port(); fMessage->fHeader->reply_port = messengerPrivate.Port();
fMessage->fHeader->replyTarget = messengerPrivate.Token(); fMessage->fHeader->reply_target = messengerPrivate.Token();
fMessage->fHeader->replyTeam = messengerPrivate.Team(); fMessage->fHeader->reply_team = messengerPrivate.Team();
} }
int32 int32
@@ -132,13 +132,13 @@ class BMessage::Private {
return fMessage->_InitHeader(); return fMessage->_InitHeader();
} }
MessageHeader* BMessage::message_header*
GetMessageHeader() GetMessageHeader()
{ {
return fMessage->fHeader; return fMessage->fHeader;
} }
FieldHeader* BMessage::field_header*
GetMessageFields() GetMessageFields()
{ {
return fMessage->fFields; return fMessage->fFields;
src/kits/app/Message4.cpp
+236 -235
View File
File diff suppressed because it is too large Load Diff
src/kits/app/dano_message.cpp
+1 -1
View File
@@ -80,7 +80,7 @@ pad_to_8(int32 value)
ssize_t ssize_t
BPrivate::dano_message_size(const char *buffer) BPrivate::dano_message_flattened_size(const char *buffer)
{ {
section_header *header = (section_header *)buffer; section_header *header = (section_header *)buffer;
src/kits/app/dano_message.h
+16 -2
View File
@@ -1,11 +1,25 @@
/*
* Copyright 2005, Haiku.
* Distributed under the terms of the MIT License.
*
* Authors:
* Axel Dörfler, axeld@pinc-software.de
*/
#ifndef DANO_MESSAGE_H
#define DANO_MESSAGE_H
#include <SupportDefs.h> #include <SupportDefs.h>
class BMessage; class BMessage;
class BDataIO; class BDataIO;
namespace BPrivate { namespace BPrivate {
status_t unflatten_dano_message(uint32 magic, BDataIO& stream, BMessage& message);
ssize_t dano_message_size(const char* buffer); status_t unflatten_dano_message(uint32 magic, BDataIO& stream, BMessage& message);
ssize_t dano_message_flattened_size(const char* buffer);
} }
#endif // DANO_MESSAGE_H
src/kits/app/r5_message.cpp
+66 -57
View File
@@ -1,3 +1,10 @@
/*
* Copyright 2005, Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Michael Lotz <mmlr@mlotz.ch>
*/
#ifdef USING_MESSAGE4 #ifdef USING_MESSAGE4
#include <DataIO.h> #include <DataIO.h>
@@ -22,13 +29,13 @@ static const uint32 kR5MessageMagic = 'FOB1';
static const uint32 kR5MessageMagicSwapped = '1BOF'; static const uint32 kR5MessageMagicSwapped = '1BOF';
typedef struct r5_message_header_s { struct r5_message_header {
uint32 magic; // kR5MessageMagic uint32 magic; // kR5MessageMagic
uint32 checksum; uint32 checksum;
ssize_t flattenedSize; ssize_t flattened_size;
int32 what; int32 what;
uint8 flags; uint8 flags;
} _PACKED R5MessageHeader; } _PACKED;
inline int32 inline int32
@@ -39,52 +46,54 @@ pad_to_8(int32 value)
ssize_t ssize_t
R5MessageFlattenedSize(const BMessage *message) r5_message_flattened_size(const BMessage *message)
{ {
BMessage::Private messagePrivate((BMessage *)message); BMessage::Private messagePrivate((BMessage *)message);
MessageHeader *header = messagePrivate.GetMessageHeader(); BMessage::message_header* header = messagePrivate.GetMessageHeader();
ssize_t flattenedSize = sizeof(R5MessageHeader);
// header size (variable, depending on the flags)
ssize_t flattenedSize = sizeof(r5_message_header);
if (header->target != B_NULL_TOKEN) if (header->target != B_NULL_TOKEN)
flattenedSize += sizeof(int32); flattenedSize += sizeof(int32);
if (header->replyPort >= 0 && header->replyTarget != B_NULL_TOKEN if (header->reply_port >= 0 && header->reply_target != B_NULL_TOKEN
&& header->replyTeam >= 0) { && header->reply_team >= 0) {
// reply info + big flags
// reply info flattenedSize += sizeof(port_id) + sizeof(int32) + sizeof(team_id) + 4;
flattenedSize += sizeof(port_id) + sizeof(int32) + sizeof(team_id);
// big flags
flattenedSize += 4;
} }
// field size
uint8 *data = messagePrivate.GetMessageData(); uint8 *data = messagePrivate.GetMessageData();
FieldHeader *field = messagePrivate.GetMessageFields(); BMessage::field_header* field = messagePrivate.GetMessageFields();
for (int32 i = 0; i < header->fieldCount; i++, field++) { for (int32 i = 0; i < header->field_count; i++, field++) {
// flags and type // flags and type
flattenedSize += 1 + sizeof(type_code); flattenedSize += 1 + sizeof(type_code);
// item count
#if 0 #if 0
bool miniData = field->dataSize <= 255 && field->count <= 255; bool miniData = field->dataSize <= 255 && field->count <= 255;
#else #else
// ToDo: we don't know the R5 dataSize yet (padding) // ToDo: we don't know the R5 dataSize yet (padding)
bool miniData = false; bool miniData = false;
#endif #endif
// item count
if (field->count > 1) if (field->count > 1)
flattenedSize += (miniData ? sizeof(uint8) : sizeof(int32)); flattenedSize += (miniData ? sizeof(uint8) : sizeof(uint32));
// data size // data size
flattenedSize += (miniData ? sizeof(uint8) : sizeof(ssize_t)); flattenedSize += (miniData ? sizeof(uint8) : sizeof(size_t));
// name length and name // name length and name
flattenedSize += 1 + min_c(field->nameLength - 1, 255); flattenedSize += 1 + min_c(field->name_length - 1, 255);
// data // data
if (field->flags & FIELD_FLAG_FIXED_SIZE) if (field->flags & FIELD_FLAG_FIXED_SIZE)
flattenedSize += field->dataSize; flattenedSize += field->data_size;
else { else {
uint8 *source = data + field->offset + field->nameLength; uint8 *source = data + field->offset + field->name_length;
for (int32 i = 0; i < field->count; i++) { for (int32 i = 0; i < field->count; i++) {
ssize_t itemSize = *(ssize_t *)source + sizeof(ssize_t); ssize_t itemSize = *(ssize_t *)source + sizeof(ssize_t);
@@ -100,14 +109,14 @@ R5MessageFlattenedSize(const BMessage *message)
status_t status_t
R5MessageFlatten(const BMessage *message, char *buffer, ssize_t size) flatten_r5_message(const BMessage *message, char *buffer, ssize_t size)
{ {
BMessage::Private messagePrivate((BMessage *)message); BMessage::Private messagePrivate((BMessage *)message);
MessageHeader *header = messagePrivate.GetMessageHeader(); BMessage::message_header* header = messagePrivate.GetMessageHeader();
uint8 *data = messagePrivate.GetMessageData(); uint8* data = messagePrivate.GetMessageData();
R5MessageHeader *r5header = (R5MessageHeader *)buffer; r5_message_header* r5header = (r5_message_header *)buffer;
uint8 *pointer = (uint8 *)buffer + sizeof(R5MessageHeader); uint8* pointer = (uint8 *)buffer + sizeof(r5_message_header);
r5header->magic = kR5MessageMagic; r5header->magic = kR5MessageMagic;
r5header->what = message->what; r5header->what = message->what;
@@ -120,18 +129,18 @@ R5MessageFlatten(const BMessage *message, char *buffer, ssize_t size)
flags |= R5_MESSAGE_FLAG_INCLUDE_TARGET; flags |= R5_MESSAGE_FLAG_INCLUDE_TARGET;
} }
if (header->replyPort >= 0 && header->replyTarget != B_NULL_TOKEN if (header->reply_port >= 0 && header->reply_target != B_NULL_TOKEN
&& header->replyTeam >= 0) { && header->reply_team >= 0) {
// reply info // reply info
*(port_id *)pointer = header->replyPort; *(port_id *)pointer = header->reply_port;
pointer += sizeof(port_id); pointer += sizeof(port_id);
*(int32 *)pointer = header->replyTarget; *(int32 *)pointer = header->reply_target;
pointer += sizeof(int32); pointer += sizeof(int32);
*(team_id *)pointer = header->replyTeam; *(team_id *)pointer = header->reply_team;
pointer += sizeof(team_id); pointer += sizeof(team_id);
// big flags // big flags
*pointer = (header->replyTarget == B_PREFERRED_TOKEN ? 1 : 0); *pointer = (header->reply_target == B_PREFERRED_TOKEN ? 1 : 0);
pointer++; pointer++;
*pointer = (header->flags & MESSAGE_FLAG_REPLY_REQUIRED ? 1 : 0); *pointer = (header->flags & MESSAGE_FLAG_REPLY_REQUIRED ? 1 : 0);
@@ -155,14 +164,14 @@ R5MessageFlatten(const BMessage *message, char *buffer, ssize_t size)
ssize_t headerSize = (uint32)pointer - (uint32)buffer; ssize_t headerSize = (uint32)pointer - (uint32)buffer;
// collect and add the data // collect and add the data
FieldHeader *field = messagePrivate.GetMessageFields(); BMessage::field_header* field = messagePrivate.GetMessageFields();
for (int32 i = 0; i < header->fieldCount; i++, field++) { for (int32 i = 0; i < header->field_count; i++, field++) {
flags = R5_FIELD_FLAG_VALID; flags = R5_FIELD_FLAG_VALID;
if (field->count == 1) if (field->count == 1)
flags |= R5_FIELD_FLAG_SINGLE_ITEM; flags |= R5_FIELD_FLAG_SINGLE_ITEM;
// ToDo: we don't really know the data size now (padding missing) // ToDo: we don't really know the data size now (padding missing)
if (field->dataSize <= 255 && field->count <= 255) if (field->data_size <= 255 && field->count <= 255)
;//flags |= R5_FIELD_FLAG_MINI_DATA; ;//flags |= R5_FIELD_FLAG_MINI_DATA;
if (field->flags & FIELD_FLAG_FIXED_SIZE) if (field->flags & FIELD_FLAG_FIXED_SIZE)
flags |= R5_FIELD_FLAG_FIXED_SIZE; flags |= R5_FIELD_FLAG_FIXED_SIZE;
@@ -186,15 +195,15 @@ R5MessageFlatten(const BMessage *message, char *buffer, ssize_t size)
// we may have to adjust this to account for padding later // we may have to adjust this to account for padding later
uint8 *fieldSize = pointer; uint8 *fieldSize = pointer;
if (flags & R5_FIELD_FLAG_MINI_DATA) { if (flags & R5_FIELD_FLAG_MINI_DATA) {
*pointer = (uint8)field->dataSize; *pointer = (uint8)field->data_size;
pointer++; pointer++;
} else { } else {
*(ssize_t *)pointer = field->dataSize; *(ssize_t *)pointer = field->data_size;
pointer += sizeof(ssize_t); pointer += sizeof(ssize_t);
} }
// name // name
int32 nameLength = min_c(field->nameLength - 1, 255); int32 nameLength = min_c(field->name_length - 1, 255);
*pointer = (uint8)nameLength; *pointer = (uint8)nameLength;
pointer++; pointer++;
@@ -202,10 +211,10 @@ R5MessageFlatten(const BMessage *message, char *buffer, ssize_t size)
pointer += nameLength; pointer += nameLength;
// data // data
uint8 *source = data + field->offset + field->nameLength; uint8 *source = data + field->offset + field->name_length;
if (flags & R5_FIELD_FLAG_FIXED_SIZE) { if (flags & R5_FIELD_FLAG_FIXED_SIZE) {
memcpy(pointer, source, field->dataSize); memcpy(pointer, source, field->data_size);
pointer += field->dataSize; pointer += field->data_size;
} else { } else {
uint8 *previous = pointer; uint8 *previous = pointer;
for (int32 i = 0; i < field->count; i++) { for (int32 i = 0; i < field->count; i++) {
@@ -228,7 +237,7 @@ R5MessageFlatten(const BMessage *message, char *buffer, ssize_t size)
pointer++; pointer++;
// calculate the flattened size from the pointers // calculate the flattened size from the pointers
r5header->flattenedSize = (uint32)pointer - (uint32)buffer; r5header->flattened_size = (uint32)pointer - (uint32)buffer;
r5header->checksum = BPrivate::CalculateChecksum((uint8 *)(buffer + 8), r5header->checksum = BPrivate::CalculateChecksum((uint8 *)(buffer + 8),
headerSize - 8); headerSize - 8);
return B_OK; return B_OK;
@@ -236,15 +245,15 @@ R5MessageFlatten(const BMessage *message, char *buffer, ssize_t size)
status_t status_t
R5MessageFlatten(const BMessage *message, BDataIO *stream, ssize_t *_size) flatten_r5_message(const BMessage *message, BDataIO *stream, ssize_t *_size)
{ {
// ToDo: This is not very cheap... // ToDo: This is not very cheap...
ssize_t size = R5MessageFlattenedSize(message); ssize_t size = r5_message_flattened_size(message);
char *buffer = (char *)malloc(size); char *buffer = (char *)malloc(size);
if (!buffer) if (!buffer)
return B_NO_MEMORY; return B_NO_MEMORY;
status_t result = R5MessageFlatten(message, buffer, size); status_t result = flatten_r5_message(message, buffer, size);
if (result < B_OK) { if (result < B_OK) {
free(buffer); free(buffer);
return result; return result;
@@ -265,23 +274,23 @@ R5MessageFlatten(const BMessage *message, BDataIO *stream, ssize_t *_size)
status_t status_t
R5MessageUnflatten(BMessage *message, const char *flatBuffer) unflatten_r5_message(BMessage *message, const char *flatBuffer)
{ {
R5MessageHeader *r5header = (R5MessageHeader *)flatBuffer; r5_message_header *r5header = (r5_message_header *)flatBuffer;
BMemoryIO stream(flatBuffer + 4, r5header->flattenedSize - 4); BMemoryIO stream(flatBuffer + 4, r5header->flattened_size - 4);
return R5MessageUnflatten(message, &stream); return unflatten_r5_message(message, &stream);
} }
status_t status_t
R5MessageUnflatten(BMessage *message, BDataIO *stream) unflatten_r5_message(BMessage *message, BDataIO *stream)
{ {
TReadHelper reader(stream); TReadHelper reader(stream);
BMessage::Private messagePrivate(message); BMessage::Private messagePrivate(message);
MessageHeader *header = messagePrivate.GetMessageHeader(); BMessage::message_header *header = messagePrivate.GetMessageHeader();
// the stream is already advanced by the size of the "format" // the stream is already advanced by the size of the "format"
R5MessageHeader r5header; r5_message_header r5header;
reader(((uint8 *)&r5header) + sizeof(uint32), reader(((uint8 *)&r5header) + sizeof(uint32),
sizeof(r5header) - sizeof(uint32)); sizeof(r5header) - sizeof(uint32));
@@ -294,15 +303,15 @@ R5MessageUnflatten(BMessage *message, BDataIO *stream)
if (r5header.flags & R5_MESSAGE_FLAG_INCLUDE_REPLY) { if (r5header.flags & R5_MESSAGE_FLAG_INCLUDE_REPLY) {
// reply info // reply info
reader(header->replyPort); reader(header->reply_port);
reader(header->replyTarget); reader(header->reply_target);
reader(header->replyTeam); reader(header->reply_team);
// big flags // big flags
uint8 bigFlag; uint8 bigFlag;
reader(bigFlag); reader(bigFlag);
if (bigFlag) if (bigFlag)
header->replyTarget = B_PREFERRED_TOKEN; header->reply_target = B_PREFERRED_TOKEN;
reader(bigFlag); reader(bigFlag);
if (bigFlag) if (bigFlag)
src/kits/app/r5_message.h
+17 -6
View File
@@ -1,17 +1,28 @@
/*
* Copyright 2005, Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Michael Lotz <mmlr@mlotz.ch>
*/
#ifndef _R5_MESSAGE_H_ #ifndef _R5_MESSAGE_H_
#define _R5_MESSAGE_H_ #define _R5_MESSAGE_H_
#include <sys/types.h>
class BMessage; class BMessage;
class BDataIO; class BDataIO;
namespace BPrivate { namespace BPrivate {
ssize_t R5MessageFlattenedSize(const BMessage *message); ssize_t r5_message_flattened_size(const BMessage *message);
status_t R5MessageFlatten(const BMessage *message, char *buffer, ssize_t size); status_t flatten_r5_message(const BMessage *message, char *buffer, ssize_t size);
status_t R5MessageFlatten(const BMessage *message, BDataIO *stream, ssize_t *size); status_t flatten_r5_message(const BMessage *message, BDataIO *stream, ssize_t *size);
status_t R5MessageUnflatten(BMessage *message, const char *flatBuffer); status_t unflatten_r5_message(BMessage *message, const char *flatBuffer);
status_t R5MessageUnflatten(BMessage *message, BDataIO *stream); status_t unflatten_r5_message(BMessage *message, BDataIO *stream);
} }
#endif #endif // _R5_MESSAGE_H_