cel_endian.h

Go to the documentation of this file.

//----------------------------------------------------------------------------
//
// (C) 2003-2006 Celartem Technology Inc. All rights reserved.
//----------------------------------------------------------------------------

#ifndef _cel_endian_h_
#define _cel_endian_h_

#include "cel_system.h"

namespace Celartem
{
    enum Endian
    {
        endianBig = 1234,   
        endianLittle = 4321, 

        endianHost = ENDIAN_HOST
    };

    template<class T> T swap(const T& n);

    // 'signed char' is special; we need independent definition for this.
    template<> signed char swap<signed char>(const signed char& num);

    template<> char swap<char>(const char& num);
    template<> short swap<short>(const short& num);
    template<> int swap<int>(const int& num);
    template<> long swap<long>(const long& num);
    template<> long long swap<long long>(const long long& num);

    template<> unsigned char swap<unsigned char>(const unsigned char& num);
    template<> unsigned short swap<unsigned short>(const unsigned short& num);
    template<> unsigned int swap<unsigned int>(const unsigned int& num);
    template<> unsigned long swap<unsigned long>(const unsigned long& num);
    template<> unsigned long long swap<unsigned long long>(const unsigned long long& num);

    template<> float swap<float>(const float& num);
    template<> double swap<double>(const double& num);

    template<class T> T toBig(const T& num)
    {
        return (endianHost == endianLittle) ? swap(num) : num;
    }

    template<class T> T toLittle(const T& num)
    {
        return (endianHost == endianBig) ? swap(num) : num;
    }

    template<class T> T fromBig(const T& num)
    {
        return (endianHost == endianLittle) ? swap(num) : num;
    }

    template<class T> T fromLittle(const T& num)
    {
        return (endianHost == endianBig) ? swap(num) : num;
    }

    template<class T> void write(
        void * CEL_RESTRICT buffer, T t, Endian endian /*= endianHost*/)
    {
        if(endian != endianHost)
            t = swap<T>(t);
        std::memcpy(buffer, &t, sizeof(T));
    }

    template<class T> void writeArray(
        void * CEL_RESTRICT buffer, T * CEL_RESTRICT array, size_t count,
        Endian endian /*= endianHost*/)
    {
        for(size_t i = 0; i < count; i++)
        {
            write<T>(buffer, array[i], endian);
            buffer = ((T*)buffer) + 1;
        }
    }

    template<class T> T read(
        const void * CEL_RESTRICT buffer, Endian endian /*= endianHost*/)
    {
        T t;
        std::memcpy(&t, buffer, sizeof(T));
        if(endian != endianHost)
            return swap<T>(t);
        return t;
    }

    template<class T> void swapBytes(
        const void * CEL_RESTRICT ioBuffer, size_t inBytes)
    {
        T *p = (T *)ioBuffer;
        T const * const end = p + inBytes / sizeof(T);
        for(; p < end; p++)
            *p = swap<T>(*p);
    }

} // namespace Celartem

#endif // _cel_endian_h_

---

This document is automatically generated using doxygen 1.5.4 at Fri Jun 27 18:21:54 2008.