#ifndef _MESSAGE_UTILS_H_
#define _MESSAGE_UTILS_H_

#include <ByteOrder.h>
#include <DataIO.h>
#include <Entry.h>
#include <Message.h>
#include <Node.h>
#include <SupportDefs.h>


namespace BPrivate {    // Only putting these here because Be did

// entry_ref
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);

// node_ref
status_t node_ref_flatten(char* buffer, size_t* size, const node_ref* ref);
status_t node_ref_unflatten(node_ref* ref, const char* buffer, size_t size);
status_t node_ref_swap(char* buffer, size_t size);

uint32 CalculateChecksum(const uint8 *buffer, int32 size);

}       // namespace BPrivate


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 error = stream->Write(data, size);
        if (error < B_OK)
                throw error;
}


class TReadHelper {
public:
                                                        TReadHelper(BDataIO *stream)
                                                                :       fStream(stream),
                                                                        fError(B_OK),
                                                                        fSwap(false)
                                                        {
                                                        }

                                                        TReadHelper(BDataIO *stream, bool swap)
                                                                :       fStream(stream),
                                                                        fError(B_OK),
                                                                        fSwap(swap)
                                                        {
                                                        }

                template<class T>
                inline void                     operator()(T &data)
                                                        {
                                                                fError = fStream->Read((void *)&data, sizeof(T));
                                                                if (fError > B_OK) {
                                                                        if (IsSwapping())
                                                                                byte_swap(data);
                                                                        return;
                                                                }

                                                                if (fError == 0)
                                                                        fError = B_ERROR;
                                                                throw fError;
                                                        }

                template<class T>
                inline void                     operator()(T data, size_t len)
                                                        {
                                                                fError = fStream->Read((void *)data, len);
                                                                if (fError >= B_OK)
                                                                        return;

                                                                throw fError;
                                                        }

                status_t                        Status() const { return fError >= B_OK ? B_OK : fError; }

                void                            SetSwap(bool yesNo) { fSwap = yesNo; }
                bool                            IsSwapping() const { return fSwap; }

private:
                BDataIO                         *fStream;
                status_t                        fError;
                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<>
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(uint64 &data)
{
        data = __swap_int64(data);
}


template<>
inline void
byte_swap(int32 &data)
{
        data = __swap_int32(data);
}


template<>
inline void
byte_swap(uint32 &data)
{
        data = __swap_int32(data);
}


template<>
inline void
byte_swap(int16 &data)
{
        data = __swap_int16(data);
}


template<>
inline void
byte_swap(uint16 &data)
{
        data = __swap_int16(data);
}


template<>
inline void
byte_swap(entry_ref &data)
{
        byte_swap(data.device);
        byte_swap(data.directory);
}

#endif  // _MESSAGE_UTILS_H_