conversions.cpp

Go to the documentation of this file.

/* MAINATINER: Bernard CURENT_EDITOR: Bernard */

#include <cstdlib>
#include <cerrno>
#include <sstream>
#include "conversions.h"
#include "log.h"

using namespace std;

/*****************************************************************************/
string itos(int i) 
{
        stringstream s;
        s << i;
        return s.str();
}

/*****************************************************************************/
string iptos(unsigned long ip)
{
        
//      unsigned long l = ntohl(ip);

        stringstream s;
        /*
        s << ((l & 0xFF000000) >> 24)  << "."
          << ((l &   0xFF0000) >> 16)  << "."
          << ((l &     0xFF00) >>  8)  << "."
          << ((l &       0xFF) >>  0);
        */
        return s.str();
}



/*****************************************************************************/
bool try_get_long(const string& value, long &i)
{
        char *endptr;
        const char *orig = value.c_str();
        errno = 0;
        i = strtol(orig, &endptr, 0);
        if (errno != 0) 
        {
                g_log.perror("try_get_long strtol");
                return false;
        }
        if (orig == endptr) return false;
        if (*endptr == '\0') return true;
        
        // ?
        return false;
}

/*****************************************************************************/
bool try_get_double(const string& value, double &d)
{
        char *endptr;
        const char *orig = value.c_str();
        errno = 0;
        d = strtod(orig, &endptr);
        if (errno != 0) 
        {
                g_log.perror("try_get_double strtod");
                return false;
        }
        if (orig == endptr) return false;
        if (*endptr == '\0') return true;
        
        return false;
}


/*****************************************************************************/
bool try_get_bool(const string& value, bool &b)
{
        if (value == "1" || value == "true" || value == "yes") 
        {
                b = true;
                return true;
        }
        if (value == "0" || value == "false" || value == "no") 
        {
                b = false;
                return true;
        }
        return false;
}


/*****************************************************************************/
double get_double(const string& value)
{
        double d;
        if (!try_get_double(value,  d)) 
        {
                g_log.error() << "get_float Unable to convert " << value << " into float!" << endl;
                g_log.die("get_float Conversion MUST be OK");
        }
        return d;
}


/*****************************************************************************/
long get_long(const string& value)
{
        long i;
        if (!try_get_long(value,  i)) 
        {
                g_log.error() << "get_long Unable to convert " << value << " into long!" << endl;
                g_log.die("get_int Conversion MUST be OK");
        }
        return i;
}


/*****************************************************************************/
bool  get_bool(const string& value)
{
        bool i;
        if (!try_get_bool(value,  i)) 
        {
                g_log.error() << "get_bool Unable to convert " << value << " into bool!" << endl;
                g_log.die("get_bool Conversion MUST be OK");
        }
        return i;
}


/*****************************************************************************/
// UTF-8 decoding table:
//
//      Scalar value                     UTF-8
//                                 1st byte 2nd byte 3rd byte 4th byte
// 00000000 00000000 0xxxxxxx      0xxxxxxx
// 00000000 00000yyy yyxxxxxx      110yyyyy 10xxxxxx
// 00000000 zzzzyyyy yyxxxxxx      1110zzzz 10yyyyyy 10xxxxxx
// 000uuuuu zzzzyyyy yyxxxxxx      11110uuu 10uuzzzz 10yyyyyy 10xxxxxx
void utf8tows(const char *utf8, std::wstring &ws)
{
//      TIN
                
        // assertL(utf8 != 0);
        
        ws.erase();

//      TVARIABLE(utf8);
        
        while (*utf8 != '\0') 
        {

//              TVARIABLE(utf8);
                
                int     ln = 0;
                wchar_t  w = 0;
                
                // Processing first byte - determine how many chars will 
                // create one wchar_t
                if ( (*utf8 & 0xF8) == 0xF0 ) // is as 11110xxx
                {
                        ln = 3;
                        w  = *utf8 & 0x07;
                }
                
                if ( (*utf8 & 0xF0) == 0xE0 ) // is as 1110xxxx
                {
                        ln = 2;
                        w  = *utf8 & 0x0F;
                }
                
                if ( (*utf8 & 0xE0) == 0xC0 ) // is as 110xxxxx
                {
                        ln = 1;
                        w  = *utf8 & 0x1F;
                }
                
                if (ln == 0) 
                {
                        w =  *utf8 & 0x7F;
                        if ( (*utf8 & 0x80) != 0) // is as 1111 1xxx
                        {
                                LOGE << "ERROR IN UTF8 CONTERSION!" << endl;
                        }
                }

                // processing other chars for one wchar_t
                for (; ln > 0; --ln)  // add bytes 10xx xxxx
                {
                        ++utf8;

                        if (*utf8 == '\0') 
                        {
                                LOGE << "ERROR IN UTF8 CONTERSION!" << endl;
                                break;
                        }
                        if ( (*utf8 & 0xC0) != 0x80) // must be as 10xx xxxx
                        {
                                LOGE << "ERROR IN UTF8 CONTERSION!" << endl;
                                break;
                        }
                        w <<= 6;
                        w += *utf8 & 0x3F;
                }
        
        
                // Storing decoded wchar_t 
                ws += w;
                
                // utf8 may be == '\0' because of errors in processing
                // other character
                if (*utf8 != '\0') 
                {
                        ++utf8;
                }
        }
}


/*****************************************************************************/

/*****************************************************************************/
// UTF-8 decoding table:
//
//      Scalar value                     UTF-8
//                                 1st byte 2nd byte 3rd byte 4th byte
// 00000000 00000000 0xxxxxxx      0xxxxxxx
// 00000000 00000yyy yyxxxxxx      110yyyyy 10xxxxxx
// 00000000 zzzzyyyy yyxxxxxx      1110zzzz 10yyyyyy 10xxxxxx
// 000uuuuu zzzzyyyy yyxxxxxx      11110uuu 10uuzzzz 10yyyyyy 10xxxxxx

// append one character
void appendW(long w, std::string &utf8)
{
        int ln = 0;
        
        if (w <= 0x7F) 
        {
                utf8 += (char)(w & 0x7F);
                return;
        }

        if (w <= 0x7FF)
        {
                utf8 += (char)( ((w >> 6)&0x1F) | 0xC0); // 110yyyyy
                w &= 0x3F; // 0011 1111
                ln = 1;
        }
        else if (w <= 0xFFFF)
        {
                utf8 += (char)( ((w >> 12)&0x0F) | 0xE0); // 1110zzzz
                w &= 0x0FFF; // 0000 1111  1111 1111
                ln = 2;
        }
        else if (w <= 0x1FFFFF)
        {
                utf8 += (char)( ((w >> 18)&0x07) | 0xF0); // 11110uuu
                w &= 0x03FFFF; // 0000 0011   1111 1111   1111 1111
                ln = 3;
        }
        else 
        {
                LOGE << "Invalid unicode character - too large number!" << endl;
                return;
        }
        
        while (ln-- > 0)
        {
                utf8 += (char)(((w >> (ln*6))&0x3F) | 0x80); // 10xxxxxx
        }
}

//TODO wstoutf8
void wstoutf8(const std::wstring &ws, std::string &utf8)
{
        utf8.erase();

        for (unsigned int i = 0; i < ws.length(); i++)
                appendW(ws[i], utf8);
}

---