EndianConverter.h

Go to the documentation of this file.

// -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 4; tab-width: 4; -*-
// vim: set shiftwidth=4 softtabstop=4 expandtab:
/*
 ********************************************************************
 ** NIDAS: NCAR In-situ Data Acquistion Software
 **
 ** 2006, Copyright University Corporation for Atmospheric Research
 **
 ** This program is free software; you can redistribute it and/or modify
 ** it under the terms of the GNU General Public License as published by
 ** the Free Software Foundation; either version 2 of the License, or
 ** (at your option) any later version.
 **
 ** This program is distributed in the hope that it will be useful,
 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 ** GNU General Public License for more details.
 **
 ** The LICENSE.txt file accompanying this software contains
 ** a copy of the GNU General Public License. If it is not found,
 ** write to the Free Software Foundation, Inc.,
 ** 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 **
 ********************************************************************
*/
 
#ifndef NIDAS_UTIL_ENDIANCONVERTER_H
#define NIDAS_UTIL_ENDIANCONVERTER_H
 
#include <cstring> // memcpy
#include <stdint.h>
 
#include "ThreadSupport.h"
 
namespace nidas { namespace util {
 
inline double flipDoubleIn(const void* p)
{
    union {
      double v;
      char b[8];
    } u;
    const char* cp = (const char*)p;
    for (int i = 7; i >= 0; i--) u.b[i] = *cp++;
    return u.v;
}
 
inline double flipDouble(const double& p)
{
    return flipDoubleIn(&p);
}
 
inline float flipFloatIn(const void* p)
{
    union {
      float v;
      char b[4];
    } u;
    const char* cp = (const char*)p;
    for (int i = 3; i >= 0; i--) u.b[i] = *cp++;
    return u.v;
}
inline float flipFloat(const float& p)
{
    return flipFloatIn(&p);
}
 
 
inline int64_t flipInt64In(const void* p)
{
    union {
      int64_t v;
      char b[8];
    } u;
    const char* cp = (const char*)p;
    for (int i = 7; i >= 0; i--) u.b[i] = *cp++;
    return u.v;
}
inline int64_t flipInt64(const int64_t& p)
{
    return flipInt64In(&p);
}
 
 
inline int32_t flipInt32In(const void* p)
{
    union {
      int32_t v;
      char b[4];
    } u;
    const char* cp = (const char*)p;
    for (int i = 3; i >= 0; i--) u.b[i] = *cp++;
    return u.v;
}
inline int32_t flipInt32(const int32_t& p)
{
    return flipInt32In(&p);
}
 
 
inline uint32_t flipUint32In(const void* p)
{
    union {
      uint32_t v;
      char b[4];
    } u;
    const char* cp = (const char*)p;
    for (int i = 3; i >= 0; i--) u.b[i] = *cp++;
    return u.v;
}
inline uint32_t flipUint32(const uint32_t& p)
{
    return flipUint32In(&p);
}
 
 
inline int16_t flipInt16In(const void* p)
{
    union {
      int16_t v;
      char b[2];
    } u;
    u.b[1] = ((const char*)p)[0];
    u.b[0] = ((const char*)p)[1];
    return u.v;
}
inline int16_t flipInt16(const int16_t& p)
{
    return flipInt16In(&p);
}
 
 
inline uint16_t flipUint16In(const void* p)
{
    union {
      uint16_t v;
      char b[2];
    } u;
    u.b[1] = ((const char*)p)[0];
    u.b[0] = ((const char*)p)[1];
    return u.v;
}
inline uint16_t flipUint16(const uint16_t& p)
{
    return flipUint16In(&p);
}
 
 
inline void flipDoubleOut(const double& v,void* p)
{
    union {
      double v;
      char b[8];
    } u;
    u.v = v;
    char* cp = (char*) p;
    for (int i = 7; i >= 0; i--) *cp++ = u.b[i];
}
 
inline void flipFloatOut(const float& v,void* p)
{
    union {
      float v;
      char b[4];
    } u;
    u.v = v;
    char* cp = (char*) p;
    for (int i = 3; i >= 0; i--) *cp++ = u.b[i];
}
 
inline void flipInt64Out(const int64_t& v,void* p)
{
    union {
      int64_t v;
      char b[8];
    } u;
    u.v = v;
    char* cp = (char*) p;
    for (int i = 7; i >= 0; i--) *cp++ = u.b[i];
}
 
inline void flipInt32Out(const int32_t& v,void* p)
{
    union {
      int32_t v;
      char b[4];
    } u;
    u.v = v;
    char* cp = (char*) p;
    for (int i = 3; i >= 0; i--) *cp++ = u.b[i];
}
 
inline void flipUint32Out(const uint32_t& v,void* p)
{
    union {
      uint32_t v;
      char b[4];
    } u;
    u.v = v;
    char* cp = (char*) p;
    for (int i = 3; i >= 0; i--) *cp++ = u.b[i];
}
 
inline void flipInt16Out(const int16_t &v,void* p)
{
    union {
      int16_t v;
      char b[2];
    } u;
    u.v = v;
    char* cp = (char*) p;
    cp[0] = u.b[1];
    cp[1] = u.b[0];
}
 
inline void flipUint16Out(const uint16_t& v,void *p)
{
    union {
      uint16_t v;
      char b[2];
    } u;
    u.v = v;
    char* cp = (char*) p;
    cp[0] = u.b[1];
    cp[1] = u.b[0];
}
 
class EndianConverter {
public:
 
    virtual ~EndianConverter() {}
 
    enum endianness { EC_UNKNOWN_ENDIAN, EC_BIG_ENDIAN, EC_LITTLE_ENDIAN };
 
    // typedef enum endianness endianness_t;
 
    static endianness hostEndianness;
 
    static endianness getHostEndianness();
 
    static const EndianConverter* getConverter(endianness input, endianness output);
 
    static const EndianConverter* getConverter(endianness input);
 
    virtual double doubleValue(const void* ) const = 0;
 
    virtual double doubleValue(const double& ) const = 0;
 
    virtual float floatValue(const void* ) const = 0;
 
    virtual float floatValue(const float& ) const = 0;
 
    virtual int32_t int32Value(const void* ) const = 0;
 
    virtual int32_t int32Value(const int32_t& ) const = 0;
 
    virtual int64_t int64Value(const void* ) const = 0;
 
    virtual int64_t int64Value(const int64_t& ) const = 0;
 
    virtual uint32_t uint32Value(const void* ) const = 0;
 
    virtual uint32_t uint32Value(const uint32_t& ) const = 0;
 
    virtual int16_t int16Value(const void* ) const = 0;
 
    virtual int16_t int16Value(const int16_t& ) const = 0;
 
    virtual uint16_t uint16Value(const void* ) const = 0;
 
    virtual uint16_t uint16Value(const uint16_t& ) const = 0;
 
    virtual void doubleCopy(const double&,void* ) const = 0;
 
    virtual void floatCopy(const float&,void* ) const = 0;
 
    virtual void int32Copy(const int32_t&,void* ) const = 0;
 
    virtual void int64Copy(const int64_t&,void* ) const = 0;
 
    virtual void uint32Copy(const uint32_t&, void* ) const = 0;
 
    virtual void int16Copy(const int16_t&,void* ) const = 0;
 
    virtual void uint16Copy(const uint16_t&, void* ) const = 0;
 
private:
    static endianness privGetHostEndianness();
 
    static EndianConverter* flipConverter;
 
    static EndianConverter* noflipConverter;
 
    static Mutex staticInitMutex;
};
 
class FlipConverter : public EndianConverter {
public:
 
    virtual ~FlipConverter() {}
 
    double doubleValue(const void* p) const
    {
        return flipDoubleIn(p);
    }
 
    double doubleValue(const double& p) const
    {
        return flipDouble(p);
    }
 
    float floatValue(const void* p) const
    {
        return flipFloatIn(p);
    }
 
    float floatValue(const float& p) const
    {
        return flipFloat(p);
    }
 
    int64_t int64Value(const void* p) const
    {
        return flipInt64In(p);
    }
 
    int64_t int64Value(const int64_t& p) const
    {
        return flipInt64(p);
    }
 
    int32_t int32Value(const void* p) const
    {
        return flipInt32In(p);
    }
 
    int32_t int32Value(const int32_t& p) const
    {
        return flipInt32(p);
    }
 
    uint32_t uint32Value(const void* p) const
    {
        return flipUint32In(p);
    }
 
    uint32_t uint32Value(const uint32_t& p) const
    {
        return flipUint32(p);
    }
 
    int16_t int16Value(const void* p) const
    {
        return flipInt16In(p);
    }
 
    int16_t int16Value(const int16_t& p) const
    {
        return flipInt16(p);
    }
 
    uint16_t uint16Value(const void* p) const
    {
        return flipUint16In(p);
    }
 
    uint16_t uint16Value(const uint16_t& p) const
    {
        return flipUint16(p);
    }
 
    void doubleCopy(const double& v,void* p) const
    {
        return flipDoubleOut(v,p);
    }
 
    void floatCopy(const float& v,void* p) const
    {
        return flipFloatOut(v,p);
    }
 
    void int64Copy(const int64_t& v,void* p) const
    {
        return flipInt64Out(v,p);
    }
 
    void int32Copy(const int32_t& v,void* p) const
    {
        return flipInt32Out(v,p);
    }
 
    void uint32Copy(const uint32_t& v,void* p) const
    {
        return flipUint32Out(v,p);
    }
 
    void int16Copy(const int16_t &v,void* p) const
    {
        return flipInt16Out(v,p);
    }
 
    void uint16Copy(const uint16_t& v,void *p) const
    {
        return flipUint16Out(v,p);
    }
};
 
class NoFlipConverter : public EndianConverter {
public:
    virtual ~NoFlipConverter() {}
 
    double doubleValue(const void* p) const
    {
        double v;
        memcpy(&v,p,sizeof(double));
        return v;
    }
 
    double doubleValue(const double& p) const
    {
        return p;
    }
 
    float floatValue(const void* p) const
    {
        float v;
        memcpy(&v,p,sizeof(float));
        return v;
    }
 
    float floatValue(const float& p) const
    {
        return p;
    }
 
    int64_t int64Value(const void* p) const
    {
        int64_t v;
        memcpy(&v,p,sizeof(int64_t));
        return v;
    }
 
    int64_t int64Value(const int64_t& p) const
    {
        return p;
    }
 
    int32_t int32Value(const void* p) const
    {
        int32_t v;
        memcpy(&v,p,sizeof(int32_t));
        return v;
    }
 
    int32_t int32Value(const int32_t& p) const
    {
        return p;
    }
 
    uint32_t uint32Value(const void* p) const
    {
        uint32_t v;
        memcpy(&v,p,sizeof(uint32_t));
        return v;
    }
 
    uint32_t uint32Value(const uint32_t& p) const
    {
        return p;
    }
 
    int16_t int16Value(const void* p) const
    {
        union {
          int16_t v;
          char b[2];
        } u;
        u.b[0] = ((const char*)p)[0];
        u.b[1] = ((const char*)p)[1];
        return u.v;
    }
 
    int16_t int16Value(const int16_t& p) const
    {
        return p;
    }
 
    uint16_t uint16Value(const void* p) const
    {
        union {
          uint16_t v;
          char b[2];
        } u;
        u.b[0] = ((const char*)p)[0];
        u.b[1] = ((const char*)p)[1];
        return u.v;
    }
 
    uint16_t uint16Value(const uint16_t& p) const
    {
        return p;
    }
 
    void doubleCopy(const double& v,void* p) const
    {
        memcpy(p,&v,sizeof(double));
    }
 
    void floatCopy(const float& v,void* p) const
    {
        memcpy(p,&v,sizeof(float));
    }
 
    void int64Copy(const int64_t& v,void* p) const
    {
        memcpy(p,&v,sizeof(int64_t));
    }
 
    void int32Copy(const int& v,void* p) const
    {
        memcpy(p,&v,sizeof(int32_t));
    }
 
    void uint32Copy(const uint32_t& v,void* p) const
    {
        memcpy(p,&v,sizeof(uint32_t));
    }
 
    void int16Copy(const int16_t &v,void* p) const
    {
        memcpy(p,&v,sizeof(int16_t));
#ifdef BOZO
        union {
          int16_t v;
          char b[2];
        } u;
        u.v = v;
        ((char*)p)[0] = u.b[1];
        ((char*)p)[1] = u.b[0];
#endif
    }
 
    void uint16Copy(const uint16_t& v,void* p) const {
        memcpy(p,&v,sizeof(uint16_t));
#ifdef BOZO
        union {
          uint16_t v;
          char b[2];
        } u;
        u.v = v;
        ((char*)p)[0] = u.b[1];
        ((char*)p)[1] = u.b[0];
#endif
    }
};
}}  // namespace nidas namespace util
#endif