//------------------------------------------------------------------------------
//      MessageRefItemTest.h
//
//------------------------------------------------------------------------------

#ifndef MESSAGEREFITEMTEST_H
#define MESSAGEREFITEMTEST_H

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

// System Includes -------------------------------------------------------------
#include <Entry.h>
#include <Path.h>

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

// Local Includes --------------------------------------------------------------

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

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

struct TRefFuncPolicy
{
        static status_t Add(BMessage& msg, const char* name, entry_ref& val)
        {
                return msg.AddRef(name, &val);
        }
        static status_t AddData(BMessage& msg, const char* name, type_code type,
                                                        entry_ref* data, ssize_t size, bool);
        static status_t Find(BMessage& msg, const char* name, int32 index,
                                                 entry_ref* val)
        {
                return msg.FindRef(name, index, val);
        }
        static status_t ShortFind(BMessage& msg, const char* name, entry_ref* val)
        {
                return msg.FindRef(name, val);
        }
        static entry_ref QuickFind(BMessage& msg, const char* name, int32 index);
        static bool Has(BMessage& msg, const char* name, int32 index)
        {
                return msg.HasRef(name, index);
        }
        static status_t Replace(BMessage& msg, const char* name, int32 index,
                                                        entry_ref& val)
        {
                return msg.ReplaceRef(name, index, &val);
        }
        static status_t FindData(BMessage& msg, const char* name, type_code type,
                                                         int32 index, const void** data, ssize_t* size);

        private:
                static entry_ref sRef;
};
status_t TRefFuncPolicy::AddData(BMessage& msg, const char* name, type_code type,
                                                                 entry_ref* data, ssize_t size, bool)
{
        BPath Path(data);
        status_t err = Path.InitCheck();
        char* buf = NULL;
//      if (!err)
        {
                buf = new char[size];
                err = Path.Flatten(buf, size);
        }
        
        if (!err)
        {
                err = msg.AddData(name, type, buf, size, false);
        }
        delete[] buf;
        return err;
}

entry_ref TRefFuncPolicy::QuickFind(BMessage &msg, const char *name, int32 index)
{
        //      TODO: make cooler
        //      There must be some 1337 template voodoo way of making the inclusion
        //      of this function conditional.  In the meantime, we offer this
        //      cheesy hack
        entry_ref ref;
        msg.FindRef(name, index, &ref);
        return ref;
}

status_t TRefFuncPolicy::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)
        {
                BPath Path;
                err = Path.Unflatten(type, ptr, *size);
                if (!err)
                {
                        if (Path.Path())
                        {
                                err = get_ref_for_path(Path.Path(), &sRef);
                                if (!err)
                                {
                                        *(entry_ref**)data = &sRef;
                                }
                        }
                        else
                        {
                                sRef = entry_ref();
                                *(entry_ref**)data = &sRef;
                        }
                }
        }
        return err;
}
entry_ref TRefFuncPolicy::sRef;
//------------------------------------------------------------------------------
struct TRefInitPolicy : public ArrayTypeBase<entry_ref>
{
        inline static entry_ref Zero()  { return entry_ref(); }
        static entry_ref Test1()
        {
                entry_ref ref;
                get_ref_for_path("/boot/beos/apps/camera", &ref);
                return ref;
        }
        static entry_ref Test2()
        {
                entry_ref ref;
                get_ref_for_path("/boot/develop/headers/be/Be.h", &ref);
                return ref;
        }
        static size_t SizeOf(const entry_ref& data)
        {
                BPath Path(&data);
                return Path.FlattenedSize();
        }
        inline static ArrayType Array()
        {
                ArrayType array;
                array.push_back(Zero());
                array.push_back(Test1());
                array.push_back(Test2());
                return array;
        }
};
//------------------------------------------------------------------------------
struct TRefAssertPolicy
{
        inline static entry_ref Zero()          { return TRefInitPolicy::Zero(); }
        inline static entry_ref Invalid()       { return TRefInitPolicy::Zero();}
// TODO: fix
        static bool             Size(size_t size, entry_ref& ref)
        {
                return size == TRefInitPolicy::SizeOf(ref);
        }
};
//------------------------------------------------------------------------------
typedef TMessageItemTest
<
        entry_ref,
        B_REF_TYPE,
        TRefFuncPolicy,
        TRefInitPolicy,
        TRefAssertPolicy
>
TMessageRefItemTest;

#endif  // MESSAGEREFITEMTEST_H

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