clshexcoder.cpp

set of classes for coding hex to bin and bin to hex

#include "clshexcoder.h"

#define DEFAULT_BIN_ARRAY_LEN 1024

//#############################################################################

clsHexCoder::clsHexCoder():
//    m_szMyString ( )
    m_lArraySize ( 0 ),
    m_lArrayUsed ( 0 ),
    m_pBinArray ( 0 )
{
    ReserveArray ( DEFAULT_BIN_ARRAY_LEN );
}

//#############################################################################

clsHexCoder::~clsHexCoder()
{
    if ( m_pBinArray )
    {
        delete [] m_pBinArray;
        m_pBinArray = 0;
    }
    m_lArraySize = 0;
    m_lArrayUsed = 0;
}

//#############################################################################

int             clsHexCoder::HexToBin        ( const char* pHexChars )
{
    if ( ! pHexChars )
        return ErrBadInputData;
    if ( ! m_pBinArray )
        return ErrNoBinArray;
    memset ( m_pBinArray , 0x00 , m_lArraySize );
    m_lArrayUsed = 0;

    unsigned int iLen = strlen ( pHexChars );
    if ( ! iLen || iLen%2 )
        return ErrBadInputData;

    char cTmp;
    unsigned char cTmpBin;
    unsigned int iLimit = m_lArraySize * 2;
    for ( unsigned int i = 0 ; i < iLen && i < iLimit ; i+=2 )
    {
        cTmp = pHexChars [ i ];
        if ( cTmp >= '0' && cTmp <= '9' )
            cTmpBin = cTmp -'0';
        else if ( cTmp >= 'a' && cTmp <= 'f' )
            cTmpBin = 10 + cTmp -'a';
        else if ( cTmp >= 'A' && cTmp <= 'F' )
            cTmpBin = 10 + cTmp -'A';
        else
            return ErrBadInputData;

        cTmpBin *= 16;

        cTmp = pHexChars [ i+1 ];
        if ( cTmp >= '0' && cTmp <= '9' )
            cTmpBin += cTmp -'0';
        else if ( cTmp >= 'a' && cTmp <= 'f' )
            cTmpBin += 10 + cTmp -'a';
        else if ( cTmp >= 'A' && cTmp <= 'F' )
            cTmpBin += 10 + cTmp -'A';
        else
            return ErrBadInputData;

        m_pBinArray [ i >> 1 ] = cTmpBin;
        m_lArrayUsed = ( i >> 1 ) + 1;
    }

    return NoError;
}

//#############################################################################

int             clsHexCoder::HexToBin        ( const std::string& rHexString )
{
    return HexToBin ( rHexString.c_str() );
}

//#############################################################################

int             clsHexCoder::BinToHex        ( const void* pBin , unsigned long lArraySize )
{
    m_szMyString.clear();
    if ( ! pBin || ! lArraySize )
        return ErrBadInputData;

    const unsigned char* pBinChar = reinterpret_cast<const unsigned char*>(pBin);

    char aTmp[4] = { 0,0,0,0 };
    unsigned char cTmpBin;
    for ( unsigned long l = 0 ; l < lArraySize ; ++l )
    {
        cTmpBin = pBinChar [ l ];
        aTmp[0] = cTmpBin >> 4; // /16;
        aTmp[1] = cTmpBin & 0x0F; // % 16;

        if ( aTmp[0] < 0x0A )
            aTmp[0] = '0' + aTmp[0];
        else // ( aTmp[0] >= 0x0A )
            aTmp[0] = 'A' + aTmp[0] - 10;

        if ( aTmp[1] < 0x0A )
            aTmp[1] = '0' + aTmp[1];
        else // ( aTmp[0] >= 0x0A )
            aTmp[1] = 'A' + aTmp[1] - 10;

        m_szMyString.append ( aTmp );
    }

    return NoError;
}

//#############################################################################

void            clsHexCoder::ReserveArray    ( unsigned long lArraySize )
{
    if ( m_pBinArray )
    {
        delete [] m_pBinArray;
        m_pBinArray = 0;
    }
    m_pBinArray = new unsigned char[lArraySize];
    if ( m_pBinArray )
        m_lArraySize = lArraySize;
    m_lArrayUsed = 0;
}

//#############################################################################