#ifndef MESSAGEMESSAGEITEMTEST_H
#define MESSAGEMESSAGEITEMTEST_H
#include <Debug.h>
#include "MessageItemTest.h"
struct TMessageFuncPolicy
{
static status_t Add(BMessage& msg, const char* name, BMessage& val);
static status_t AddData(BMessage& msg, const char* name, type_code type,
BMessage* data, ssize_t size, bool);
static status_t Find(BMessage& msg, const char* name, int32 index,
BMessage* val);
static status_t ShortFind(BMessage& msg, const char* name, BMessage* val);
static BMessage QuickFind(BMessage& msg, const char* name, int32 index);
static bool Has(BMessage& msg, const char* name, int32 index);
static status_t Replace(BMessage& msg, const char* name, int32 index,
BMessage& val);
static status_t FindData(BMessage& msg, const char* name, type_code type,
int32 index, const void** data, ssize_t* size);
private:
static BMessage sMsg;
};
BMessage TMessageFuncPolicy::sMsg;
status_t TMessageFuncPolicy::Add(BMessage& msg, const char* name,
BMessage& val)
{
return msg.AddMessage(name, &val);
}
status_t TMessageFuncPolicy::AddData(BMessage& msg, const char* name,
type_code type, BMessage* data,
ssize_t size, bool)
{
char* buf = new char[size];
status_t err = data->Flatten(buf, size);
if (!err)
{
err = msg.AddData(name, type, buf, size, false);
}
delete[] buf;
return err;
}
inline status_t TMessageFuncPolicy::Find(BMessage& msg, const char* name,
int32 index, BMessage* val)
{
return msg.FindMessage(name, index, val);
}
inline status_t TMessageFuncPolicy::ShortFind(BMessage& msg, const char* name,
BMessage* val)
{
return msg.FindMessage(name, val);
}
BMessage TMessageFuncPolicy::QuickFind(BMessage& msg, const char* name,
int32 index)
{
BMessage val;
msg.FindMessage(name, index, &val);
return val;
}
inline bool TMessageFuncPolicy::Has(BMessage& msg, const char* name,
int32 index)
{
return msg.HasMessage(name, index);
}
inline status_t TMessageFuncPolicy::Replace(BMessage& msg, const char* name,
int32 index, BMessage& val)
{
return msg.ReplaceMessage(name, index, &val);
}
inline status_t TMessageFuncPolicy::FindData(BMessage& msg, const char* name,
type_code type, int32 index,
const void** data, ssize_t* size)
{
*data = NULL;
char* ptr;
status_t err = msg.FindData(name, type, index, (const void**)&ptr, size);
if (!err)
{
err = sMsg.Unflatten(ptr);
if (!err)
{
*(BMessage**)data = &sMsg;
}
}
return err;
}
template<>
struct ArrayTypeBase<BMessage>
{
class ArrayType
{
public:
ArrayType() : array(NULL), size(0) {;}
ArrayType(const ArrayType& rhs) : array(NULL), size(0)
{ *this = rhs; }
ArrayType(BMessage* data, uint32 len) : array(NULL), size(0)
{ Assign(data, len); }
~ArrayType() { if (array) delete[] array; }
ArrayType& operator=(const ArrayType& rhs)
{
if (this != &rhs)
Assign(rhs.array, rhs.size);
return *this;
};
uint32 Size() { return size; }
BMessage& operator[](int index)
{
return array[index];
}
private:
void Assign(BMessage* data, uint32 len)
{
size = len;
if (array)
delete[] array;
array = new BMessage[Size()];
for (uint32 i = 0; i < Size(); ++i)
array[i] = data[i];
}
BMessage* array;
uint32 size;
};
typedef uint32 SizeType;
static SizeType Size(ArrayType& array) { return array.Size(); }
};
struct TMessageInitPolicy : public ArrayTypeBase<BMessage>
{
inline static BMessage Zero() { return BMessage(); }
static BMessage Test1()
{
BMessage msg('1234');
msg.AddInt32("int32", 1234);
return msg;
}
static BMessage Test2()
{
BMessage msg('5678');
msg.AddString("string", "5678");
return msg;
}
static size_t SizeOf(const BMessage& data)
{
return data.FlattenedSize();
}
inline static ArrayType Array()
{
BMessage array[3];
array[0] = Zero();
array[1] = Test1();
array[2] = Test2();
return ArrayType(array, 3);
}
};
struct TMessageAssertPolicy
{
inline static BMessage Zero() { return BMessage(); }
inline static BMessage Invalid() { return BMessage(); }
static bool Size(size_t size, BMessage& msg)
;
};
bool TMessageAssertPolicy::Size(size_t size, BMessage& msg)
{
ssize_t msgSize = msg.FlattenedSize();
return size == (size_t)msgSize;
}
template<>
struct TMessageItemComparePolicy<BMessage>
{
inline static bool Compare(const BMessage& lhs, const BMessage& rhs)
{ return lhs.what == rhs.what; }
};
typedef TMessageItemTest
<
BMessage,
B_MESSAGE_TYPE,
TMessageFuncPolicy,
TMessageInitPolicy,
TMessageAssertPolicy
>
TMessageMessageItemTest;
#endif
* $Log $
*
* $Id $
*
*/
