//------------------------------------------------------------------------------
//      MessageFlattenableItemTest.h
//
//------------------------------------------------------------------------------

#ifndef MESSAGEFLATTENABLEITEMTEST_H
#define MESSAGEFLATTENABLEITEMTEST_H

// Standard Includes -----------------------------------------------------------
#include <string>

// System Includes -------------------------------------------------------------

// Project Includes ------------------------------------------------------------
#include <Flattenable.h>

// Local Includes --------------------------------------------------------------
#include "MessageItemTest.h"

// Local Defines ---------------------------------------------------------------
#define MY_FLATTENABLE_TYPE     'flat'

// Globals ---------------------------------------------------------------------

class MyFlattenableType : public BFlattenable
{
        public:
                MyFlattenableType() {;}
                MyFlattenableType(const char* data)
                        :       fData(data)
                {;}

                bool operator==(const MyFlattenableType& mft) const;
//                      { return fData == mft.fData; }

                virtual status_t        Flatten(void* buffer, ssize_t numBytes) const;
                virtual status_t        Unflatten(type_code code, const void* buffer,
                                                                          ssize_t numBytes);
                virtual ssize_t         FlattenedSize() const { return fData.length() + 1; }
                virtual bool            IsFixedSize() const { return false; }
                virtual type_code       TypeCode() const { return MY_FLATTENABLE_TYPE; }

        private:
                std::string     fData;
};
//------------------------------------------------------------------------------
bool MyFlattenableType::operator==(const MyFlattenableType& mft) const
{
        bool ret = fData == mft.fData;
        return ret;
}
//------------------------------------------------------------------------------
status_t MyFlattenableType::Flatten(void* buffer, ssize_t numBytes) const
{
        if (!buffer)
        {
                return B_BAD_VALUE;
        }
        if (numBytes != FlattenedSize())
        {
                return B_NO_MEMORY;
        }
        memcpy(buffer, (const void*)fData.c_str(), fData.length());
        ((char*)buffer)[fData.length()] = '\0';
        return B_OK;
}
//------------------------------------------------------------------------------
status_t MyFlattenableType::Unflatten(type_code code, const void* buffer,
                                                                          ssize_t numBytes)
{
        if (!buffer)
        {
                return B_BAD_VALUE;
        }
        if (!AllowsTypeCode(code))
        {
                return B_ERROR;
        }
        fData.assign((const char*)buffer, numBytes - 1);
        return B_OK;
}
//------------------------------------------------------------------------------


struct TFlattenableFuncPolicy
{
        static status_t Add(BMessage& msg, const char* name, MyFlattenableType& val)
                { return msg.AddFlat(name, &val); }
        static status_t AddData(BMessage& msg, const char* name, type_code type,
                                                        MyFlattenableType* data, ssize_t size, bool)
        {
                char* buffer = new char[size];
                status_t err = data->Flatten(buffer, size);
                if (!err)
                {
                        err = msg.AddData(name, type, buffer, size, false);
                }
                delete[] buffer;
                return err;
        }
        static status_t Find(BMessage& msg, const char* name, int32 index,
                                                 MyFlattenableType* val)
        {
                return msg.FindFlat(name, index, val);
        }
        static status_t ShortFind(BMessage& msg, const char* name, MyFlattenableType* val)
        {
                return msg.FindFlat(name, val);
        }
        static MyFlattenableType QuickFind(BMessage& msg, const char* name, int32 index)
        {
                MyFlattenableType mft;
                msg.FindFlat(name, index, &mft);
                return mft;
        }
        static bool Has(BMessage& msg, const char* name, int32 index)
                { return msg.HasFlat(name, index, &sFlat); }
        static status_t Replace(BMessage& msg, const char* name, int32 index,
                                                        MyFlattenableType& val)
                { return msg.ReplaceFlat(name, index, &val); }
        static status_t 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 = sFlat.Unflatten(type, ptr, *size);
                        if (!err)
                        {
                                *(MyFlattenableType**)data = &sFlat;
                        }
                }
                return err;
        }

        private:
                static MyFlattenableType sFlat;
};
MyFlattenableType TFlattenableFuncPolicy::sFlat;
//------------------------------------------------------------------------------
struct TFlattenableInitPolicy : public ArrayTypeBase<MyFlattenableType>
{
        inline static MyFlattenableType Zero()  { return ""; }
        inline static MyFlattenableType Test1() { return "flat1"; }
        inline static MyFlattenableType Test2() { return "MyFlattenableType"; }
        inline static size_t SizeOf(const BFlattenable& flat)
                { return flat.FlattenedSize(); }
        inline static ArrayType Array()
        {
                ArrayType array;
                array.push_back(Zero());
                array.push_back(Test1());
                array.push_back(Test2());
                return array;
        }
};
//------------------------------------------------------------------------------
struct TFlattenableAssertPolicy
{
        inline static MyFlattenableType Zero()                          { return MyFlattenableType(); }
        inline static MyFlattenableType Invalid()                       { return MyFlattenableType(); }
         static bool            Size(size_t size, MyFlattenableType& flat)
                ;//{ return size == msg.FlattenedSize(); }
};
bool TFlattenableAssertPolicy::Size(size_t size, MyFlattenableType& flat)
{
        ssize_t flatSize = flat.FlattenedSize();
        return size == (size_t)flatSize;
}
//------------------------------------------------------------------------------
template<>
struct TypePolicy<MyFlattenableType>
{
        typedef MyFlattenableType* TypePtr;
        enum { FixedSize = false };
        inline MyFlattenableType& Dereference(TypePtr p)
        {
                return *p;
        }
        inline TypePtr AddressOf(MyFlattenableType& t) { return &t; }
};
//------------------------------------------------------------------------------

typedef TMessageItemTest
<
        MyFlattenableType,
        MY_FLATTENABLE_TYPE,
        TFlattenableFuncPolicy,
        TFlattenableInitPolicy,
        TFlattenableAssertPolicy
>
TMessageFlattenableItemTest;

#endif  // MESSAGEFLATTENABLEITEMTEST_H

/*
 * $Log $
 *
 * $Id  $
 *
 */