lmsg/Grinder.hh

/* -*- mode: c++; c-basic-offset: 4; -*- */
#ifndef LMSG_GRINDER_HH
#define LMSG_GRINDER_HH
#include "lmsg/MsgTypes.hh"
#include <string.h>

namespace lmsg {

    class Grinder {
    public:
        Grinder(void);

        ~Grinder(void);

        bool need_swap(void) const;

        template<typename T> void SwapT(T* _data);

        template<typename T> void SwapIn(const char* _in, T* _out, size_type N);

        template<typename T> void SwapOut(const T* _in, char* out, size_type N);
    private:
        bool   mBigEnd;
    };   // class Grinder

    //==================================  Need swap
    inline bool
    Grinder::need_swap(void) const {
        return !mBigEnd;
    }

    //==================================  Swap templates
    template<typename T> 
    inline void 
    Grinder::SwapT(T* _data) {
        char* fp = reinterpret_cast<char*>(_data);
        char* bp = fp + sizeof(T);
        while (fp < bp) {
            char t = *(--bp);
            *bp = *fp;
            *(fp++) = t;
        }
    }
        
    template<typename T> 
    inline void 
    Grinder::SwapIn(const char* _in, T* _out, size_type N) {
        memcpy(_out, _in, N*sizeof(T));
        if (!mBigEnd) {
            for (size_type _i=0; _i<N; ++_i) SwapT(_out+_i);
        }
    }
        
    template<typename T> 
    inline void 
    Grinder::SwapOut(const T* _in, char* _out, size_type N) {
        memcpy(_out, _in, N*sizeof(T));
        if (!mBigEnd) {
            T* _op = reinterpret_cast<T*>(_out);
            for (size_type _i=0; _i<N; ++_i) SwapT(_op+_i);
        }
    }

    extern Grinder export_format_grinder;

}  // namespace lmsg

#endif // LMSG_GRINDER_HH

---