mirror of
https://review.haiku-os.org/haiku
synced 2025-02-15 18:18:57 +01:00
80a604c999
git-svn-id: file:///srv/svn/repos/haiku/trunk/current@503 a95241bf-73f2-0310-859d-f6bbb57e9c96
1500 lines
47 KiB
C++
1500 lines
47 KiB
C++
|
|
// Standard Includes -----------------------------------------------------------
|
|
|
|
// System Includes -------------------------------------------------------------
|
|
#include <Message.h>
|
|
#include <Messenger.h>
|
|
#include <Errors.h>
|
|
|
|
#include <CRTDBG.H>
|
|
|
|
// Project Includes ------------------------------------------------------------
|
|
|
|
// Local Includes --------------------------------------------------------------
|
|
|
|
// Local Defines ---------------------------------------------------------------
|
|
|
|
// Globals ---------------------------------------------------------------------
|
|
void _msg_cache_cleanup_()
|
|
{
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
BMessage *_reconstruct_msg_(uint32,uint32,uint32)
|
|
{
|
|
return NULL;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
void _set_message_target_(BMessage *msg, int32 target, bool preferred)
|
|
{
|
|
if (preferred)
|
|
{
|
|
msg->fTarget = -1;
|
|
msg->fPreferred = true;
|
|
}
|
|
else
|
|
{
|
|
msg->fTarget = target;
|
|
msg->fPreferred = false;
|
|
}
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
void _set_message_reply_(BMessage *msg, BMessenger messenger)
|
|
{
|
|
msg->fReplyTo.port = messenger.fPort;
|
|
msg->fReplyTo.target = messenger.fHandlerToken;
|
|
msg->fReplyTo.team = messenger.fTeam;
|
|
msg->fReplyTo.preferred = messenger.fPreferredTarget;
|
|
msg->fReplyRequired = true;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
int32 _get_message_target_(BMessage *msg)
|
|
{
|
|
if (msg->fPreferred)
|
|
return -1;
|
|
else
|
|
return msg->fTarget;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
bool _use_preferred_target_(BMessage *msg)
|
|
{
|
|
return msg->fPreferred;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
BMessage::BMessage(uint32 command)
|
|
{
|
|
init_data();
|
|
|
|
what = command;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
BMessage::BMessage(const BMessage &message)
|
|
{
|
|
*this = message;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
BMessage::BMessage()
|
|
{
|
|
init_data();
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
BMessage::~BMessage ()
|
|
{
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
BMessage &BMessage::operator=(const BMessage &message)
|
|
{
|
|
what = message.what;
|
|
|
|
link = message.link;
|
|
fTarget = message.fTarget;
|
|
fOriginal = message.fOriginal;
|
|
fChangeCount = message.fChangeCount;
|
|
fCurSpecifier = message.fCurSpecifier;
|
|
fPtrOffset = message.fPtrOffset;
|
|
|
|
fEntries = NULL;
|
|
|
|
entry_hdr *src_entry;
|
|
|
|
for ( src_entry = message.fEntries; src_entry != NULL; src_entry = src_entry->fNext )
|
|
{
|
|
entry_hdr* new_entry = (entry_hdr*)new char[da_total_logical_size ( src_entry )];
|
|
|
|
if ( new_entry != NULL )
|
|
{
|
|
memcpy ( new_entry, src_entry, da_total_logical_size ( src_entry ) );
|
|
|
|
new_entry->fNext = fEntries;
|
|
new_entry->fPhysicalBytes = src_entry->fLogicalBytes;
|
|
|
|
fEntries = new_entry;
|
|
}
|
|
}
|
|
|
|
fReplyTo.port = message.fReplyTo.port;
|
|
fReplyTo.target = message.fReplyTo.target;
|
|
fReplyTo.team = message.fReplyTo.team;
|
|
fReplyTo.preferred = message.fReplyTo.preferred;
|
|
|
|
fPreferred = message.fPreferred;
|
|
fReplyRequired = message.fReplyRequired;
|
|
fReplyDone = message.fReplyDone;
|
|
fIsReply = message.fIsReply;
|
|
fWasDelivered = message.fWasDelivered;
|
|
fReadOnly = message.fReadOnly;
|
|
fHasSpecifiers = message.fHasSpecifiers;
|
|
|
|
return *this;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::GetInfo(const char *name, type_code *typeFound,
|
|
int32 *countFound) const
|
|
{
|
|
for(entry_hdr *entry = fEntries; entry != NULL; entry = entry->fNext)
|
|
{
|
|
if (entry->fNameLength == strlen(name) &&
|
|
strncmp(entry->fName, name, entry->fNameLength) == 0)
|
|
{
|
|
if (typeFound)
|
|
*typeFound = entry->fType;
|
|
|
|
if (countFound)
|
|
*countFound = entry->fCount;
|
|
|
|
return B_OK;
|
|
}
|
|
}
|
|
|
|
return B_NAME_NOT_FOUND;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::GetInfo(const char *name, type_code *typeFound, bool *fixedSize) const
|
|
{
|
|
return B_ERROR;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::GetInfo(type_code type, int32 index, char **nameFound, type_code *typeFound,
|
|
int32 *countFound) const
|
|
{
|
|
return B_ERROR;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
int32 BMessage::CountNames(type_code type) const
|
|
{
|
|
return -1;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
//bool BMessage::IsEmpty () const;
|
|
//------------------------------------------------------------------------------
|
|
//bool BMessage::IsSystem () const;
|
|
//------------------------------------------------------------------------------
|
|
bool BMessage::IsReply() const
|
|
{
|
|
return fIsReply;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
void BMessage::PrintToStream() const
|
|
{
|
|
char name[256];
|
|
|
|
for (entry_hdr *entry = fEntries; entry != NULL; entry = entry->fNext)
|
|
{
|
|
memcpy(name, entry->fName, entry->fNameLength);
|
|
name[entry->fNameLength] = 0;
|
|
|
|
printf("#entry %s, type = %c%c%c%c, count = %d\n", name,
|
|
(entry->fType & 0xFF000000) >> 24, (entry->fType & 0x00FF0000) >> 16,
|
|
(entry->fType & 0x0000FF00) >> 8, entry->fType & 0x000000FF, entry->fCount);
|
|
|
|
((BMessage*)this)->da_dump((dyn_array*)entry);
|
|
}
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::Rename(const char *old_entry, const char *new_entry);
|
|
//------------------------------------------------------------------------------
|
|
//------------------------------------------------------------------------------
|
|
bool BMessage::WasDelivered () const
|
|
{
|
|
return fWasDelivered;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
//bool BMessage::IsSourceWaiting() const;
|
|
//------------------------------------------------------------------------------
|
|
//bool BMessage::IsSourceRemote() const;
|
|
//------------------------------------------------------------------------------
|
|
BMessenger BMessage::ReturnAddress() const
|
|
{
|
|
return BMessenger(fReplyTo.team, fReplyTo.port, fReplyTo.target,
|
|
fReplyTo.preferred);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
const BMessage *BMessage::Previous () const
|
|
{
|
|
return fOriginal;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
bool BMessage::WasDropped () const
|
|
{
|
|
if (GetInfo("_drop_point_", NULL, (int32*)NULL) == B_OK)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
BPoint BMessage::DropPoint(BPoint *offset) const
|
|
{
|
|
BPoint point;
|
|
|
|
FindPoint("_drop_point_", &point);
|
|
|
|
if (offset)
|
|
FindPoint("_drop_offset_", offset);
|
|
|
|
return point;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::SendReply(uint32 command, BHandler *reply_to)
|
|
{
|
|
return B_ERROR;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::SendReply(BMessage *the_reply, BHandler *reply_to,
|
|
bigtime_t timeout)
|
|
{
|
|
return B_ERROR;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::SendReply(BMessage *the_reply, BMessenger reply_to,
|
|
bigtime_t timeout)
|
|
{
|
|
return B_ERROR;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::SendReply(uint32 command, BMessage *reply_to_reply)
|
|
{
|
|
return B_ERROR;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::SendReply(BMessage *the_reply, BMessage *reply_to_reply,
|
|
bigtime_t send_timeout,
|
|
bigtime_t reply_timeout)
|
|
{
|
|
return B_ERROR;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
size_t BMessage::FlattenedSize() const
|
|
{
|
|
size_t size = 7 * sizeof(int32);
|
|
|
|
for (entry_hdr *entry = fEntries; entry != NULL; entry = entry->fNext)
|
|
size += da_total_logical_size(entry);
|
|
|
|
return size;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::Flatten(char *address, size_t numBytes) const
|
|
{
|
|
if (numBytes != NULL && numBytes < FlattenedSize())
|
|
return B_NO_MEMORY;
|
|
|
|
int position = 7 * sizeof(int32);
|
|
|
|
((int32*)address)[1] = what;
|
|
((int32*)address)[2] = fCurSpecifier;
|
|
((int32*)address)[3] = fHasSpecifiers;
|
|
((int32*)address)[4] = 0;
|
|
((int32*)address)[5] = 0;
|
|
((int32*)address)[6] = 0;
|
|
|
|
for (entry_hdr *entry = fEntries; entry != NULL; entry = entry->fNext)
|
|
{
|
|
memcpy(address + position, entry, da_total_logical_size(entry));
|
|
|
|
position += da_total_logical_size(entry);
|
|
}
|
|
|
|
((size_t*)address)[0] = position;
|
|
|
|
return B_OK;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::Flatten(BDataIO *object, size_t *numBytes) const
|
|
{
|
|
if (numBytes != NULL && *numBytes < FlattenedSize())
|
|
return B_NO_MEMORY;
|
|
|
|
int32 size = FlattenedSize();
|
|
char *buffer = new char[size];
|
|
|
|
Flatten(buffer, size);
|
|
|
|
object->Write(buffer, size);
|
|
|
|
delete buffer;
|
|
|
|
return B_OK;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::Unflatten(const char *address)
|
|
{
|
|
size_t size;
|
|
|
|
MakeEmpty();
|
|
|
|
size = ((size_t*)address)[0];
|
|
what = ((int32*)address)[1];
|
|
fCurSpecifier = ((int32*)address)[2];
|
|
fHasSpecifiers = ((int32*)address)[3];
|
|
|
|
size_t position = 7 * sizeof(int32);
|
|
|
|
while (position < size)
|
|
{
|
|
entry_hdr* src_entry = (entry_hdr*)&address[position];
|
|
entry_hdr* new_entry = (entry_hdr*)new char[da_total_logical_size ( src_entry )];
|
|
|
|
if (new_entry != NULL)
|
|
{
|
|
memcpy(new_entry, src_entry, da_total_logical_size(src_entry));
|
|
|
|
new_entry->fNext = fEntries;
|
|
new_entry->fPhysicalBytes = src_entry->fLogicalBytes;
|
|
position += da_total_logical_size(src_entry);
|
|
|
|
fEntries = new_entry;
|
|
}
|
|
else
|
|
return B_NO_MEMORY;
|
|
}
|
|
|
|
if (position != size)
|
|
{
|
|
MakeEmpty();
|
|
return B_BAD_VALUE;
|
|
}
|
|
|
|
return B_OK;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::Unflatten(BDataIO *object)
|
|
{
|
|
size_t size;
|
|
|
|
object->Read(&size, sizeof(int32));
|
|
|
|
char *buffer = new char[size];
|
|
|
|
*(int32*)buffer = size;
|
|
|
|
object->Read(buffer + sizeof(int32), size - sizeof(int32));
|
|
|
|
status_t status = Unflatten(buffer);
|
|
|
|
delete[] buffer;
|
|
|
|
return status;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::AddSpecifier(const char *property)
|
|
{
|
|
BMessage message(B_DIRECT_SPECIFIER);
|
|
message.AddString("property", property);
|
|
|
|
fCurSpecifier ++;
|
|
fHasSpecifiers = true;
|
|
|
|
return AddMessage("specifiers", &message);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::AddSpecifier(const char *property, int32 index)
|
|
{
|
|
BMessage message(B_INDEX_SPECIFIER);
|
|
message.AddString("property", property);
|
|
message.AddInt32("index", index);
|
|
|
|
fCurSpecifier++;
|
|
fHasSpecifiers = true;
|
|
|
|
return AddMessage("specifiers", &message);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::AddSpecifier(const char *property, int32 index, int32 range)
|
|
{
|
|
BMessage message(B_RANGE_SPECIFIER);
|
|
message.AddString("property", property);
|
|
message.AddInt32("index", index);
|
|
message.AddInt32("range", range);
|
|
|
|
fCurSpecifier ++;
|
|
fHasSpecifiers = true;
|
|
|
|
return AddMessage("specifiers", &message);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::AddSpecifier(const char *property, const char *name)
|
|
{
|
|
BMessage message(B_NAME_SPECIFIER);
|
|
message.AddString("property", property);
|
|
message.AddString("name", name);
|
|
|
|
fCurSpecifier ++;
|
|
fHasSpecifiers = true;
|
|
|
|
return AddMessage("specifiers", &message);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::AddSpecifier(const BMessage *message);
|
|
//------------------------------------------------------------------------------
|
|
status_t SetCurrentSpecifier(int32 index)
|
|
{
|
|
return B_ERROR;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::GetCurrentSpecifier(int32 *index, BMessage *specifier,
|
|
int32 *what, const char **property) const
|
|
{
|
|
if (fCurSpecifier == -1)
|
|
return B_BAD_SCRIPT_SYNTAX;
|
|
|
|
if (index)
|
|
*index = fCurSpecifier;
|
|
|
|
if (specifier)
|
|
{
|
|
FindMessage("specifiers", fCurSpecifier, specifier);
|
|
|
|
if (what)
|
|
*what = specifier->what;
|
|
|
|
if (property)
|
|
specifier->FindString("property", property);
|
|
}
|
|
|
|
return B_OK;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
bool BMessage::HasSpecifiers() const
|
|
{
|
|
return fHasSpecifiers;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::PopSpecifier()
|
|
{
|
|
if (fCurSpecifier)
|
|
{
|
|
fCurSpecifier--;
|
|
return B_OK;
|
|
}
|
|
else
|
|
return B_BAD_VALUE;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::AddRect(const char *name, BRect rect)
|
|
{
|
|
return AddData(name, B_RECT_TYPE, &rect, sizeof(BRect), true);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::AddPoint(const char *name, BPoint point)
|
|
{
|
|
return AddData(name, B_POINT_TYPE, &point, sizeof(BPoint), true);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::AddString(const char *name, const char *string)
|
|
{
|
|
return AddData(name, B_STRING_TYPE, string, strlen(string) + 1, false);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::AddString(const char *name, const CString &string);
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::AddInt8(const char *name, int8 anInt8)
|
|
{
|
|
return AddData(name, B_INT8_TYPE, &anInt8, sizeof(int8));
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::AddInt16(const char *name, int16 anInt16)
|
|
{
|
|
return AddData(name, B_INT16_TYPE, &anInt16, sizeof(int16));
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::AddInt32(const char *name, int32 anInt32)
|
|
{
|
|
return AddData(name, B_INT32_TYPE, &anInt32, sizeof(int32));
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::AddInt64(const char *name, int64 anInt64)
|
|
{
|
|
return AddData(name, B_INT64_TYPE, &anInt64, sizeof(int64));
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::AddBool(const char *name, bool aBool)
|
|
{
|
|
return AddData(name, B_BOOL_TYPE, &aBool, sizeof(bool));
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::AddFloat ( const char *name, float aFloat)
|
|
{
|
|
return AddData(name, B_FLOAT_TYPE, &aFloat, sizeof(float));
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::AddDouble ( const char *name, double aDouble)
|
|
{
|
|
return AddData(name, B_DOUBLE_TYPE, &aDouble, sizeof(double));
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::AddPointer(const char *name, const void *pointer)
|
|
{
|
|
return AddData(name, B_POINTER_TYPE, &pointer, sizeof(void*), true);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::AddMessenger(const char *name, BMessenger messenger)
|
|
{
|
|
return B_OK;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::AddRef(const char *name, const entry_ref *ref);
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::AddMessage(const char *name, const BMessage *message)
|
|
{
|
|
int32 size = message->FlattenedSize();
|
|
char *buffer = new char[size];
|
|
|
|
message->Flatten (buffer, size);
|
|
|
|
return AddData(name, B_MESSAGE_TYPE, buffer, size, false);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::AddFlat(const char *name, BFlattenable *object,
|
|
int32 numItems)
|
|
{
|
|
int32 size = object->FlattenedSize ();
|
|
char *buffer = new char[size];
|
|
|
|
object->Flatten(buffer, size);
|
|
|
|
return AddData(name, object->TypeCode(), buffer, size,
|
|
object->IsFixedSize(), numItems);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::AddData(const char *name, type_code type, const void *data,
|
|
size_t numBytes, bool fixedSize, int32 numItems)
|
|
{
|
|
entry_hdr *entry = entry_find(name, type);
|
|
|
|
if (entry == NULL)
|
|
{
|
|
if ( strlen(name) > 255)
|
|
return B_BAD_VALUE;
|
|
|
|
entry = (entry_hdr*)da_create(sizeof(entry_hdr) - sizeof(dyn_array) +
|
|
strlen(name), numBytes, fixedSize, numItems);
|
|
|
|
entry->fNext = fEntries;
|
|
entry->fType = type;
|
|
entry->fNameLength = strlen(name);
|
|
memcpy(entry->fName, name, entry->fNameLength);
|
|
|
|
fEntries = entry;
|
|
}
|
|
|
|
return da_add_data((dyn_array**)&entry, data, numBytes);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::RemoveData(const char *name, int32 index);
|
|
//status_t BMessage::RemoveName(const char *name);
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::MakeEmpty()
|
|
{
|
|
entry_hdr *entry;
|
|
|
|
while(entry = fEntries)
|
|
{
|
|
fEntries = entry->fNext;
|
|
delete entry;
|
|
}
|
|
|
|
return B_OK;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::FindRect(const char *name, BRect *rect) const
|
|
{
|
|
entry_hdr *entry = entry_find(name, B_RECT_TYPE);
|
|
|
|
if (entry == NULL)
|
|
return B_NAME_NOT_FOUND;
|
|
|
|
*rect = *(BRect*)da_first_chunk(entry);
|
|
|
|
return B_OK;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::FindRect(const char *name, int32 index, BRect *rect) const
|
|
{
|
|
entry_hdr *entry = entry_find(name, B_RECT_TYPE);
|
|
|
|
if (entry == NULL)
|
|
return B_NAME_NOT_FOUND;
|
|
|
|
if (index < entry->fCount)
|
|
{
|
|
BRect* data = (BRect*)da_first_chunk(entry);
|
|
*rect = data[index];
|
|
|
|
return B_OK;
|
|
}
|
|
|
|
return B_BAD_INDEX;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::FindPoint(const char *name, BPoint *point) const
|
|
{
|
|
entry_hdr *entry = entry_find(name, B_POINT_TYPE);
|
|
|
|
if (entry == NULL)
|
|
return B_NAME_NOT_FOUND;
|
|
|
|
*point = *(BPoint*)da_first_chunk(entry);
|
|
|
|
return B_OK;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::FindPoint(const char *name, int32 index, BPoint *point) const
|
|
{
|
|
entry_hdr *entry = entry_find(name, B_POINT_TYPE);
|
|
|
|
if (entry == NULL)
|
|
return B_NAME_NOT_FOUND;
|
|
|
|
if (index < entry->fCount)
|
|
{
|
|
BPoint* data = (BPoint*)da_first_chunk(entry);
|
|
*point = data[index];
|
|
|
|
return B_OK;
|
|
}
|
|
|
|
return B_BAD_INDEX;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::FindString(const char *name, int32 index,
|
|
const char **string) const
|
|
{
|
|
return FindData(name, B_STRING_TYPE, index, (const void**)string, NULL);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::FindString(const char *name, const char **string) const
|
|
{
|
|
return FindData(name, B_STRING_TYPE, (const void**)string, NULL);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::FindString ( const char *name, int32 index,
|
|
//CString *string ) const;
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::FindString ( const char *name, CString *string ) const;
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::FindInt8(const char *name, int8 *anInt8) const
|
|
{
|
|
entry_hdr *entry = entry_find(name, B_INT8_TYPE);
|
|
|
|
if (entry == NULL)
|
|
return B_NAME_NOT_FOUND;
|
|
|
|
*anInt8 = *(int8*)da_first_chunk(entry);
|
|
|
|
return B_OK;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::FindInt8(const char *name, int32 index, int8 *anInt8) const
|
|
{
|
|
entry_hdr *entry = entry_find(name, B_INT8_TYPE);
|
|
|
|
if (entry == NULL)
|
|
return B_NAME_NOT_FOUND;
|
|
|
|
if (index < entry->fCount)
|
|
{
|
|
int8* data = (int8*)da_first_chunk(entry);
|
|
*anInt8 = data[index];
|
|
|
|
return B_OK;
|
|
}
|
|
|
|
return B_BAD_INDEX;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::FindInt16(const char *name, int16 *anInt16) const
|
|
{
|
|
entry_hdr *entry = entry_find(name, B_INT16_TYPE);
|
|
|
|
if (entry == NULL)
|
|
return B_NAME_NOT_FOUND;
|
|
|
|
*anInt16 = *(int16*)da_first_chunk(entry);
|
|
|
|
return B_OK;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::FindInt16(const char *name, int32 index, int16 *anInt16) const
|
|
{
|
|
entry_hdr *entry = entry_find(name, B_INT16_TYPE);
|
|
|
|
if (entry == NULL)
|
|
return B_NAME_NOT_FOUND;
|
|
|
|
if (index < entry->fCount)
|
|
{
|
|
int16* data = (int16*)da_first_chunk(entry);
|
|
*anInt16 = data[index];
|
|
|
|
return B_OK;
|
|
}
|
|
|
|
return B_BAD_INDEX;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::FindInt32(const char *name, int32 *anInt32) const
|
|
{
|
|
entry_hdr *entry = entry_find(name, B_INT32_TYPE);
|
|
|
|
if (entry == NULL)
|
|
return B_NAME_NOT_FOUND;
|
|
|
|
*anInt32 = *(int32*)da_first_chunk(entry);
|
|
|
|
return B_OK;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::FindInt32(const char *name, int32 index,
|
|
int32 *anInt32) const
|
|
{
|
|
entry_hdr *entry = entry_find(name, B_INT32_TYPE);
|
|
|
|
if (entry == NULL)
|
|
return B_NAME_NOT_FOUND;
|
|
|
|
if (index < entry->fCount)
|
|
{
|
|
int32* data = (int32*)da_first_chunk(entry);
|
|
*anInt32 = data[index];
|
|
|
|
return B_OK;
|
|
}
|
|
|
|
return B_BAD_INDEX;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::FindInt64 ( const char *name, int64 *anInt64) const;
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::FindInt64 ( const char *name, int32 index,
|
|
// int64 *anInt64 ) const;
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::FindBool(const char *name, bool *aBool) const
|
|
{
|
|
entry_hdr *entry = entry_find(name, B_BOOL_TYPE);
|
|
|
|
if (entry == NULL)
|
|
return B_NAME_NOT_FOUND;
|
|
|
|
*aBool = *(bool*)da_first_chunk(entry);
|
|
|
|
return B_OK;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::FindBool(const char *name, int32 index, bool *aBool) const
|
|
{
|
|
entry_hdr *entry = entry_find(name, B_BOOL_TYPE);
|
|
|
|
if (entry == NULL)
|
|
return B_NAME_NOT_FOUND;
|
|
|
|
if (index < entry->fCount)
|
|
{
|
|
bool* data = (bool*)da_first_chunk(entry);
|
|
*aBool = data[index];
|
|
|
|
return B_OK;
|
|
}
|
|
|
|
return B_BAD_INDEX;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::FindFloat(const char *name, float *aFloat) const
|
|
{
|
|
entry_hdr *entry = entry_find(name, B_FLOAT_TYPE);
|
|
|
|
if (entry == NULL)
|
|
return B_NAME_NOT_FOUND;
|
|
|
|
*aFloat = *(float*)da_first_chunk(entry);
|
|
|
|
return B_OK;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::FindFloat(const char *name, int32 index, float *aFloat) const
|
|
{
|
|
entry_hdr *entry = entry_find(name, B_FLOAT_TYPE);
|
|
|
|
if (entry == NULL)
|
|
return B_NAME_NOT_FOUND;
|
|
|
|
if (index < entry->fCount)
|
|
{
|
|
float* data = (float*)da_first_chunk(entry);
|
|
*aFloat = data[index];
|
|
|
|
return B_OK;
|
|
}
|
|
|
|
return B_BAD_INDEX;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::FindDouble(const char *name, double *aDouble) const
|
|
{
|
|
entry_hdr *entry = entry_find(name, B_DOUBLE_TYPE);
|
|
|
|
if (entry == NULL)
|
|
return B_NAME_NOT_FOUND;
|
|
|
|
*aDouble = *(double*)da_first_chunk(entry);
|
|
|
|
return B_OK;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::FindDouble(const char *name, int32 index,
|
|
double *aDouble) const
|
|
{
|
|
entry_hdr *entry = entry_find(name, B_DOUBLE_TYPE);
|
|
|
|
if (entry == NULL)
|
|
return B_NAME_NOT_FOUND;
|
|
|
|
if (index < entry->fCount)
|
|
{
|
|
double* data = (double*)da_first_chunk(entry);
|
|
*aDouble = data[index];
|
|
|
|
return B_OK;
|
|
}
|
|
|
|
return B_BAD_INDEX;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::FindPointer(const char *name, void **pointer) const
|
|
{
|
|
entry_hdr *entry = entry_find(name, B_POINTER_TYPE);
|
|
|
|
if (entry == NULL)
|
|
{
|
|
*pointer = NULL;
|
|
return B_NAME_NOT_FOUND;
|
|
}
|
|
|
|
*pointer = *(void**)da_first_chunk(entry);
|
|
|
|
return B_OK;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::FindPointer(const char *name, int32 index,
|
|
void **pointer) const
|
|
{
|
|
entry_hdr *entry = entry_find(name, B_POINTER_TYPE);
|
|
|
|
if (entry == NULL)
|
|
{
|
|
*pointer = NULL;
|
|
return B_NAME_NOT_FOUND;
|
|
}
|
|
|
|
if (index >= entry->fCount)
|
|
{
|
|
*pointer = NULL;
|
|
return B_BAD_INDEX;
|
|
}
|
|
|
|
void** data = (void**)da_first_chunk(entry);
|
|
*pointer = data[index];
|
|
|
|
return B_OK;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::FindMessenger ( const char *name, CMessenger *messenger ) const;
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::FindMessenger ( const char *name, int32 index, CMessenger *messenger ) const;
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::FindRef ( const char *name, entry_ref *ref ) const;
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::FindRef ( const char *name, int32 index, entry_ref *ref ) const;
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::FindMessage(const char *name, BMessage *message) const
|
|
{
|
|
const char *data;
|
|
|
|
if ( FindData(name, B_MESSAGE_TYPE, (const void**)&data, NULL) != B_OK)
|
|
return B_NAME_NOT_FOUND;
|
|
|
|
return message->Unflatten(data);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::FindMessage(const char *name, int32 index,
|
|
BMessage *message) const
|
|
{
|
|
const char *data;
|
|
|
|
if ( FindData(name, B_MESSAGE_TYPE, index, (const void**)&data,
|
|
NULL) != B_OK)
|
|
return B_NAME_NOT_FOUND;
|
|
|
|
return message->Unflatten(data);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::FindFlat(const char *name, BFlattenable *object) const
|
|
{
|
|
status_t ret;
|
|
const void *data;
|
|
size_t numBytes;
|
|
|
|
ret = FindData(name, object->TypeCode (), &data, &numBytes);
|
|
|
|
if ( ret != B_OK )
|
|
return ret;
|
|
|
|
if ( object->Unflatten(object->TypeCode (), data, numBytes) != B_OK)
|
|
return B_BAD_VALUE;
|
|
|
|
return B_OK;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::FindFlat(const char *name, int32 index,
|
|
BFlattenable *object) const
|
|
{
|
|
status_t ret;
|
|
const void *data;
|
|
size_t numBytes;
|
|
|
|
ret = FindData(name, object->TypeCode(), index, &data, &numBytes);
|
|
|
|
if (ret != B_OK)
|
|
return ret;
|
|
|
|
if (object->Unflatten(object->TypeCode(), data, numBytes) != B_OK)
|
|
return B_BAD_VALUE;
|
|
|
|
return B_OK;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::FindData(const char *name, type_code type, const void **data,
|
|
size_t *numBytes) const
|
|
{
|
|
entry_hdr *entry = entry_find(name, type);
|
|
|
|
if (entry == NULL)
|
|
{
|
|
*data = NULL;
|
|
return B_NAME_NOT_FOUND;
|
|
}
|
|
|
|
int32 size;
|
|
|
|
*data = da_find_data(entry, 0, &size);
|
|
|
|
if (numBytes)
|
|
*numBytes = size;
|
|
|
|
return B_OK;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::FindData(const char *name, type_code type, int32 index,
|
|
const void **data, size_t *numBytes) const
|
|
{
|
|
entry_hdr *entry = entry_find(name, type);
|
|
|
|
if (entry == NULL)
|
|
{
|
|
*data = NULL;
|
|
return B_NAME_NOT_FOUND;
|
|
}
|
|
|
|
if (index >= entry->fCount)
|
|
{
|
|
*data = NULL;
|
|
return B_BAD_INDEX;
|
|
}
|
|
|
|
int32 size;
|
|
|
|
*data = da_find_data(entry, index, &size);
|
|
|
|
if (numBytes)
|
|
*numBytes = size;
|
|
|
|
return B_OK;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::ReplaceRect(const char *name, BRect rect);
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::ReplaceRect(const char *name, int32 index, BRect rect);
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::ReplacePoint(const char *name, BPoint point)
|
|
{
|
|
return ReplaceData(name, B_POINT_TYPE, &point, sizeof(BPoint));
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::ReplacePoint(const char *name, int32 index, BPoint point);
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::ReplaceString(const char *name, const char *string)
|
|
{
|
|
return B_ERROR;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::ReplaceString(const char *name, int32 index,
|
|
// const char *string);
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::ReplaceString(const char *name, CString &string);
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::ReplaceString(const char *name, int32 index, CString &string);
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::ReplaceInt8(const char *name, int8 anInt8)
|
|
{
|
|
return ReplaceData(name, B_INT8_TYPE, &anInt8, sizeof(int8));
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::ReplaceInt8(const char *name, int32 index, int8 anInt8);
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::ReplaceInt16(const char *name, int16 anInt16);
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::ReplaceInt16(const char *name, int32 index, int16 anInt16);
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::ReplaceInt32(const char *name, long anInt32)
|
|
{
|
|
return ReplaceData(name, B_INT32_TYPE, &anInt32, sizeof(int32));
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::ReplaceInt32(const char *name, int32 index, int32 anInt32);
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::ReplaceInt64(const char *name, int64 anInt64)
|
|
{
|
|
return ReplaceData(name, B_INT64_TYPE, &anInt64, sizeof(int64));
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::ReplaceInt64(const char *name, int32 index, int64 anInt64);
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::ReplaceBool(const char *name, bool aBool);
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::ReplaceBool(const char *name, int32 index, bool aBool);
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::ReplaceFloat(const char *name, float aFloat);
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::ReplaceFloat(const char *name, int32 index, float aFloat);
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::ReplaceDouble(const char *name, double aDouble);
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::ReplaceDouble(const char *name, int32 index, double aDouble);
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::ReplacePointer(const char *name, const void *pointer);
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::ReplacePointer(const char *name, int32 index,
|
|
// const void *pointer);
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::ReplaceMessenger(const char *name, BMessenger messenger);
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::ReplaceMessenger(const char *name, int32 index,
|
|
// BMessenger messenger);
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::ReplaceRef(const char *name, entry_ref *ref);
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::ReplaceRef(const char *name, int32 index, entry_ref *ref);
|
|
//------------------------------------------------------------------------------
|
|
//status_t ReplaceMessage(const char *name, const BMessage *msg);
|
|
//------------------------------------------------------------------------------
|
|
//status_t ReplaceMessage(const char *name, int32 index, const BMessage *msg);
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::ReplaceFlat(const char *name, BFlattenable *object);
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::ReplaceFlat(const char *name, int32 index,
|
|
// BFlattenable *object);
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::ReplaceData(const char *name, type_code type,
|
|
const void *data, size_t numBytes)
|
|
{
|
|
entry_hdr *entry = entry_find(name, type);
|
|
|
|
if (entry == NULL)
|
|
return B_NAME_NOT_FOUND;
|
|
|
|
if (entry->fType != type)
|
|
return B_BAD_TYPE;
|
|
|
|
da_replace_data((dyn_array**)&entry, 0, data, numBytes);
|
|
|
|
return B_OK;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
//status_t BMessage::ReplaceData(const char *name, type_code type, int32 index,
|
|
// const void *data, size_t numBytes);
|
|
//------------------------------------------------------------------------------
|
|
//void *BMessage::operator new(size_t numBytes);
|
|
//------------------------------------------------------------------------------
|
|
//void BMessage::operator delete(void *memory, size_t numBytes);
|
|
//------------------------------------------------------------------------------
|
|
/*bool HasRect(const char *, int32 n = 0) const;
|
|
bool HasPoint(const char *, int32 n = 0) const;
|
|
bool HasString(const char *, int32 n = 0) const;
|
|
bool HasInt8(const char *, int32 n = 0) const;
|
|
bool HasInt16(const char *, int32 n = 0) const;
|
|
bool HasInt32(const char *, int32 n = 0) const;
|
|
bool HasInt64(const char *, int32 n = 0) const;
|
|
bool HasBool(const char *, int32 n = 0) const;
|
|
bool HasFloat(const char *, int32 n = 0) const;
|
|
bool HasDouble(const char *, int32 n = 0) const;
|
|
bool HasPointer(const char *, int32 n = 0) const;
|
|
bool HasMessenger(const char *, int32 n = 0) const;
|
|
bool HasRef(const char *, int32 n = 0) const;
|
|
bool HasMessage(const char *, int32 n = 0) const;
|
|
bool HasFlat(const char *, const BFlattenable *) const;
|
|
bool HasFlat(const char *,int32 ,const BFlattenable *) const;
|
|
bool HasData(const char *, type_code , int32 n = 0) const;
|
|
BRect FindRect(const char *, int32 n = 0) const;
|
|
BPoint FindPoint(const char *, int32 n = 0) const;
|
|
const char *FindString(const char *, int32 n = 0) const;
|
|
int8 FindInt8(const char *, int32 n = 0) const;
|
|
int16 FindInt16(const char *, int32 n = 0) const;*/
|
|
//------------------------------------------------------------------------------
|
|
int32 BMessage::FindInt32(const char *name, int32 index) const
|
|
{
|
|
int32 anInt32 = 0;
|
|
|
|
BMessage::FindInt32(name, index, &anInt32);
|
|
|
|
return anInt32;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/*int64 FindInt64(const char *, int32 n = 0) const;
|
|
bool FindBool(const char *, int32 n = 0) const;
|
|
float FindFloat(const char *, int32 n = 0) const;
|
|
double FindDouble(const char *, int32 n = 0) const;*/
|
|
//------------------------------------------------------------------------------
|
|
BMessage::BMessage(BMessage *a_message)
|
|
{
|
|
BMessage::BMessage(*a_message);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
void BMessage::_ReservedMessage1() {}
|
|
void BMessage::_ReservedMessage2() {}
|
|
void BMessage::_ReservedMessage3() {}
|
|
//------------------------------------------------------------------------------
|
|
void BMessage::init_data()
|
|
{
|
|
what = 0;
|
|
|
|
link = NULL;
|
|
fTarget = -1;
|
|
fOriginal = NULL;
|
|
fChangeCount = 0;
|
|
fCurSpecifier = -1;
|
|
fPtrOffset = 0;
|
|
|
|
fEntries = NULL;
|
|
|
|
fReplyTo.port = -1;
|
|
fReplyTo.target = -1;
|
|
fReplyTo.team = -1;
|
|
fReplyTo.preferred = false;
|
|
|
|
fPreferred = false;
|
|
fReplyRequired = false;
|
|
fReplyDone = false;
|
|
fIsReply = false;
|
|
fWasDelivered = false;
|
|
fReadOnly = false;
|
|
fHasSpecifiers = false;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
int32 BMessage::flatten_hdr(uchar *result, ssize_t size, uchar flags) const
|
|
{
|
|
return -1;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::real_flatten(char *result, ssize_t size, uchar flags) const
|
|
{
|
|
return B_ERROR;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::real_flatten(BDataIO *stream, ssize_t size,
|
|
uchar flags) const
|
|
{
|
|
return B_ERROR;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
char *BMessage::stack_flatten(char *stack_ptr, ssize_t stack_size,
|
|
bool incl_reply, ssize_t *size) const
|
|
{
|
|
return NULL;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
ssize_t BMessage::calc_size(uchar flags) const
|
|
{
|
|
return -1;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
ssize_t BMessage::calc_hdr_size(uchar flags) const
|
|
{
|
|
return -1;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
ssize_t BMessage::min_hdr_size() const
|
|
{
|
|
return -1;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::nfind_data(const char *name, type_code type, int32 index,
|
|
const void **data, ssize_t *data_size) const
|
|
{
|
|
return B_ERROR;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::copy_data(const char *name, type_code type, int32 index,
|
|
void *data, ssize_t data_size) const
|
|
{
|
|
return B_ERROR;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::_send_(port_id port, int32 token, bool preferred,
|
|
bigtime_t timeout, bool reply_required,
|
|
BMessenger &reply_to) const
|
|
{
|
|
/*_set_message_target_(this, token, preferred);
|
|
_set_message_reply_(this, reply_to);
|
|
|
|
int32 size;
|
|
char *buffer;
|
|
|
|
write_port_etc(port, what, buffer, size, B_TIMEOUT, timeout);*/
|
|
|
|
return B_ERROR;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::send_message(port_id port, team_id port_owner, int32 token,
|
|
bool preferred, BMessage *reply,
|
|
bigtime_t send_timeout,
|
|
bigtime_t reply_timeout) const
|
|
{
|
|
return B_ERROR;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
BMessage::entry_hdr * BMessage::entry_find(const char *name, uint32 type,
|
|
status_t *result) const
|
|
{
|
|
for (entry_hdr *entry = fEntries; entry != NULL; entry = entry->fNext)
|
|
if (entry->fType ==type && entry->fNameLength == strlen(name) &&
|
|
strncmp(entry->fName, name, entry->fNameLength) == 0)
|
|
{
|
|
if (result)
|
|
*result = B_OK;
|
|
|
|
return entry;
|
|
}
|
|
|
|
if (result)
|
|
*result = B_NAME_NOT_FOUND;
|
|
|
|
return NULL;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
void BMessage::entry_remove(entry_hdr *entry)
|
|
{
|
|
if (entry == fEntries)
|
|
fEntries = entry->fNext;
|
|
else
|
|
{
|
|
for (entry_hdr *entry_ptr = fEntries; entry_ptr != NULL; entry_ptr = entry_ptr->fNext)
|
|
if (entry_ptr->fNext == entry)
|
|
entry_ptr->fNext = entry->fNext;
|
|
}
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
void *BMessage::da_create(int32 header_size, int32 chunk_size, bool fixed,
|
|
int32 nchunks)
|
|
{
|
|
int size = da_calc_size(header_size, chunk_size, fixed, nchunks);
|
|
|
|
dyn_array *da = (dyn_array*)new char[size];
|
|
|
|
da->fLogicalBytes = 0;
|
|
da->fPhysicalBytes = size - sizeof(dyn_array) - header_size;
|
|
|
|
if ( fixed )
|
|
da->fChunkSize = chunk_size;
|
|
else
|
|
da->fChunkSize = 0;
|
|
|
|
da->fCount = 0;
|
|
da->fEntryHdrSize = header_size;
|
|
|
|
return da;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::da_add_data(dyn_array **da, const void *data, int32 size )
|
|
{
|
|
_ASSERT(_CrtCheckMemory());
|
|
|
|
int32 new_size = (*da)->fLogicalBytes + ((*da)->fChunkSize ? (*da)->fChunkSize :
|
|
da_pad_8(size + da_chunk_hdr_size()));
|
|
|
|
if (new_size > (*da)->fPhysicalBytes)
|
|
da_grow(da, new_size - (*da)->fPhysicalBytes);
|
|
|
|
void *ptr = da_find_data(*da, (*da)->fCount++, NULL);
|
|
|
|
memcpy(ptr, data, size);
|
|
|
|
if ((*da)->fChunkSize)
|
|
(*da)->fLogicalBytes += size;
|
|
else
|
|
{
|
|
da_chunk_ptr(ptr)->fDataSize = size;
|
|
(*da)->fLogicalBytes += da_chunk_size(da_chunk_ptr(ptr));
|
|
}
|
|
|
|
_ASSERT(_CrtCheckMemory());
|
|
|
|
return B_OK;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
void *BMessage::da_find_data(dyn_array *da, int32 index, int32 *size) const
|
|
{
|
|
if (da->fChunkSize)
|
|
{
|
|
if (size)
|
|
*size = da->fChunkSize;
|
|
|
|
return (char*)da_start_of_data(da) + index * da->fChunkSize;
|
|
}
|
|
else
|
|
{
|
|
var_chunk *chunk = da_first_chunk(da);
|
|
|
|
for (int i = 0; i < index; i++)
|
|
chunk = da_next_chunk(chunk);
|
|
|
|
if (size)
|
|
*size = chunk->fDataSize;
|
|
|
|
return chunk->fData;
|
|
}
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::da_delete_data(dyn_array **pda, int32 index)
|
|
{
|
|
return 0;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
status_t BMessage::da_replace_data(dyn_array **pda, int32 index,
|
|
const void *data, int32 dsize)
|
|
{
|
|
void *ptr = da_find_data(*pda, index, NULL);
|
|
|
|
memcpy(ptr, data, dsize);
|
|
|
|
return B_OK;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
int32 BMessage::da_calc_size(int32 hdr_size, int32 chunksize, bool is_fixed,
|
|
int32 nchunks) const
|
|
{
|
|
int size = sizeof(dyn_array) + hdr_size;
|
|
|
|
if (is_fixed)
|
|
size += chunksize * nchunks;
|
|
else
|
|
size += (chunksize + da_chunk_hdr_size()) * nchunks;
|
|
|
|
return size;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
void *BMessage::da_grow(dyn_array **pda, int32 increase)
|
|
{
|
|
dyn_array *da = (dyn_array*)new char[da_total_size(*pda) + increase];
|
|
dyn_array *old_da = *pda;
|
|
|
|
memcpy(da, *pda, da_total_size(*pda));
|
|
|
|
*pda = da;
|
|
(*pda)->fPhysicalBytes += increase;
|
|
|
|
entry_remove((entry_hdr*)old_da);
|
|
|
|
delete old_da;
|
|
|
|
((entry_hdr*)*pda)->fNext = fEntries;
|
|
fEntries = (entry_hdr*)*pda;
|
|
|
|
return *pda;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
void BMessage::da_dump(dyn_array *da)
|
|
{
|
|
entry_hdr *entry = (entry_hdr*)da;
|
|
|
|
printf("\tLogicalBytes=%d\n\tPhysicalBytes=%d\n\tChunkSize=%d\n\tCount=%d\n\tEntryHdrSize=%d\n",
|
|
entry->fLogicalBytes, entry->fPhysicalBytes, entry->fChunkSize, entry->fCount,
|
|
entry->fEntryHdrSize);
|
|
printf("\tNext=%p\n\tType=%c%c%c%c\n\tNameLength=%d\n\tName=%s\n",
|
|
entry->fNext, (entry->fType & 0xFF000000) >> 24, (entry->fType & 0x00FF0000) >> 16,
|
|
(entry->fType & 0x0000FF00) >> 8, entry->fType & 0x000000FF, entry->fNameLength,
|
|
entry->fName);
|
|
|
|
printf("\tData=");
|
|
|
|
switch (entry->fType)
|
|
{
|
|
case B_BOOL_TYPE:
|
|
{
|
|
printf("%s", *(bool*)da_find_data(entry, 0, NULL) ? "true" : "false");
|
|
|
|
for (int i = 1; i < entry->fCount; i++)
|
|
printf(", %s", *(bool*)da_find_data ( entry, i, NULL ) ? "true" : "false");
|
|
break;
|
|
}
|
|
case B_INT32_TYPE:
|
|
{
|
|
printf("%d", *(int32*)da_find_data(entry, 0, NULL));
|
|
|
|
for (int i = 1; i < entry->fCount; i++)
|
|
printf(", %d", *(int32*)da_find_data(entry, i, NULL));
|
|
break;
|
|
}
|
|
case B_FLOAT_TYPE:
|
|
{
|
|
printf("%f", *(float*)da_find_data(entry, 0, NULL));
|
|
|
|
for (int i = 1; i < entry->fCount; i++)
|
|
printf(", %f", *(float*)da_find_data ( entry, i, NULL));
|
|
break;
|
|
}
|
|
case B_STRING_TYPE:
|
|
{
|
|
printf("%s", da_find_data(entry, 0, NULL));
|
|
|
|
for (int i = 1; i < entry->fCount; i++)
|
|
printf(", %s", da_find_data(entry, i, NULL));
|
|
break;
|
|
}
|
|
case B_POINT_TYPE:
|
|
{
|
|
float *data = (float*)da_find_data(entry, 0, NULL);
|
|
|
|
printf("[%f,%f]", data[0], data[1]);
|
|
|
|
for (int i = 1; i < entry->fCount; i++)
|
|
{
|
|
data = (float*)da_find_data ( entry, i, NULL);
|
|
printf(", [%f,%f]", data[0], data[1]);
|
|
}
|
|
break;
|
|
}
|
|
case B_RECT_TYPE:
|
|
{
|
|
float *data = (float*)da_find_data(entry, 0, NULL);
|
|
|
|
printf("[%f,%f,%f,%f]", data[0], data[1], data[2], data[3]);
|
|
|
|
for (int i = 1; i < entry->fCount; i++)
|
|
{
|
|
data = (float*)da_find_data ( entry, i, NULL);
|
|
printf(", [%f,%f,%f,%f]", data[0], data[1], data[2], data[3]);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
printf("\n");
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
void BMessage::da_swap_var_sized(dyn_array *da)
|
|
{
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
void BMessage::da_swap_fixed_sized(dyn_array *da)
|
|
{
|
|
}
|
|
//------------------------------------------------------------------------------
|