encodingImplHelpers.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 2010 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: encodingImplHelpers.h,v $ $Revision: 1.0 $ $State: Exp $
*********************************************************************/

#ifndef encodingImplHelpers_H_
#define encodingImplHelpers_H_

#include <rtiApiTypes.h>

#include <vlutil/vlUtil.h>

#include <RTI/encoding/EncodingConfig.h>

#include <typeinfo>
#include <cstring> 

namespace RTI_API
{
    const int endianChecker = 1;
    #define IS_MACHINE_BIG_ENDIAN() ( (*(char*)&endianChecker) == 0 )

    inline void swapByteArray( char * byteArray, int theSize )
    {
        int theEnd = 0;
        for( int i = 0; i < ( theSize >> 1 ); ++i )
        {
            theEnd = ( theSize - 1 ) - i;
            byteArray[ i ] ^= byteArray[ theEnd ];
            byteArray[ theEnd ] ^= byteArray[ i ];
            byteArray[ i ] ^= byteArray[ theEnd ];
        }
    }

    inline unsigned short endianSwap16Bit( unsigned short rhs )
    {
        unsigned short msbyte = rhs & 0x00ff;
        unsigned short lsbyte = ( rhs & 0xff00 ) >> 8;
        return ( msbyte << 8 ) | lsbyte;
    }

    template<typename T>
    inline Integer64 valueHash(T value)
    {
       return static_cast<Integer64>(value);
    }

    inline Integer64 valueHash(OctetPair value)
    {
       return (static_cast<Integer64>(value.first) << 8) + value.second;
    }

    inline unsigned int endianSwap32Bit( unsigned int rhs )
    {
        unsigned short msword = endianSwap16Bit( rhs & 0x0000ffff );
        unsigned short lsword = endianSwap16Bit(( rhs & 0xffff0000 ) >> 16 );
        return ( msword << 16 ) | lsword;
    }

    inline Integer64 endianSwap64Bit( Integer64 rhs )
    {
        unsigned int mspart = endianSwap32Bit( static_cast<unsigned int>(rhs & 0xffffffff) );
        unsigned int lspart = endianSwap32Bit(static_cast<unsigned int>(( rhs >> 32 ) & 0xffffffff) );
        return ( Integer64( mspart ) << 32 ) | lspart;
    }

    inline float endianSwap32BitFloat( float rhs )
    {
        union v 
        {
            float f; 
            unsigned int i; 
        };

        v val;
        val.f = rhs;
        val.i = endianSwap32Bit( val.i );

        return val.f;
    }

    inline double endianSwap64BitDouble( double rhs )
    {
        union v
        {
            double d;
            Integer64 i;
        };

        v val;
        val.d = rhs;
        val.i = endianSwap64Bit( val.i );
        return val.d;
    }

    inline void appendBytes( std::vector<Octet>& wrapper, const char* bytes, size_t length )
    {
        // Resize the buffer and then write to it (this is efficient if caller
        // has already reserved the space - otherwise buffer may re-alloc)
        unsigned int currentBufferSize = wrapper.size();
        wrapper.resize( currentBufferSize + length );
        memcpy( &wrapper[ currentBufferSize ], bytes, length );      
    }

    inline unsigned int paddingSizeInBytes( unsigned int bufferLength, unsigned int elementOctetBoundary )
    {
         return MAKRti::alignedPadding(bufferLength, elementOctetBoundary);
    }

    inline void insertBytes( std::vector<Octet>& wrapper, size_t length )
    {
        unsigned int currentBufferSize = wrapper.size();
        wrapper.resize( currentBufferSize + length );
    }
}

#endif