char_strings.hpp

Go to the documentation of this file.

 
/*****************************************************************************
** Ifdefs
*****************************************************************************/
 
#ifndef ECL_CONVERTERS_CONVERT_CHAR_STRINGS_HPP_
#define ECL_CONVERTERS_CONVERT_CHAR_STRINGS_HPP_
 
/*****************************************************************************
** Includes
*****************************************************************************/
 
#include <cstdio> // vsnprintf
#include <cstring> //strcat
#include <new>
#include "converter.hpp"
#include <ecl/errors/handlers.hpp>
#include <ecl/exceptions/standard_exception.hpp>
#include <ecl/mpl/converters.hpp>
 
#if _MSC_VER
#define snprintf _snprintf
#endif
 
/*****************************************************************************
** Namespaces
*****************************************************************************/
 
namespace ecl {
 
namespace converters {
 
/*****************************************************************************
** Inheritable Buffer Interface
*****************************************************************************/
class CharStringBuffer : public ConverterBase {
    protected:
        /******************************************
        ** C&D's
        *******************************************/
        CharStringBuffer(char* begin, char* end) : buffer_begin(begin),buffer_end(end),delete_buffer(false) {}
        CharStringBuffer(int buffer_size = 250) : delete_buffer(true) {
                buffer_begin = new (std::nothrow) char[buffer_size];
                buffer_end = buffer_begin + (buffer_size-1);
                if ( buffer_begin == NULL ) {
                        ecl_debug_throw(ecl::StandardException(LOC,ecl::MemoryError,"Failed to allocate memory for the char string buffer."));
                        error_handler = ecl::MemoryError;
                }
        }
        virtual ~CharStringBuffer() {
                if(delete_buffer) {
                        delete[] buffer_begin;
                        delete_buffer = false;
                }
        }
 
        char *buffer_begin;
        char *buffer_end;
        bool delete_buffer;
};
 
/*****************************************************************************
** Character String Converter Utilities
*****************************************************************************/
template <typename Number>
char* convertUnsignedIntegral(Number number, char* buffer_begin, char* buffer_end)
{
    *buffer_end = 0; // Set to the null terminator
    Number lsd;
    char* str_ptr = buffer_end;
 
    do {
        lsd = static_cast<Number>(number % 10);     // Determine the least significant digit.
        number = static_cast<Number>(number / 10);  // Deal with next most significant.
        --str_ptr;
        if ( str_ptr < buffer_begin ) { return NULL; }
        *str_ptr = '0'+lsd;
    } while (number != 0);
    return str_ptr;
};
 
template <typename Number>
char* convertSignedIntegral(const Number &number, char* buffer_begin, char* buffer_end)
{
    typedef typename Unsigned<Number>::type UnsignedNumber;
 
    char *s;
    if ( number >= 0 ) {
        s = convertUnsignedIntegral(static_cast<UnsignedNumber>(number),buffer_begin,buffer_end);
    } else {
        s = convertUnsignedIntegral(static_cast<UnsignedNumber>(-1*number),buffer_begin+1,buffer_end);
        --s;
        *s = '-';
    }
    return s;
}
 
 
}; // namespace converters
 
/*****************************************************************************
** Char String Converters [char]
*****************************************************************************/
template<>
class Converter<char*,char> : public virtual converters::CharStringBuffer {
    public:
        /******************************************
        ** C&D's
        *******************************************/
        Converter(char* begin, char* end) : converters::CharStringBuffer(begin,end) {}
        Converter(int buffer_size = 250) :
                        converters::CharStringBuffer(buffer_size) {}
 
        virtual ~Converter() {}
 
        /******************************************
        ** Converters
        *******************************************/
        char* operator ()(const char &input) {
            return converters::convertUnsignedIntegral(input,this->buffer_begin,this->buffer_end);
        }
};
/*****************************************************************************
** Char String Converters [unsigned char]
*****************************************************************************/
template<>
class Converter<char*,unsigned char> : public virtual converters::CharStringBuffer {
    public:
        /******************************************
        ** C&D's
        *******************************************/
        Converter(char* begin, char* end) : converters::CharStringBuffer(begin,end) {}
        Converter(int buffer_size = 250) : converters::CharStringBuffer(buffer_size) {}
 
        virtual ~Converter() {}
 
        /******************************************
        ** Converters
        *******************************************/
        char* operator ()(const unsigned char &input){ return converters::convertUnsignedIntegral(input,this->buffer_begin,this->buffer_end); }
};
/*****************************************************************************
** Char String Converters [short]
*****************************************************************************/
template<>
class Converter<char*,short> : public virtual converters::CharStringBuffer {
    public:
        /******************************************
        ** C&D's
        *******************************************/
        Converter(char* begin, char* end) : converters::CharStringBuffer(begin,end) {}
        Converter(int buffer_size = 250) : converters::CharStringBuffer(buffer_size) {}
 
        virtual ~Converter() {}
 
        /******************************************
        ** Converters
        *******************************************/
        char* operator ()(const short &input){ return converters::convertSignedIntegral(input,this->buffer_begin,this->buffer_end); }
};
/*****************************************************************************
** Char String Converters [unsigned short]
*****************************************************************************/
template<>
class Converter<char*,unsigned short> : public virtual converters::CharStringBuffer {
    public:
        /******************************************
        ** C&D's
        *******************************************/
        Converter(char* begin, char* end) : converters::CharStringBuffer(begin,end) {}
        Converter(int buffer_size = 250) : converters::CharStringBuffer(buffer_size) {}
 
        virtual ~Converter() {}
 
        /******************************************
        ** Converters
        *******************************************/
        char* operator ()(const unsigned short &input){ return converters::convertUnsignedIntegral(input,this->buffer_begin,this->buffer_end); }
};
 
/*****************************************************************************
** Char String Converters [int]
*****************************************************************************/
template<>
class Converter<char*,int> : public virtual converters::CharStringBuffer {
    public:
        Converter(char* begin, char* end) : converters::CharStringBuffer(begin,end) {}
        Converter(int buffer_size = 250) : converters::CharStringBuffer(buffer_size) {}
 
        virtual ~Converter() {}
 
        char* operator ()(const int &input){ return converters::convertSignedIntegral(input,this->buffer_begin,this->buffer_end); }
};
/*****************************************************************************
** Char String Converters [unsigned int]
*****************************************************************************/
template<>
class Converter<char*,unsigned int> : public virtual converters::CharStringBuffer {
    public:
        /******************************************
        ** C&D's
        *******************************************/
        Converter(char* begin, char* end) : converters::CharStringBuffer(begin,end) {}
        Converter(int buffer_size = 250) : converters::CharStringBuffer(buffer_size) {}
 
        virtual ~Converter() {}
 
        /******************************************
        ** Converters
        *******************************************/
        char* operator ()(const unsigned int &input){ return converters::convertUnsignedIntegral(input,this->buffer_begin,this->buffer_end); }
};
 
/*****************************************************************************
** Char String Converters [long]
*****************************************************************************/
template<>
class Converter<char*,long> : public virtual converters::CharStringBuffer {
    public:
        /******************************************
        ** C&D's
        *******************************************/
        Converter(char* begin, char* end) : converters::CharStringBuffer(begin,end) {}
        Converter(int buffer_size = 250) : converters::CharStringBuffer(buffer_size) {}
 
        virtual ~Converter() {}
 
        /******************************************
        ** Converters
        *******************************************/
        char* operator ()(const long &input){ return converters::convertSignedIntegral(input,this->buffer_begin,this->buffer_end); }
};
/*****************************************************************************
** Char String Converters [unsigned long]
*****************************************************************************/
template<>
class Converter<char*,unsigned long> : public virtual converters::CharStringBuffer {
    public:
        Converter(char* begin, char* end) : converters::CharStringBuffer(begin,end) {}
        Converter(int buffer_size = 250) : converters::CharStringBuffer(buffer_size) {}
 
        virtual ~Converter() {}
 
        char* operator ()(const unsigned long &input){ return converters::convertUnsignedIntegral(input,this->buffer_begin,this->buffer_end); }
};
/*****************************************************************************
** Char String Converters [long long]
*****************************************************************************/
template<>
class Converter<char*,long long> : public virtual converters::CharStringBuffer {
    public:
        Converter(char* begin, char* end) : converters::CharStringBuffer(begin,end) {}
        Converter(int buffer_size = 250) : converters::CharStringBuffer(buffer_size) {}
 
        virtual ~Converter() {}
 
        char* operator ()(const long long &input){ return converters::convertSignedIntegral(input,this->buffer_begin,this->buffer_end); }
};
/*****************************************************************************
** Char String Converters [unsigned long long]
*****************************************************************************/
template<>
class Converter<char*,unsigned long long> : public virtual converters::CharStringBuffer {
    public:
        Converter(char* begin, char* end) : converters::CharStringBuffer(begin,end) {
        }
        Converter(int buffer_size = 250) : converters::CharStringBuffer(buffer_size) {
        }
 
        virtual ~Converter() {}
 
        char* operator ()(const unsigned long long &input){ return converters::convertUnsignedIntegral(input,this->buffer_begin,this->buffer_end); }
};
/*****************************************************************************
** Char String Converters [float]
*****************************************************************************/
template<>
class Converter<char*,float> : public virtual converters::CharStringBuffer {
    public:
        /******************************************
        ** C&D's
        *******************************************/
        Converter(char* begin, char* end) : converters::CharStringBuffer(begin,end) {
                format_specifier[0] = '%';
                format_specifier[1] = '.';
                format_specifier[2] = 'x';
                format_specifier[3] = 'f';
                format_specifier[4] = 'f';
                format_specifier[5] = '\0';
        }
        Converter(int buffer_size = 250) : converters::CharStringBuffer(buffer_size) {
                format_specifier[0] = '%';
                format_specifier[1] = '.';
                format_specifier[2] = 'x';
                format_specifier[3] = 'f';
                format_specifier[4] = 'f';
                format_specifier[5] = '\0';
        }
 
        virtual ~Converter() {}
 
        /******************************************
        ** Converters
        *******************************************/
        char* operator ()(const float &input, const int& precision = -1){
                if ( precision < 0 ) {
                format_specifier[1] = 'f';
                format_specifier[2] = '\0';
                } else if ( precision < 10 ) {
                format_specifier[1] = '.';
                format_specifier[2] = '0'+precision;
                format_specifier[3] = 'f';
                format_specifier[4] = '\0';
            } else if ( precision < 20 )  {
                format_specifier[1] = '.';
                format_specifier[2] = '1';
                format_specifier[3] = '0'+(precision - 10);
                format_specifier[4] = 'f';
            } else {
                format_specifier[1] = '.';
                format_specifier[2] = '2';
                format_specifier[3] = '0';
                format_specifier[4] = 'f';
            }
 
            snprintf(this->buffer_begin, this->buffer_end-this->buffer_begin, format_specifier, input);
            return this->buffer_begin;
//            return converters::convertDecimal<32>(input,this->buffer_begin,this->buffer_end);
        }
    private:
        char format_specifier[6];
};
/*****************************************************************************
** Char String Converters [double]
*****************************************************************************/
template<>
class Converter<char*,double> : public virtual converters::CharStringBuffer {
    public:
        /******************************************
        ** C&D's
        *******************************************/
        Converter(char* begin, char* end) : converters::CharStringBuffer(begin,end) {
                format_specifier[0] = '%';
                format_specifier[1] = '.';
                format_specifier[2] = 'x';
                format_specifier[3] = 'f';
                format_specifier[4] = 'f';
                format_specifier[5] = '\0';
        }
        Converter(int buffer_size = 250) : converters::CharStringBuffer(buffer_size) {
                format_specifier[0] = '%';
                format_specifier[1] = '.';
                format_specifier[2] = 'x';
                format_specifier[3] = 'f';
                format_specifier[4] = 'f';
                format_specifier[5] = '\0';
        }
 
        virtual ~Converter() {}
 
        /******************************************
        ** Converters
        *******************************************/
        char* operator ()(const double &input, const int& precision = -1){
                if ( precision < 0 ) {
                format_specifier[1] = 'f';
                format_specifier[2] = '\0';
                } else if ( precision < 10 ) {
                format_specifier[1] = '.';
                format_specifier[2] = '0'+precision;
                format_specifier[3] = 'f';
                format_specifier[4] = '\0';
            } else if ( precision < 20 )  {
                format_specifier[1] = '.';
                format_specifier[2] = '1';
                format_specifier[3] = '0'+(precision - 10);
                format_specifier[4] = 'f';
            } else {
                format_specifier[1] = '.';
                format_specifier[2] = '2';
                format_specifier[3] = '0';
                format_specifier[4] = 'f';
            }
            snprintf(this->buffer_begin, this->buffer_end-this->buffer_begin, format_specifier, input);
            return this->buffer_begin;
//            return converters::convertDecimal<64>(input,this->buffer_begin,this->buffer_end);
        }
    private:
        char format_specifier[6];
};
/*****************************************************************************
** Char String Converters [bool]
*****************************************************************************/
template<>
class Converter<char*,bool> : public virtual converters::CharStringBuffer {
    public:
        Converter() : converters::CharStringBuffer(6) {}
 
        virtual ~Converter() {}
 
        char* operator ()(const bool &input){
            *buffer_begin = '\0';
            input ? strcat(buffer_begin,"true") : strcat (buffer_begin,"false");
            return buffer_begin;
        }
};
 
/*****************************************************************************
 * Char String Converter Family
 ****************************************************************************/
template <>
class Converter<char*,void>  :
    public Converter<char*,char>,
    public Converter<char*,short>,
    public Converter<char*,int>,
    public Converter<char*,long>,
    public Converter<char*,unsigned char>,
    public Converter<char*,unsigned short>,
    public Converter<char*,unsigned int>,
    public Converter<char*,unsigned long>,
    public Converter<char*,float>,
    public Converter<char*,double>,
    public Converter<char*,long long>,
    public Converter<char*,unsigned long long>,
    public Converter<char*,bool>
{
    public:
        Converter(char* begin, char* end) : converters::CharStringBuffer(begin,end) {
        }
        Converter(int buffer_size = 250) : converters::CharStringBuffer(buffer_size) {
        }
 
        virtual ~Converter() {}
 
        using Converter<char*,char>::operator();
        using Converter<char*,short>::operator();
        using Converter<char*,int>::operator();
        using Converter<char*,long>::operator();
        using Converter<char*,unsigned char>::operator();
        using Converter<char*,unsigned short>::operator();
        using Converter<char*,unsigned int>::operator();
        using Converter<char*,unsigned long>::operator();
        using Converter<char*,float>::operator();
        using Converter<char*,double>::operator();
        using Converter<char*,long long>::operator();
        using Converter<char*,unsigned long long>::operator();
        using Converter<char*,bool>::operator();
};
 
}; // Namespace ecl
 
#endif /*ECL_CONVERTERS_CONVERT_CHAR_STRINGS_HPP_*/