Removing old BMessage implementation. Message4 will replace it in the next commit.
This will allow to fix message related problems like drag and drop and scripting. git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@16708 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Michael Lotz
@@ -1,256 +0,0 @@
|
||||
//------------------------------------------------------------------------------
|
||||
// Copyright (c) 2001-2002, OpenBeOS
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the "Software"),
|
||||
// to deal in the Software without restriction, including without limitation
|
||||
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
// and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in
|
||||
// all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||
// DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
// File Name: MessageBody.h
|
||||
// Author(s): Erik Jaesler ([email protected])
|
||||
// Description: BMessageBody handles data storage and retrieval for
|
||||
// BMessage.
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
#ifndef MESSAGEBODY_H
|
||||
#define MESSAGEBODY_H
|
||||
#include <MessageField.h>
|
||||
// Standard Includes -----------------------------------------------------------
|
||||
#include <map>
|
||||
#include <new>
|
||||
#include <stdio.h>
|
||||
#include <string>
|
||||
|
||||
// System Includes -------------------------------------------------------------
|
||||
#include <Entry.h>
|
||||
#include <Path.h>
|
||||
#include <Point.h>
|
||||
#include <Rect.h>
|
||||
//#include <StreamIO.h>
|
||||
#include <String.h>
|
||||
#include <SupportDefs.h>
|
||||
|
||||
// Project Includes ------------------------------------------------------------
|
||||
|
||||
// Local Includes --------------------------------------------------------------
|
||||
|
||||
// Local Defines ---------------------------------------------------------------
|
||||
|
||||
// Globals ---------------------------------------------------------------------
|
||||
|
||||
enum { B_FLATTENABLE_TYPE = 'FLAT' };
|
||||
|
||||
using namespace std;
|
||||
|
||||
namespace BPrivate {
|
||||
|
||||
class BMessageBody
|
||||
{
|
||||
public:
|
||||
BMessageBody();
|
||||
BMessageBody(const BMessageBody& rhs);
|
||||
~BMessageBody();
|
||||
|
||||
BMessageBody& operator=(const BMessageBody& rhs);
|
||||
|
||||
// Statistics and misc info
|
||||
status_t GetInfo(type_code typeRequested, int32 which, char **name,
|
||||
type_code *typeReturned, int32 *count = NULL) const;
|
||||
|
||||
status_t GetInfo(const char *name, type_code *type, int32 *c = 0) const;
|
||||
status_t GetInfo(const char *name, type_code *type, bool *fixed_size) const;
|
||||
|
||||
int32 CountNames(type_code type) const;
|
||||
bool IsEmpty() const;
|
||||
bool IsSystem() const;
|
||||
bool IsReply() const;
|
||||
void PrintToStream() const;
|
||||
|
||||
status_t Rename(const char *old_entry, const char *new_entry);
|
||||
|
||||
// Flattening data
|
||||
ssize_t FlattenedSize() const;
|
||||
status_t Flatten(BDataIO *stream) const;
|
||||
|
||||
// Removing data
|
||||
status_t RemoveData(const char *name, int32 index = 0);
|
||||
status_t RemoveName(const char *name);
|
||||
status_t MakeEmpty();
|
||||
|
||||
bool HasData(const char* name, type_code t, int32 n) const;
|
||||
|
||||
template<class T1>
|
||||
status_t AddData(const char* name, const T1& data, type_code type);
|
||||
status_t AddData(const char* name, type_code type, const void* data, ssize_t numBytes, bool is_fixed_size, int32);
|
||||
status_t FindData(const char* name, type_code type, int32 index,
|
||||
const void** data, ssize_t* numBytes) const;
|
||||
template<class T1>
|
||||
status_t FindData(const char* name, int32 index, T1* data, type_code type);
|
||||
template<class T1>
|
||||
status_t ReplaceData(const char* name, int32 index, const T1& data, type_code type);
|
||||
|
||||
#if 0
|
||||
void *operator new(size_t size);
|
||||
void operator delete(void *ptr, size_t size);
|
||||
#endif
|
||||
|
||||
private:
|
||||
BMessageField* FindData(const char *name, type_code type,
|
||||
status_t& err) const;
|
||||
|
||||
typedef std::map<std::string, BMessageField*> TMsgDataMap;
|
||||
TMsgDataMap fData;
|
||||
ssize_t fFlattenedSize;
|
||||
};
|
||||
//------------------------------------------------------------------------------
|
||||
template<class T1>
|
||||
status_t BMessageBody::AddData(const char *name, const T1 &data, type_code type)
|
||||
{
|
||||
// The flattened message format in R5 only allows 1 byte
|
||||
// for the length of field names
|
||||
if (!name || (strlen(name) > 255)) return B_BAD_VALUE;
|
||||
|
||||
status_t err = B_OK;
|
||||
BMessageField* BMF = FindData(name, type, err);
|
||||
|
||||
if (err)
|
||||
{
|
||||
if (err == B_NAME_NOT_FOUND)
|
||||
{
|
||||
// Reset err; we'll create the field
|
||||
err = B_OK;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Looking for B_BAD_TYPE here in particular, which would indicate
|
||||
// that we tried to add data of type X when we already had data of
|
||||
// type Y with the same name
|
||||
return err;
|
||||
}
|
||||
}
|
||||
|
||||
if (!BMF)
|
||||
{
|
||||
BMF = new(nothrow) BMessageFieldImpl<T1>(name, type);
|
||||
if (BMF)
|
||||
{
|
||||
fData[name] = BMF;
|
||||
}
|
||||
else
|
||||
{
|
||||
err = B_NO_MEMORY;
|
||||
}
|
||||
}
|
||||
|
||||
if (!err)
|
||||
{
|
||||
BMessageFieldImpl<T1>* RItem =
|
||||
dynamic_cast<BMessageFieldImpl<T1>*>(BMF);
|
||||
if (!RItem)
|
||||
{
|
||||
debugger("\n\n\tyou \033[44;1;37mB\033[41;1;37me\033[m screwed\n\n");
|
||||
}
|
||||
RItem->AddItem(data);
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
template<class T1>
|
||||
status_t BMessageBody::FindData(const char *name, int32 index, T1 *data,
|
||||
type_code type)
|
||||
{
|
||||
if (!name)
|
||||
{
|
||||
return B_BAD_VALUE;
|
||||
}
|
||||
if (index < 0)
|
||||
{
|
||||
return B_BAD_INDEX;
|
||||
}
|
||||
|
||||
status_t err = B_OK;
|
||||
BMessageField* Item = FindData(name, type, err);
|
||||
if (Item)
|
||||
{
|
||||
BMessageFieldImpl<T1>* RItem =
|
||||
dynamic_cast<BMessageFieldImpl<T1>*>(Item);
|
||||
if (!RItem)
|
||||
{
|
||||
debugger("\n\n\tyou \033[44;1;37mB\033[41;1;37me"
|
||||
"\033[m screwed\n\n");
|
||||
}
|
||||
if (index < RItem->CountItems())
|
||||
{
|
||||
*data = RItem->Data()[index];
|
||||
}
|
||||
else
|
||||
{
|
||||
err = B_BAD_INDEX;
|
||||
}
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
template<class T1>
|
||||
status_t BMessageBody::ReplaceData(const char *name, int32 index,
|
||||
const T1 &data, type_code type)
|
||||
{
|
||||
if (!name)
|
||||
{
|
||||
return B_BAD_VALUE;
|
||||
}
|
||||
if (index < 0)
|
||||
{
|
||||
return B_BAD_INDEX;
|
||||
}
|
||||
|
||||
status_t err = B_OK;
|
||||
BMessageField* Item = FindData(name, type, err);
|
||||
if (Item)
|
||||
{
|
||||
BMessageFieldImpl<T1>* RItem =
|
||||
dynamic_cast<BMessageFieldImpl<T1>*>(Item);
|
||||
if (!RItem)
|
||||
{
|
||||
debugger("\n\n\tyou \033[44;1;37mB\033[41;1;37me\033[m screwed\n\n");
|
||||
}
|
||||
if (index < (int32)RItem->Data().Size())
|
||||
{
|
||||
RItem->Data()[index] = data;
|
||||
}
|
||||
else
|
||||
{
|
||||
err = B_BAD_INDEX;
|
||||
}
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
} // namespace BPrivate
|
||||
|
||||
#endif //MESSAGEBODY_H
|
||||
|
||||
/*
|
||||
* $Log $
|
||||
*
|
||||
* $Id $
|
||||
*
|
||||
*/
|
||||
|
||||
@@ -1,791 +0,0 @@
|
||||
//------------------------------------------------------------------------------
|
||||
// Copyright (c) 2001-2002, OpenBeOS
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the "Software"),
|
||||
// to deal in the Software without restriction, including without limitation
|
||||
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
// and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in
|
||||
// all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||
// DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
// File Name: MessageField.h
|
||||
// Author(s): Erik Jaesler ([email protected])
|
||||
// Description: BMessageField contains and manages the data for indiviual
|
||||
// named field in BMessageBody
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
#ifndef MESSAGEFIELD_H
|
||||
#define MESSAGEFIELD_H
|
||||
|
||||
// Standard Includes -----------------------------------------------------------
|
||||
#include <new>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <vector>
|
||||
#include <string>
|
||||
|
||||
// System Includes -------------------------------------------------------------
|
||||
#include <Entry.h>
|
||||
#include <Path.h>
|
||||
#include <Point.h>
|
||||
#include <Rect.h>
|
||||
#include <String.h>
|
||||
#include <SupportDefs.h>
|
||||
|
||||
// Project Includes ------------------------------------------------------------
|
||||
#include <DataBuffer.h>
|
||||
#include <MessageUtils.h>
|
||||
|
||||
// Local Includes --------------------------------------------------------------
|
||||
|
||||
// Local Defines ---------------------------------------------------------------
|
||||
// flags for each entry (the bitfield is 1 byte)
|
||||
#define MSG_FLAG_VALID 0x01
|
||||
#define MSG_FLAG_MINI_DATA 0x02
|
||||
#define MSG_FLAG_FIXED_SIZE 0x04
|
||||
#define MSG_FLAG_SINGLE_ITEM 0x08
|
||||
#define MSG_FLAG_ALL 0x0F
|
||||
|
||||
#define MSG_LAST_ENTRY 0x0
|
||||
|
||||
using namespace std;
|
||||
|
||||
// Globals ---------------------------------------------------------------------
|
||||
namespace BPrivate {
|
||||
|
||||
class BMessageField
|
||||
{
|
||||
public:
|
||||
static const char* sNullData;
|
||||
|
||||
BMessageField(const std::string& name, type_code t)
|
||||
: fType(t), fName(name)
|
||||
{;}
|
||||
virtual ~BMessageField() {}
|
||||
virtual const std::string& Name() const { return fName; }
|
||||
virtual type_code Type() const { return fType; }
|
||||
virtual bool FixedSize() const { return true; }
|
||||
virtual ssize_t FlattenedSize() const { return 0; }
|
||||
virtual status_t Flatten(BDataIO& stream) const = 0;
|
||||
virtual ssize_t CountItems() const { return 0; }
|
||||
virtual void RemoveItem(ssize_t index) = 0;
|
||||
virtual void PrintToStream(const char* name) const;
|
||||
virtual const void* DataAt(int32 index, ssize_t* size) const = 0;
|
||||
|
||||
virtual BMessageField* Clone() const = 0;
|
||||
|
||||
protected:
|
||||
virtual void PrintDataItem(int32 index) const = 0;
|
||||
|
||||
private:
|
||||
type_code fType;
|
||||
std::string fName;
|
||||
};
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
template<class T>
|
||||
struct BMessageFieldStoragePolicy
|
||||
{
|
||||
class Store
|
||||
{
|
||||
public:
|
||||
// Compiler-generated versions should be just fine
|
||||
#if 0
|
||||
Store();
|
||||
Store(const Store& rhs);
|
||||
~Store();
|
||||
Store& operator=(const Store& rhs);
|
||||
#endif
|
||||
inline size_t Size() const { return fData.size(); }
|
||||
inline T& operator[](uint index) { return fData[index]; }
|
||||
inline const T& operator[](uint index) const { return fData[index]; }
|
||||
inline void Add(const T& data) { fData.push_back(data); }
|
||||
inline void Remove(uint index) { fData.erase(fData.begin() + index); }
|
||||
inline void Copy(const Store& rhs) { fData = rhs.fData; }
|
||||
|
||||
private:
|
||||
std::vector<T> fData;
|
||||
};
|
||||
};
|
||||
//------------------------------------------------------------------------------
|
||||
template<class T>
|
||||
struct BMessageFieldSizePolicy
|
||||
{
|
||||
typedef typename BMessageFieldStoragePolicy<T>::Store Store;
|
||||
|
||||
inline static size_t Size(const T&) { return sizeof (T); }
|
||||
inline static size_t Size(const Store& data)
|
||||
{
|
||||
return sizeof (T) * data.Size();
|
||||
}
|
||||
inline static bool Fixed() { return true; }
|
||||
inline static size_t Padding(const T&) { return 0; }
|
||||
inline static size_t Padding(const Store& data) { return 0; }
|
||||
};
|
||||
//------------------------------------------------------------------------------
|
||||
template<class T>
|
||||
struct BMessageFieldPrintPolicy
|
||||
{
|
||||
static void PrintData(const T& data) {;}
|
||||
};
|
||||
//------------------------------------------------------------------------------
|
||||
template<class T>
|
||||
struct BMessageFieldFlattenPolicy
|
||||
{
|
||||
typedef BMessageFieldSizePolicy<T> SizePolicy;
|
||||
|
||||
inline static status_t Flatten(BDataIO& stream, const T& data)
|
||||
{
|
||||
return stream.Write((const void*)&data, SizePolicy::Size(data));
|
||||
}
|
||||
};
|
||||
//------------------------------------------------------------------------------
|
||||
template<class T>
|
||||
struct BMessageFieldGetDataPolicy
|
||||
{
|
||||
inline static const void* GetData(const T* data)
|
||||
{ return (const void*)data; }
|
||||
};
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
template
|
||||
<
|
||||
class T1,
|
||||
class StoragePolicy = BMessageFieldStoragePolicy<T1>,
|
||||
class SizePolicy = BMessageFieldSizePolicy<T1>,
|
||||
class PrintPolicy = BMessageFieldPrintPolicy<T1>,
|
||||
class FlattenPolicy = BMessageFieldFlattenPolicy<T1>,
|
||||
class GetDataPolicy = BMessageFieldGetDataPolicy<T1>
|
||||
>
|
||||
class BMessageFieldImpl : public BMessageField
|
||||
{
|
||||
public:
|
||||
typedef typename StoragePolicy::Store StorageType;
|
||||
|
||||
BMessageFieldImpl(const std::string& name, type_code type)
|
||||
: BMessageField(name, type),
|
||||
fMaxSize(0),
|
||||
fFlags(MSG_FLAG_ALL)
|
||||
{;}
|
||||
virtual ~BMessageFieldImpl() {}
|
||||
|
||||
virtual bool FixedSize() const
|
||||
{ return fFlags & MSG_FLAG_FIXED_SIZE; }
|
||||
virtual ssize_t FlattenedSize() const;
|
||||
virtual status_t Flatten(BDataIO& stream) const;
|
||||
virtual ssize_t CountItems() const { return fData.Size(); }
|
||||
virtual void AddItem(const T1& data);
|
||||
virtual void RemoveItem(ssize_t index)
|
||||
{ fData.Remove(index); };
|
||||
|
||||
virtual const void* DataAt(int32 index, ssize_t* size) const;
|
||||
|
||||
virtual BMessageField* Clone() const;
|
||||
|
||||
StorageType& Data() { return fData; }
|
||||
|
||||
protected:
|
||||
virtual void PrintDataItem(int32 index) const;
|
||||
|
||||
private:
|
||||
StorageType fData;
|
||||
size_t fMaxSize;
|
||||
uchar fFlags;
|
||||
};
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
template
|
||||
<
|
||||
class T1,
|
||||
class StoragePolicy,
|
||||
class SizePolicy,
|
||||
class PrintPolicy,
|
||||
class FlattenPolicy,
|
||||
class GetDataPolicy
|
||||
>
|
||||
ssize_t
|
||||
BMessageFieldImpl<T1, StoragePolicy, SizePolicy, PrintPolicy, FlattenPolicy, GetDataPolicy>::
|
||||
FlattenedSize() const
|
||||
{
|
||||
// Mandatory stuff
|
||||
ssize_t size = 1; // field flags byte
|
||||
size += sizeof (type_code); // field type bytes
|
||||
if (!(fFlags & MSG_FLAG_SINGLE_ITEM)) // item count byte
|
||||
{
|
||||
if (fFlags & MSG_FLAG_MINI_DATA)
|
||||
++size; // item count byte for mini data
|
||||
else
|
||||
size += 4; // item count bytes for maxi data
|
||||
}
|
||||
|
||||
if (fFlags & MSG_FLAG_MINI_DATA)
|
||||
++size; // data length byte for mini data
|
||||
else
|
||||
size += 4; // data length bytes for maxi data
|
||||
|
||||
++size; // name length byte
|
||||
size += Name().length(); // name length
|
||||
|
||||
// item data length
|
||||
size += SizePolicy::Size(fData);
|
||||
|
||||
// Calculate any necessary padding
|
||||
if (!SizePolicy::Fixed())
|
||||
{
|
||||
size += 4 * fData.Size();
|
||||
size += SizePolicy::Padding(fData);
|
||||
#if 0
|
||||
for (uint32 i = 0; i < fData.Size(); ++i)
|
||||
{
|
||||
// pad to 8-byte boundary, including size bytes in calculation
|
||||
size += calc_padding(SizePolicy::Size(fData[i]) + 4, 8);
|
||||
// item size bytes
|
||||
size += 4;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
return size;
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
template
|
||||
<
|
||||
class T1,
|
||||
class StoragePolicy,
|
||||
class SizePolicy,
|
||||
class PrintPolicy,
|
||||
class FlattenPolicy,
|
||||
class GetDataPolicy
|
||||
>
|
||||
status_t
|
||||
BMessageFieldImpl<T1, StoragePolicy, SizePolicy, PrintPolicy, FlattenPolicy, GetDataPolicy>::
|
||||
Flatten(BDataIO& stream) const
|
||||
{
|
||||
status_t err = B_OK;
|
||||
type_code type = Type();
|
||||
uint32 count = fData.Size();
|
||||
uint8 nameLen = Name().length();
|
||||
size_t size = SizePolicy::Size(fData);
|
||||
|
||||
err = stream.Write(&fFlags, sizeof (fFlags));
|
||||
|
||||
// Field type_code
|
||||
if (err >= 0)
|
||||
err = stream.Write(&type, sizeof (type_code));
|
||||
|
||||
// Item count, if more than one
|
||||
if (err >= 0 && !(fFlags & MSG_FLAG_SINGLE_ITEM))
|
||||
{
|
||||
if (fFlags & MSG_FLAG_MINI_DATA)
|
||||
{
|
||||
uint8 miniCount = count;
|
||||
err = stream.Write(&miniCount, sizeof (miniCount));
|
||||
}
|
||||
else
|
||||
{
|
||||
err = stream.Write(&count, sizeof (count));
|
||||
}
|
||||
}
|
||||
|
||||
// Data length
|
||||
if (err >= 0)
|
||||
{
|
||||
if (!(fFlags & MSG_FLAG_FIXED_SIZE))
|
||||
{
|
||||
// Add the bytes for holding the item size for each item
|
||||
size += 4 * fData.Size();
|
||||
size += SizePolicy::Padding(fData);
|
||||
}
|
||||
if (fFlags & MSG_FLAG_MINI_DATA)
|
||||
{
|
||||
uint8 miniSize = size;
|
||||
err = stream.Write(&miniSize, sizeof (miniSize));
|
||||
}
|
||||
else
|
||||
{
|
||||
err = stream.Write(&size, sizeof (size));
|
||||
}
|
||||
}
|
||||
|
||||
// Name length
|
||||
if (err >= 0)
|
||||
err = stream.Write(&nameLen, sizeof (nameLen));
|
||||
|
||||
// Name
|
||||
if (err >= 0)
|
||||
err = stream.Write(Name().c_str(), Name().length());
|
||||
|
||||
// Actual data items
|
||||
for (uint32 i = 0; i < fData.Size() && err >= 0; ++i)
|
||||
{
|
||||
if (!SizePolicy::Fixed())
|
||||
{
|
||||
size = (int32)SizePolicy::Size(fData[i]);
|
||||
err = stream.Write(&size, sizeof (size));
|
||||
}
|
||||
if (err >= 0)
|
||||
{
|
||||
err = FlattenPolicy::Flatten(stream, fData[i]);
|
||||
}
|
||||
if (err >= 0 && !SizePolicy::Fixed())
|
||||
{
|
||||
// Add any necessary padding
|
||||
err = stream.Write(BMessageField::sNullData,
|
||||
SizePolicy::Padding(fData[i]));
|
||||
}
|
||||
}
|
||||
|
||||
if (err >= 0)
|
||||
err = B_OK;
|
||||
return err;
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
template
|
||||
<
|
||||
class T1,
|
||||
class StoragePolicy,
|
||||
class SizePolicy,
|
||||
class PrintPolicy,
|
||||
class FlattenPolicy,
|
||||
class GetDataPolicy
|
||||
>
|
||||
void
|
||||
BMessageFieldImpl<T1, StoragePolicy, SizePolicy, PrintPolicy, FlattenPolicy, GetDataPolicy>::
|
||||
AddItem(const T1& data)
|
||||
{
|
||||
fData.Add(data);
|
||||
|
||||
if (fMaxSize)
|
||||
{
|
||||
if ((fFlags & MSG_FLAG_FIXED_SIZE) &&
|
||||
(!SizePolicy::Fixed() ||
|
||||
fMaxSize != SizePolicy::Size(data)))
|
||||
{
|
||||
fMaxSize = max(SizePolicy::Size(data), fMaxSize);
|
||||
fFlags &= ~MSG_FLAG_FIXED_SIZE;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!SizePolicy::Fixed())
|
||||
{
|
||||
fFlags &= ~MSG_FLAG_FIXED_SIZE;
|
||||
}
|
||||
fMaxSize = SizePolicy::Size(data);
|
||||
}
|
||||
|
||||
if (fFlags & MSG_FLAG_MINI_DATA)
|
||||
{
|
||||
int32 size = SizePolicy::Size(fData);
|
||||
if (!(fFlags & MSG_FLAG_FIXED_SIZE))
|
||||
{
|
||||
size += 4 * fData.Size();
|
||||
size += SizePolicy::Padding(fData);
|
||||
}
|
||||
if (size > 255)
|
||||
fFlags &= ~MSG_FLAG_MINI_DATA;
|
||||
}
|
||||
|
||||
if (fData.Size() > 1)
|
||||
fFlags &= ~MSG_FLAG_SINGLE_ITEM;
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
template
|
||||
<
|
||||
class T1,
|
||||
class StoragePolicy,
|
||||
class SizePolicy,
|
||||
class PrintPolicy,
|
||||
class FlattenPolicy,
|
||||
class GetDataPolicy
|
||||
>
|
||||
const void*
|
||||
BMessageFieldImpl<T1, StoragePolicy, SizePolicy, PrintPolicy, FlattenPolicy, GetDataPolicy>::
|
||||
DataAt(int32 index, ssize_t* size) const
|
||||
{
|
||||
if (index < CountItems())
|
||||
{
|
||||
*size = SizePolicy::Size(fData[index]);
|
||||
const T1& ref = fData[index];
|
||||
const T1* data = &ref;
|
||||
|
||||
return GetDataPolicy::GetData(data);//(const void*)data;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
template
|
||||
<
|
||||
class T1,
|
||||
class StoragePolicy,
|
||||
class SizePolicy,
|
||||
class PrintPolicy,
|
||||
class FlattenPolicy,
|
||||
class GetDataPolicy
|
||||
>
|
||||
BMessageField*
|
||||
BMessageFieldImpl<T1, StoragePolicy, SizePolicy, PrintPolicy, FlattenPolicy, GetDataPolicy>::
|
||||
Clone() const
|
||||
{
|
||||
BMessageFieldImpl<T1>* BMF =
|
||||
new(nothrow) BMessageFieldImpl<T1>(Name(), Type());
|
||||
if (BMF)
|
||||
{
|
||||
BMF->fMaxSize = fMaxSize;
|
||||
BMF->fFlags = fFlags;
|
||||
BMF->fData.Copy(fData);
|
||||
}
|
||||
return BMF;
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
template
|
||||
<
|
||||
class T1,
|
||||
class StoragePolicy,
|
||||
class SizePolicy,
|
||||
class PrintPolicy,
|
||||
class FlattenPolicy,
|
||||
class GetDataPolicy
|
||||
>
|
||||
void
|
||||
BMessageFieldImpl<T1, StoragePolicy, SizePolicy, PrintPolicy, FlattenPolicy, GetDataPolicy>::
|
||||
PrintDataItem(int32 index) const
|
||||
{
|
||||
if (index && FixedSize())
|
||||
{
|
||||
std::printf(" ");
|
||||
}
|
||||
else
|
||||
{
|
||||
std::printf("size=%2ld, ", SizePolicy::Size(fData[index]));
|
||||
}
|
||||
std::printf("data[%ld]: ", index);
|
||||
PrintPolicy::PrintData(fData[index]);
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
|
||||
// Print policy specializations ------------------------------------------------
|
||||
template<> struct BMessageFieldPrintPolicy<bool>
|
||||
{
|
||||
static void PrintData(const bool& b) { std::printf("%d", int(b)); }
|
||||
};
|
||||
template<> struct BMessageFieldPrintPolicy<int8>
|
||||
{
|
||||
static void PrintData(const int8& i)
|
||||
{ std::printf("0x%X (%d, '%c')", int(i), int(i), char(i)); }
|
||||
};
|
||||
template<> struct BMessageFieldPrintPolicy<int16>
|
||||
{
|
||||
static void PrintData(const int16& i)
|
||||
{ std::printf("0x%X (%d, '%c')", i, i, char(i)); }
|
||||
};
|
||||
template<> struct BMessageFieldPrintPolicy<int32>
|
||||
{
|
||||
static void PrintData(const int32& i)
|
||||
{ std::printf("0x%lX (%ld, '%c')", i, i, char(i)); }
|
||||
};
|
||||
template<> struct BMessageFieldPrintPolicy<int64>
|
||||
{
|
||||
static void PrintData(const int64& i)
|
||||
{ std::printf("0x%LX (%Ld, '%c')", i, i, char(i)); }
|
||||
};
|
||||
template<> struct BMessageFieldPrintPolicy<float>
|
||||
{
|
||||
static void PrintData(const float& f) { std::printf("%.4f", f); }
|
||||
};
|
||||
template<> struct BMessageFieldPrintPolicy<double>
|
||||
{
|
||||
static void PrintData(const double& d) { std::printf("%.8f", d); }
|
||||
};
|
||||
template<> struct BMessageFieldPrintPolicy<BString>
|
||||
{
|
||||
static void PrintData(const BString& s) { std::printf("\"%s\"", s.String()); }
|
||||
};
|
||||
template<> struct BMessageFieldPrintPolicy<BPoint>
|
||||
{
|
||||
static void PrintData(const BPoint& p) { std::printf("BPoint(x:%.1f, y:%.1f)", p.x, p.y); }
|
||||
};
|
||||
template<> struct BMessageFieldPrintPolicy<BRect>
|
||||
{
|
||||
static void PrintData(const BRect& r)
|
||||
{ std::printf("BRect(l:%.1f, t:%.1f, r:%.1f, b:%.1f)", r.left, r.top, r.right, r.bottom); }
|
||||
};
|
||||
template<> struct BMessageFieldPrintPolicy<entry_ref>
|
||||
{
|
||||
static void PrintData(const entry_ref& ref)
|
||||
{
|
||||
std::printf("device=%ld, directory=%Ld, name=\"%s\", path=\"%s\"",
|
||||
ref.device, ref.directory, ref.name, BPath(&ref).Path());
|
||||
}
|
||||
};
|
||||
// Storage policy specializations ----------------------------------------------
|
||||
template<>
|
||||
struct BMessageFieldStoragePolicy<bool>
|
||||
{
|
||||
class Store
|
||||
{
|
||||
private:
|
||||
struct Boolean
|
||||
{
|
||||
Boolean() : data(bool()) {;}
|
||||
Boolean(bool b) : data(b) {;}
|
||||
bool data;
|
||||
};
|
||||
|
||||
public:
|
||||
inline size_t Size() const
|
||||
{ return fData.size(); }
|
||||
inline bool& operator[](uint index)
|
||||
{ return fData[index].data; }
|
||||
inline const bool& operator[](uint index) const
|
||||
{ return fData[index].data; }
|
||||
inline void Add(const bool& data)
|
||||
{
|
||||
fData.push_back(data);
|
||||
}
|
||||
inline void Remove(uint index)
|
||||
{
|
||||
fData.erase(fData.begin() + index);
|
||||
}
|
||||
inline void Copy(const Store& rhs)
|
||||
{
|
||||
if (&fData != &rhs.fData)
|
||||
{
|
||||
fData = rhs.fData;
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
std::vector<Boolean> fData;
|
||||
};
|
||||
};
|
||||
//------------------------------------------------------------------------------
|
||||
template<>
|
||||
struct BMessageFieldStoragePolicy<BDataBuffer>
|
||||
{
|
||||
class Store
|
||||
{
|
||||
public:
|
||||
inline size_t Size() const
|
||||
{ return fData.size(); }
|
||||
inline BDataBuffer& operator[](uint index)
|
||||
{ return fData[index]; }
|
||||
inline const BDataBuffer& operator[](uint index) const
|
||||
{ return fData[index]; }
|
||||
inline void Add(const BDataBuffer& data)
|
||||
{ fData.push_back(data); }
|
||||
inline void Remove(uint index)
|
||||
{ fData.erase(fData.begin() + index); }
|
||||
void Copy(const Store& rhs)
|
||||
{
|
||||
if (&fData == &rhs.fData)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
fData.clear();
|
||||
for (size_t i = 0; i < rhs.Size(); ++i)
|
||||
{
|
||||
Add(BDataBuffer(rhs[i], true));
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
std::vector<BDataBuffer> fData;
|
||||
};
|
||||
};
|
||||
// Size policy specializations -------------------------------------------------
|
||||
template<> struct BMessageFieldSizePolicy<BString>
|
||||
{
|
||||
typedef BMessageFieldStoragePolicy<BString>::Store Store;
|
||||
|
||||
inline static size_t Size(const BString& s) { return s.Length() + 1; }
|
||||
inline static size_t Size(const Store& data)
|
||||
{
|
||||
size_t size = 0;
|
||||
for (uint32 i = 0; i < data.Size(); ++i)
|
||||
{
|
||||
size += Size(data[i]);
|
||||
}
|
||||
return size;
|
||||
}
|
||||
inline static bool Fixed() { return false; }
|
||||
inline static size_t Padding(const BString& s)
|
||||
{
|
||||
// Padding calculations are only done for variable-sized items,
|
||||
// which by definition have four bytes of size info preceeding the
|
||||
// actual data; those four bytes are included in the padding
|
||||
// calculation. Padding is calculated to an 8-byte boundary
|
||||
return calc_padding(Size(s) + 4, 8);
|
||||
}
|
||||
inline static size_t Padding(const Store& data)
|
||||
{
|
||||
size_t size = 0;
|
||||
for (uint32 i = 0; i < data.Size(); ++i)
|
||||
{
|
||||
size += Padding(data[i]);
|
||||
}
|
||||
return size;
|
||||
}
|
||||
};
|
||||
//------------------------------------------------------------------------------
|
||||
template<> struct BMessageFieldSizePolicy<BDataBuffer>
|
||||
{
|
||||
typedef BMessageFieldStoragePolicy<BDataBuffer>::Store Store;
|
||||
|
||||
inline static size_t Size(const BDataBuffer& db)
|
||||
{ return db.BufferSize(); }
|
||||
inline static size_t Size(const Store& data)
|
||||
{
|
||||
size_t size = 0;
|
||||
for (uint32 i = 0; i < data.Size(); ++i)
|
||||
{
|
||||
size += Size(data[i]);
|
||||
}
|
||||
|
||||
return size;
|
||||
}
|
||||
inline static bool Fixed() { return false; }
|
||||
inline static size_t Padding(const BDataBuffer& db)
|
||||
{
|
||||
// Padding calculations are only done for variable-sized items,
|
||||
// which by definition have four bytes of size info preceeding the
|
||||
// actual data; those four bytes are included in the padding
|
||||
// calculation. Padding is calculated to an 8-byte boundary
|
||||
return calc_padding(Size(db) + 4, 8);
|
||||
}
|
||||
inline static size_t Padding(const Store& data)
|
||||
{
|
||||
size_t size = 0;
|
||||
for (uint32 i = 0; i < data.Size(); ++i)
|
||||
{
|
||||
size += Padding(data[i]);
|
||||
}
|
||||
return size;
|
||||
}
|
||||
};
|
||||
//------------------------------------------------------------------------------
|
||||
template<> struct BMessageFieldSizePolicy<BMessage*>
|
||||
{
|
||||
typedef BMessageFieldStoragePolicy<BMessage*>::Store Store;
|
||||
|
||||
inline static size_t Size(const BMessage* msg)
|
||||
{ return msg->FlattenedSize(); }
|
||||
inline static size_t Size(const Store& data)
|
||||
{
|
||||
size_t size = 0;
|
||||
for (uint32 i = 0; i < data.Size(); ++i)
|
||||
{
|
||||
size += Size(data[i]);
|
||||
}
|
||||
|
||||
return size;
|
||||
}
|
||||
inline static bool Fixed() { return false; }
|
||||
inline static size_t Padding(const BMessage* msg)
|
||||
{
|
||||
// Padding calculations are only done for variable-sized items,
|
||||
// which by definition have four bytes of size info preceeding the
|
||||
// actual data; those four bytes are included in the padding
|
||||
// calculation. Padding is calculated to an 8-byte boundary
|
||||
return calc_padding(Size(msg) + 4, 8);
|
||||
}
|
||||
inline static size_t Padding(const Store& data)
|
||||
{
|
||||
size_t size = 0;
|
||||
for (uint32 i = 0; i < data.Size(); ++i)
|
||||
{
|
||||
size += Padding(data[i]);
|
||||
}
|
||||
return size;
|
||||
}
|
||||
};
|
||||
// Flatten policy specializations ----------------------------------------------
|
||||
template<>
|
||||
struct BMessageFieldFlattenPolicy<BString>
|
||||
{
|
||||
typedef BMessageFieldSizePolicy<BString> SizePolicy;
|
||||
|
||||
static status_t Flatten(BDataIO& stream, const BString& data)
|
||||
{
|
||||
size_t size = SizePolicy::Size(data);
|
||||
status_t err = stream.Write((const void*)data.String(), size);
|
||||
|
||||
if (err > 0)
|
||||
err = B_OK;
|
||||
return err;
|
||||
}
|
||||
};
|
||||
//------------------------------------------------------------------------------
|
||||
template<>
|
||||
struct BMessageFieldFlattenPolicy<BMessage*>
|
||||
{
|
||||
typedef BMessageFieldSizePolicy<BMessage*> SizePolicy;
|
||||
|
||||
static status_t Flatten(BDataIO& stream, const BMessage* data)
|
||||
{
|
||||
status_t err = data->Flatten(&stream);
|
||||
|
||||
if (err > 0)
|
||||
err = B_OK;
|
||||
return err;
|
||||
}
|
||||
};
|
||||
//------------------------------------------------------------------------------
|
||||
template<>
|
||||
struct BMessageFieldFlattenPolicy<BDataBuffer>
|
||||
{
|
||||
typedef BMessageFieldSizePolicy<BDataBuffer> SizePolicy;
|
||||
|
||||
static status_t Flatten(BDataIO& stream, const BDataBuffer& db)
|
||||
{
|
||||
size_t size = SizePolicy::Size(db);
|
||||
status_t err = stream.Write(db.Buffer(), size);
|
||||
if (err > 0)
|
||||
err = B_OK;
|
||||
return err;
|
||||
}
|
||||
};
|
||||
// GetData policy specializations ----------------------------------------------
|
||||
template<>
|
||||
struct BMessageFieldGetDataPolicy<BDataBuffer>
|
||||
{
|
||||
inline static const void* GetData(const BDataBuffer* data)
|
||||
{ return data->Buffer(); }
|
||||
};
|
||||
//------------------------------------------------------------------------------
|
||||
template<>
|
||||
struct BMessageFieldGetDataPolicy<BString>
|
||||
{
|
||||
inline static const void* GetData(const BString* data)
|
||||
{ return data->String(); }
|
||||
};
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
} // namespace BPrivate
|
||||
|
||||
#endif // MESSAGEFIELD_H
|
||||
|
||||
/*
|
||||
* $Log $
|
||||
*
|
||||
* $Id $
|
||||
*
|
||||
*/
|
||||
|
||||
@@ -1,83 +0,0 @@
|
||||
//------------------------------------------------------------------------------
|
||||
// MessagePrivate.h
|
||||
//
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
#ifdef USING_MESSAGE4
|
||||
# include <MessagePrivate4.h>
|
||||
#else
|
||||
|
||||
#ifndef MESSAGEPRIVATE_H
|
||||
#define MESSAGEPRIVATE_H
|
||||
|
||||
#include <Message.h>
|
||||
#include <Messenger.h>
|
||||
#include <MessengerPrivate.h>
|
||||
#include <TokenSpace.h>
|
||||
|
||||
class BMessage::Private {
|
||||
public:
|
||||
Private(BMessage* msg) : fMessage(msg) {;}
|
||||
Private(BMessage& msg) : fMessage(&msg) {;}
|
||||
|
||||
inline void SetTarget(int32 token)
|
||||
{
|
||||
fMessage->fTarget = token;
|
||||
fMessage->fPreferred = token == B_PREFERRED_TOKEN;
|
||||
}
|
||||
|
||||
inline void SetReply(team_id team, port_id port, int32 token)
|
||||
{
|
||||
fMessage->fReplyTo.port = port;
|
||||
fMessage->fReplyTo.target = token;
|
||||
fMessage->fReplyTo.team = team;
|
||||
fMessage->fReplyTo.preferred = token == B_PREFERRED_TOKEN;
|
||||
}
|
||||
|
||||
inline void SetReply(BMessenger messenger)
|
||||
{
|
||||
BMessenger::Private mp(messenger);
|
||||
fMessage->fReplyTo.port = mp.Port();
|
||||
fMessage->fReplyTo.target = mp.Token();
|
||||
fMessage->fReplyTo.team = mp.Team();
|
||||
fMessage->fReplyTo.preferred = mp.IsPreferredTarget();
|
||||
}
|
||||
|
||||
inline int32 GetTarget()
|
||||
{
|
||||
return fMessage->fTarget;
|
||||
}
|
||||
|
||||
inline bool UsePreferredTarget()
|
||||
{
|
||||
return fMessage->fPreferred;
|
||||
}
|
||||
|
||||
static inline status_t SendFlattenedMessage(void *data, int32 size,
|
||||
port_id port, int32 token, bigtime_t timeout)
|
||||
{
|
||||
return BMessage::_SendFlattenedMessage(data, size, port, token,
|
||||
timeout);
|
||||
}
|
||||
|
||||
static inline void StaticInit()
|
||||
{
|
||||
BMessage::_StaticInit();
|
||||
}
|
||||
|
||||
static inline void StaticCleanup()
|
||||
{
|
||||
BMessage::_StaticCleanup();
|
||||
}
|
||||
|
||||
static inline void StaticCacheCleanup()
|
||||
{
|
||||
BMessage::_StaticCacheCleanup();
|
||||
}
|
||||
|
||||
private:
|
||||
BMessage* fMessage;
|
||||
};
|
||||
|
||||
#endif // MESSAGEPRIVATE_H
|
||||
#endif // USING_MESSAGE4
|
||||
@@ -1,205 +0,0 @@
|
||||
#ifdef USING_MESSAGE4
|
||||
# include <MessageUtils4.h>
|
||||
#else
|
||||
//------------------------------------------------------------------------------
|
||||
// MessageUtils.h
|
||||
//
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
#ifndef MESSAGEUTILS_H
|
||||
#define MESSAGEUTILS_H
|
||||
|
||||
// Standard Includes -----------------------------------------------------------
|
||||
|
||||
// System Includes -------------------------------------------------------------
|
||||
#include <ByteOrder.h>
|
||||
#include <DataIO.h>
|
||||
#include <Entry.h>
|
||||
#include <Message.h>
|
||||
#include <Messenger.h>
|
||||
#include <MessengerPrivate.h>
|
||||
#include <SupportDefs.h>
|
||||
|
||||
// Project Includes ------------------------------------------------------------
|
||||
|
||||
// Local Includes --------------------------------------------------------------
|
||||
|
||||
// Local Defines ---------------------------------------------------------------
|
||||
|
||||
// Globals ---------------------------------------------------------------------
|
||||
|
||||
uint32 _checksum_(const uchar *buf, int32 size);
|
||||
|
||||
namespace BPrivate { // Only putting these here because Be did
|
||||
|
||||
status_t entry_ref_flatten(char* buffer, size_t* size, const entry_ref* ref);
|
||||
status_t entry_ref_unflatten(entry_ref* ref, const char* buffer, size_t size);
|
||||
status_t entry_ref_swap(char* buffer, size_t size);
|
||||
|
||||
size_t calc_padding(size_t size, size_t boundary);
|
||||
|
||||
} // namespace BPrivate
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// _set_message_target_
|
||||
/*! \brief Sets the target of a message.
|
||||
|
||||
\param message The message.
|
||||
\param token The target handler token.
|
||||
\param preferred Indicates whether to use the looper's preferred handler.
|
||||
*/
|
||||
inline
|
||||
void
|
||||
_set_message_target_(BMessage *message, int32 token, bool preferred)
|
||||
{
|
||||
message->fTarget = token;
|
||||
message->fPreferred = preferred;
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
// _set_message_reply_
|
||||
/*! \brief Sets a message's reply target.
|
||||
|
||||
\param message The message.
|
||||
\param messenger The reply messenger.
|
||||
*/
|
||||
inline
|
||||
void
|
||||
_set_message_reply_(BMessage *message, BMessenger messenger)
|
||||
{
|
||||
BMessenger::Private messengerPrivate(messenger);
|
||||
message->fReplyTo.port = messengerPrivate.Port();
|
||||
message->fReplyTo.target = messengerPrivate.Token();
|
||||
message->fReplyTo.team = messengerPrivate.Team();
|
||||
message->fReplyTo.preferred = messengerPrivate.IsPreferredTarget();
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
inline int32 _get_message_target_(BMessage *msg)
|
||||
{
|
||||
return msg->fTarget;
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
inline bool _use_preferred_target_(BMessage *msg)
|
||||
{
|
||||
return msg->fPreferred;
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
inline status_t normalize_err(status_t err)
|
||||
{
|
||||
return err >= 0 ? B_OK : err;
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
template<class T>
|
||||
inline void byte_swap(T& /*data*/)
|
||||
{
|
||||
// Specialize for data types which actually swap
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
inline void write_helper(BDataIO* stream, const void* data, size_t size,
|
||||
status_t& err)
|
||||
{
|
||||
err = normalize_err(stream->Write(data, size));
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
// Will the template madness never cease??
|
||||
template<class T>
|
||||
inline status_t write_helper(BDataIO* stream, T& data, status_t& err)
|
||||
{
|
||||
return normalize_err(stream->Write((const void*)data, sizeof (T)));
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
class TReadHelper
|
||||
{
|
||||
public:
|
||||
TReadHelper(BDataIO* stream)
|
||||
: fStream(stream), err(B_OK), fSwap(false)
|
||||
{
|
||||
;
|
||||
}
|
||||
|
||||
TReadHelper(BDataIO* stream, bool swap)
|
||||
: fStream(stream), err(B_OK), fSwap(swap)
|
||||
{
|
||||
;
|
||||
}
|
||||
|
||||
template<class T> inline void operator()(T& data)
|
||||
{
|
||||
err = normalize_err(fStream->Read((void*)&data, sizeof (T)));
|
||||
if (err)
|
||||
throw err;
|
||||
|
||||
if (IsSwapping())
|
||||
{
|
||||
byte_swap(data);
|
||||
}
|
||||
}
|
||||
|
||||
template<class T> inline void operator()(T data, size_t len)
|
||||
{
|
||||
err = normalize_err(fStream->Read((void*)data, len));
|
||||
if (err)
|
||||
throw err;
|
||||
}
|
||||
|
||||
status_t Status() { return err; }
|
||||
void SetSwap(bool yesNo) { fSwap = yesNo; }
|
||||
bool IsSwapping() { return fSwap; }
|
||||
|
||||
private:
|
||||
BDataIO* fStream;
|
||||
status_t err;
|
||||
bool fSwap;
|
||||
};
|
||||
//------------------------------------------------------------------------------
|
||||
class TChecksumHelper
|
||||
{
|
||||
public:
|
||||
TChecksumHelper(uchar* buffer) : fBuffer(buffer), fBufPtr(buffer) {;}
|
||||
|
||||
template<class T> inline void Cache(const T& data)
|
||||
{
|
||||
*((T*)fBufPtr) = data;
|
||||
fBufPtr += sizeof (T);
|
||||
}
|
||||
|
||||
int32 CheckSum();
|
||||
|
||||
private:
|
||||
uchar* fBuffer;
|
||||
uchar* fBufPtr;
|
||||
};
|
||||
//------------------------------------------------------------------------------
|
||||
template<class T> inline status_t read_helper(BDataIO* stream, T& data)
|
||||
{
|
||||
return normalize_err(stream->Read((void*)&data, sizeof (T)));
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
template<> inline void byte_swap(double& data)
|
||||
{
|
||||
data = __swap_double(data);
|
||||
}
|
||||
template<> inline void byte_swap(float& data)
|
||||
{
|
||||
data = __swap_float(data);
|
||||
}
|
||||
template<> inline void byte_swap(int64& data)
|
||||
{
|
||||
data = __swap_int64(data);
|
||||
}
|
||||
template<> inline void byte_swap(int32& data)
|
||||
{
|
||||
data = __swap_int32(data);
|
||||
}
|
||||
template<> inline void byte_swap(int16& data)
|
||||
{
|
||||
data = __swap_int16(data);
|
||||
}
|
||||
template<> inline void byte_swap(entry_ref& data)
|
||||
{
|
||||
byte_swap(data.device);
|
||||
byte_swap(data.directory);
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
#endif // MESSAGEUTILS_H
|
||||
#endif // USING_MESSAGE4
|
||||
Reference in New Issue
Block a user