//------------------------------------------------------------------------------
//      MessageBoolItemTest.h
//
//------------------------------------------------------------------------------

#ifndef MESSAGEBOOLITEMTEST_H
#define MESSAGEBOOLITEMTEST_H

// Standard Includes -----------------------------------------------------------

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

// Project Includes ------------------------------------------------------------

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

// Local Defines ---------------------------------------------------------------

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

typedef TMessageItemFuncPolicy
<
        bool,
        &BMessage::AddBool,
        &BMessage::FindBool,
        &BMessage::FindBool,
        &BMessage::FindBool,
        &BMessage::HasBool,
        &BMessage::ReplaceBool
>
TBoolFuncPolicy;

template<>
struct ArrayTypeBase<bool>
{
        class ArrayType
        {
                public:
                        ArrayType() : array(NULL), size(0) {;}
                        ArrayType(const ArrayType& rhs) : array(NULL), size(0)
                                { *this = rhs; }
                        ArrayType(bool* 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; }
                        bool& operator[](int index)
                        {
                                // We're just gonna let a segfault happen
                                return array[index];
                        }

                private:
                        void Assign(bool* data, uint32 len)
                        {
                                size = len;

                                if (array)
                                        delete[] array;
                                array = new bool[Size()];
                                memcpy(array, data, Size());
                        }
                        bool*   array;
                        uint32  size;
        };

        typedef uint32 SizeType;
        static SizeType Size(ArrayType& array) { return array.Size(); }
};

struct TBoolInitPolicy : public ArrayTypeBase<bool>
{
        inline static bool Zero()       { return false; }
        inline static bool Test1()      { return true; }
        inline static bool Test2()      { return false; }
        inline static size_t SizeOf(const bool&)        { return sizeof (bool); }
        inline static ArrayType Array()
        {
                static bool array[] = { true, true, true };
                return ArrayType(array, 3);
        }
};

//struct TBoolAssertPolicy
//{
//      inline static bool Zero()               { return false; }
//      inline static bool Invalid()    { return false;}
//};
typedef TMessageItemAssertPolicy
<
        bool//,
//      false,
//      false
>
TBoolAssertPolicy;

typedef TMessageItemTest
<
        bool,
        B_BOOL_TYPE,
        TBoolFuncPolicy,
        TBoolInitPolicy,
        TBoolAssertPolicy
>
TMessageBoolItemTest;

#endif  // MESSAGEBOOLITEMTEST_H

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