From 9d0a9900f09887ead153e3964ffc9544e3fea9c9 Mon Sep 17 00:00:00 2001 From: Ingo Weinhold Date: Fri, 28 Jan 2005 14:50:01 +0000 Subject: [PATCH] * Updated copyright date and added myself to the authors. :-) * Removed 1500 lines of unused non-template-madness code. We have version control to resurrect it, if we ever wish to. git-svn-id: file:///srv/svn/repos/haiku/trunk/current@11105 a95241bf-73f2-0310-859d-f6bbb57e9c96 --- src/kits/app/Message.cpp | 1460 +------------------------------------- 1 file changed, 3 insertions(+), 1457 deletions(-) diff --git a/src/kits/app/Message.cpp b/src/kits/app/Message.cpp index 0c9fc99424..1ac5a9bf8c 100644 --- a/src/kits/app/Message.cpp +++ b/src/kits/app/Message.cpp @@ -1,5 +1,5 @@ //------------------------------------------------------------------------------ -// Copyright (c) 2001-2002, OpenBeOS +// Copyright (c) 2001-2005, OpenBeOS // // Permission is hereby granted, free of charge, to any person obtaining a // copy of this software and associated documentation files (the "Software"), @@ -22,14 +22,13 @@ // File Name: Message.h // Author(s): Erik Jaesler (erik@cgsoftware.com) // DarkWyrm +// Ingo Weinhold // Description: BMessage class creates objects that store data and that // can be processed in a message loop. BMessage objects // are also used as data containers by the archiving and // the scripting mechanisms. //------------------------------------------------------------------------------ -#define USING_TEMPLATE_MADNESS - // debugging //#define DBG(x) x #define DBG(x) ; @@ -51,14 +50,12 @@ //#include // Project Includes ------------------------------------------------------------ -#ifdef USING_TEMPLATE_MADNESS #include #include #include #include #include #include -#endif // USING_TEMPLATE_MADNESS // Local Includes -------------------------------------------------------------- @@ -85,9 +82,8 @@ // Globals --------------------------------------------------------------------- -#ifdef USING_TEMPLATE_MADNESS using namespace BPrivate; -#endif // USING_TEMPLATE_MADNESS + const char* B_SPECIFIER_ENTRY = "specifiers"; const char* B_PROPERTY_ENTRY = "property"; const char* B_PROPERTY_NAME_ENTRY = "name"; @@ -143,7 +139,6 @@ BMessage *_reconstruct_msg_(uint32,uint32,uint32) } //------------------------------------------------------------------------------ -#ifdef USING_TEMPLATE_MADNESS void BMessage::_ReservedMessage1() {} void BMessage::_ReservedMessage2() {} void BMessage::_ReservedMessage3() {} @@ -2067,1455 +2062,6 @@ PRINT(("handle_reply(port: %ld)\n", reply_port)); PRINT(("handle_reply() done: %lx\n", err)); return err; } -//------------------------------------------------------------------------------ - -#else // USING_TEMPLATE_MADNESS - -//------------------------------------------------------------------------------ -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; -} -//------------------------------------------------------------------------------ -ssize_t BMessage::FlattenedSize() const -{ - ssize_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, ssize_t numBytes) const -{ - if (address!= 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, ssize_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, - ssize_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; - ssize_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; - ssize_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, - ssize_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, ssize_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, ssize_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) -{ - *this=*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; -} -//------------------------------------------------------------------------------ -// These are not declared in the header anymore and aren't actually used by the -// "old" implementation. -#if 0 -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; -} -#endif -//------------------------------------------------------------------------------ -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) -{ -} -//------------------------------------------------------------------------------ - -#endif // USING_TEMPLATE_MADNESS - // convert_message static