utils.h

Go to the documentation of this file.

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

  ColorBox2: utils.h
    (c) 2004 by Martin Decky

  Common datatypes, classes, macros.
  
  Distributed under the terms of Lesser General Public Licence, see
  COPYING.

  0.3           10th August 2004        complete rewrite, C++
  0.4           10th September 2004     reverse iterators
  0.5           15th September 2004     this_types, storage_types, cleanup

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


#ifndef __CB2__UTILS_H__
#define __CB2__UTILS_H__


#include <math.h>
#include <string>
#include <ostream>


#define CB2_ASSERT(cond, warning) \
    if (!(cond)) \
        throw ExceptionAssert(warning ": " #cond " in " __FILE__, __LINE__);


#define CB2_CONVERSION(cond, warning) \
    if (!(cond)) \
        throw ExceptionConversion(warning ": " #cond " in " __FILE__, __LINE__);
        

#define CB2_RANGECHECK(cond, value) \
    if (!(cond)) \
        throw ExceptionRange< typeof(value)>(#cond ": Value " #value "=", value, " is out of range in " __FILE__, __LINE__);
        
        
#define CB2_MEMORYCHECK(cond) \
    if (!(cond)) \
        throw ExceptionMemory(#cond ": Memory dereference fault in " __FILE__, __LINE__);


#define CB2_NOTFOUND(cond) \
    if (!(cond)) \
        throw ExceptionNotFound(#cond ": Item not found in " __FILE__, __LINE__);


namespace CB2 {
    
    
    class Class {
        public:
            int tag; 
    };
    
    
    template< class Tsize> class ExceptionRange; 
    class ExceptionConversion;                   
    class ExceptionMemory;                       
    class ExceptionAssert;                       
    class ExceptionNotFound;                     
    template< class Tcontainer, class Tref, class Tmemb> class Iterator : public Class {
        public:
        
            typedef Iterator< Tcontainer, Tref, Tmemb> this_type; 
            Iterator(const Tcontainer & cont, const Tref & reference)
                : container(cont) {
                ref = reference;
            }
            
            
            const this_type & operator++() {
                ref = container.RefNext(ref);
                return *this;
            }
            
            
            bool operator==(const this_type & it) const {
                return (ref == it.ref);
            }
            
            bool operator!=(const this_type & it) const {
                return (!operator==(it));
            }
            
            
            const Tmemb & operator*() const {
                return container.Deref(ref);
            }
            
            const Tmemb * operator->() const {
                return &container.Deref(ref);
            }
            
        private:
            
            const Tcontainer & container; 
            Tref ref;                     
    };
    
    
    template< class Tcontainer, class Tref, class Tmemb> class RevIterator : public Class {
        public:
            
            typedef RevIterator< Tcontainer, Tref, Tmemb> this_type; 
            RevIterator(const Tcontainer & cont, const Tref & reference)
                : container(cont) {
                ref = reference;
            }
            
            
            const this_type & operator--() {
                ref = container.RefPrev(ref);
                return *this;
            }
            
            
            bool operator==(const this_type & it) const {
                return (ref == it.ref);
            }
            
            bool operator!=(const this_type & it) const {
                return (!operator==(it));
            }
            
            
            const Tmemb & operator*() const {
                return container.RevDeref(ref);
            }
            
            const Tmemb * operator->() const {
                return &container.RevDeref(ref);
            }
            
        private:
            
            const Tcontainer & container; 
            Tref ref;                     
    };
    
    
    template< class Tmemb> class Array : public Class {
        public:
        
            typedef Array< Tmemb> this_type;                               
            typedef size_t size_type;                                      
            typedef Tmemb * ref_type;                                      
            typedef Iterator< this_type, ref_type, Tmemb> iterator;        
            typedef RevIterator< this_type, ref_type, Tmemb> rev_iterator; 
            Array(const size_type fragment = 4096) {
                /* Empty data */
                data = NULL;
                allocated = 0;
                frag = fragment;
                allocate(0);
            }
            
            
            Array(const this_type & prev) {
                /* Empty data */
                data = NULL;
                allocated = 0;
                frag = prev.frag;
                privatize(prev);
            }
            
            
            ~Array() {
                if (data) /* Dispose data */
                    delete[] data;
            }
            
            
            const this_type & operator=(const this_type & prev) {
                if (&prev != this) { /* No self-assignment */
                    frag = prev.frag;
                    privatize(prev);
                }
                return *this;
            }
            
            
            operator const Tmemb * () const {
                return (const Tmemb * ) data;
            }
            
            
            const this_type & operator<<(const Tmemb & prev) {
                allocate(len + 1);
                memcpy(data + len - 1, &prev, sizeof(Tmemb));
                
                return *this;
            }
            
            
            const this_type & operator>>(const Tmemb & prev) {
                allocate(len + 1);
                
                /* Shift original items
                   and put new item at the beginning */
                memmove(data + 1, data, len - 1);
                memcpy(data, &prev, sizeof(Tmemb));
                
                return *this;
            }
            
            
            const this_type & operator+=(const size_type nmemb) {
                allocate(len + nmemb);
                return *this;
            }
            
            
            const this_type & operator-=(const size_type nmemb) {
                if (nmemb > len)
                    allocate(0);
                else
                    allocate(len - nmemb);
                
                return *this;
            }
            
            
            Tmemb & operator[](const size_type pos) const {
                CB2_RANGECHECK(pos < len, pos);
                return data[pos];
            }
            
            
            void Fill(const Tmemb * buffer, const size_type nmemb) {
                allocate(nmemb);
                memmove(data, buffer, sizeof(Tmemb) * nmemb);
            }
            
            
            void Discart(const bool shrink = false) {
                if (shrink) {
                    /* Dispose data */
                    if (data)
                        delete[] data;
                    data = NULL;
                    allocated = 0;
                }
                allocate(0);
            }
            
            
            size_type Len() const {
                return len;
            }
            
            
            bool Empty() const {
                return (len == 0);
            }
            
            
            ref_type RefBegin() const {
                if (Len() > 0)
                    return data;
                    
                return NULL;
            }
            
            
            ref_type RefEnd() const {
                size_type len = Len();
                
                if (len > 0)
                    return (data + len);
                    
                return NULL;
            }
            
            
            ref_type RevRefBegin() const {
                return RefEnd();
            }
    
            
            ref_type RevRefEnd() const {
                return RefBegin();
            }
            
            
            ref_type RefNext(const ref_type & prev) const {
                if ((prev >= RefEnd()) || (prev < RefBegin())) /* Check pointer range */
                    return RefEnd();
                
                return (prev + 1);
            }
            
            
            ref_type RefPrev(const ref_type & prev) const {
                if ((prev <= RevRefEnd()) || (prev > RevRefBegin())) /* Check pointer range */
                    return RevRefEnd();
                
                return (prev - 1);
            }
            
            
            const Tmemb & Deref(const ref_type & ref) const {
                /* Check pointer range */
                CB2_MEMORYCHECK((ref < RefEnd()) && (ref >= RefBegin()));
                return (*ref);
            }
            
            
            const Tmemb & RevDeref(const ref_type & ref) const {
                /* Check pointer range */
                CB2_MEMORYCHECK((ref > RevRefEnd()) && (ref <= RevRefBegin()));
                return (*(ref - 1));
            }
            
            
            iterator Begin() const {
                return iterator(*this, RefBegin());
            }
            
            
            iterator End() const {
                return iterator(*this, RefEnd());
            }
            
            
            rev_iterator RevBegin() const {
                return rev_iterator(*this, RevRefBegin());
            }
            
            
            rev_iterator RevEnd() const {
                return rev_iterator(*this, RevRefEnd());
            }
            
            
            void Cut(const size_type pos, const size_type cnt) {
                /* Range check */
                CB2_RANGECHECK(pos < len, pos);
                CB2_RANGECHECK(pos + cnt <= len, pos);
                
                if (cnt > 0) {
                    size_type mv = len - pos - cnt;
                    
                    if (mv > 0) /* Shift items front */
                        memmove(data + pos, data + pos + cnt, sizeof(Tmemb) * mv);
                    
                    /* Discart overlapping items */
                    allocate(len - cnt);
                }
            }
            
            
            void Insert(const size_type pos, const size_type cnt, const this_type & ins) {
                CB2_ASSERT(&ins != this, "Cannot insert self-referred items");
            
                /* Range check */
                CB2_RANGECHECK(pos < len, pos);
                CB2_RANGECHECK(cnt < ins.Len(), cnt);
                
                size_t mv = len - pos;

                allocate(len + cnt);
                if (mv > 0) /* Shift items back */
                    memmove(data + pos + cnt, data + pos, sizeof(Tmemb) * mv);
                
                /* Insert items */
                memcpy(data + pos, ins.data, sizeof(Tmemb) * cnt);
            }
            
        private:

            Tmemb * data;        
            size_type allocated; 
            size_type len;       
            size_type frag;      
            void allocate(const size_type nlen) {
                /* Round items to nearest fragment */
                len = nlen;
                size_type nalloc = ((len / frag) + 1) * frag;
                    
                if (nalloc > allocated) { /* Enlarge memory pool */
                    Tmemb * newdata = new Tmemb[nalloc];
                    if (data != NULL) {
                        memcpy(newdata, data, sizeof(Tmemb) * allocated);
                        delete[] data;
                    }
                    data = newdata;
                    allocated = nalloc;
                }
            }
            
            
            void privatize(const this_type & prev) {
                if (&prev != this) {
                    allocate(prev.len);
                    memcpy(data, prev.data, sizeof(Tmemb) * prev.len);
                }
            }
            
    };
    
    
    template< class Tchar> class PString; 
    template< class Tchar> PString< Tchar> operator+(const PString< Tchar> & left, const PString< Tchar> & right) {
        PString< Tchar> output(left);
        output += right;
        return output;
    }
    
    
    template< class Tchar> std::basic_ostream< Tchar, std::char_traits< Tchar> > & operator<<(std::basic_ostream< Tchar, std::char_traits< Tchar> > & stream, const PString< Tchar> & str) {
        stream.write(str.data, str.Len());
        return stream;
    }
    
    
    template< class Tchar> class PString : public Class {
        public:
            
            typedef PString< Tchar> this_type;                             
            typedef Array< Tchar> storage_type;                            
            typedef typename storage_type::size_type size_type;            
            typedef typename storage_type::ref_type ref_type;              
            typedef Iterator< this_type, ref_type, Tchar> iterator;        
            typedef RevIterator< this_type, ref_type, Tchar> rev_iterator; 
            PString()
                : data(def_frag) {
                /* Add NULL-termination */
                data << 0;
            }
            
            
            PString(const this_type & prev) 
                : data(prev.data) {
            }
            
            PString(const Tchar * dt, const size_type ln) 
                : data(def_frag) {
                data.Fill(dt, ln);
                /* Add NULL-termination */
                data << 0;
            }
            
            PString(const Tchar * prev) 
                : data(def_frag) {
                cpy(prev);
            }
            
            PString(const std::basic_string< Tchar> & prev) 
                : data(def_frag) {
                cpy(prev);
            }
            
            PString(const Tchar prev) 
                : data(def_frag) {
                cpy(prev);
            }
            
            PString(const signed int prev, const size_type base = 10) 
                : data(def_frag) {
                cpy_numeric_int(prev, base);
            }
            
            PString(const unsigned int prev, const size_type base = 10)  
                : data(def_frag) {
                cpy_numeric_int(prev, base);
            }
            
            PString(const signed long int prev, const size_type base = 10)  
                : data(def_frag) {
                cpy_numeric_int(prev, base);
            }

            PString(const unsigned long int prev, const size_type base = 10)  
                : data(def_frag) {
                cpy_numeric_int(prev, base);
            }

            PString(const signed long long int prev, const size_type base = 10)  
                : data(def_frag) {
                cpy_numeric_int(prev, base);
            }

            PString(const unsigned long long int prev, const size_type base = 10)  
                : data(def_frag) {
                cpy_numeric_int(prev, base);
            }
            
            PString(const float prev) 
                : data(def_frag) {
                cpy_numeric_float(prev);
            }
            
            PString(const double prev) 
                : data(def_frag) {
                cpy_numeric_float(prev);
            }
            
            
            const this_type & operator=(const this_type & prev) { 
                if (&prev != this)
                    data = prev.data;
                return *this;
            }
            
            const this_type & operator=(const Tchar * prev) { 
                cpy(prev);
                return *this;
            }
            
            const this_type & operator=(const std::basic_string< Tchar> prev) { 
                cpy(prev);
                return *this;
            }
            
            const this_type & operator=(const Tchar prev) { 
                cpy(prev);
                return *this;
            }
            
            const this_type & operator=(const signed int prev) { 
                cpy_numeric_int(prev, 10);
                return *this;
            }
            
            const this_type & operator=(const unsigned int prev) {  
                cpy_numeric_int(prev, 10);
                return *this;
            }
            
            const this_type & operator=(const signed long int prev) {  
                cpy_numeric_int(prev, 10);
                return *this;
            }
            
            const this_type & operator=(const unsigned long int prev) {  
                cpy_numeric_int(prev, 10);
                return *this;
            }
            
            const this_type & operator=(const signed long long int prev) {  
                cpy_numeric_int(prev, 10);
                return *this;
            }
            
            const this_type & operator=(const unsigned long long int prev) {  
                cpy_numeric_int(prev, 10);
                return *this;
            }
            
            const this_type & operator=(const float prev) {  
                cpy_numeric_float(prev);
                return *this;
            }
            
            const this_type & operator=(const double prev) {  
                cpy_numeric_float(prev);
                return *this;
            }
            
            
            const this_type & operator<<(const Tchar & right) {
                data[data.Len() - 1] = right;

                /* Add NULL-termination */
                data << 0;
                
                return *this;
            }
            
            
            const this_type & operator+=(const this_type & right) { 
                /* Remove NULL-termination from left operand */
                data -= 1;
                
                /* Concatenate characters */
                for (size_type i = 0; i < right.Len(); i++)
                    data << right.data[i];
                
                /* Add NULL-termination */
                data << 0;
                
                return *this;
            }
            
            const this_type & operator+(const this_type & right) { 
                return operator+=(right);
            }
            
            friend PString< Tchar> operator+<>(const PString< Tchar> & left, const PString< Tchar> & right); 
            friend std::basic_ostream< Tchar, std::char_traits< Tchar> > & operator<<<>(std::basic_ostream< Tchar,  std::char_traits< Tchar> > & stream, const PString< Tchar> & str); 
            operator const Tchar * () const { 
                return (const Tchar * ) data;
            }
            
            operator std::basic_string< Tchar> () const { 
                std::basic_string< Tchar> str;
            
                for (size_type i = 0; i < Len(); i++)
                    str += data[i];
                    
                return str;
            }
            
            operator Tchar () const { 
                CB2_CONVERSION(Len() > 0, "Can't convert empty string to character");
                return (Tchar) data[(size_type) 0];
            }
            
            operator signed int () const { 
                return (signed int) numeric_int(true, (signed int) 0);
            }
            
            operator unsigned int () const {  
                return (unsigned int) numeric_int(false, (unsigned int) 0);
            }
            
            operator signed long int () const {  
                return (signed long int) numeric_int(true, (signed long int) 0);
            }
            
            operator unsigned long int () const {  
                return (unsigned long int) numeric_int(false, (unsigned long int) 0);
            }
            
            operator signed long long int () const {  
                return (signed long long int) numeric_int(true, (signed long long int) 0);
            }
            
            operator unsigned long long int () const {  
                return (unsigned long long int) numeric_int(false, (unsigned long long int) 0);
            }
            
            operator float () const { 
                return (float) numeric_float((float) 0);
            }

            operator double () const { 
                return (double) numeric_float((double) 0);
            }
            
            
            size_type Len() const {
                size_type len = data.Len();
                CB2_ASSERT(len > 0, "Incosistent NULL-termination");
                return (len - 1);
            }
            
            
            size_type Size() const {
                return (Len() * sizeof(Tchar));
            }

            
            Tchar & operator[](const size_type pos) const {
                CB2_RANGECHECK(pos < Len(), pos);
                return data[pos];
            }
            
            
            bool operator==(const this_type & str) const { 
                if (Len() != str.Len())
                    return false;
            
                for (size_type i = 0; i < Len(); i++) { /* Compare string characters */
                    if (data[i] != str.data[i])
                        return false;
                }
                
                return true;
            }
            
            
            bool operator!=(const this_type & str) const {
                return (!operator==(str));
            }
            
            bool operator==(const Tchar * str) const { 
                if (Len() != strlen(str))
                    return false;
            
                for (size_type i = 0; i < Len(); i++) { /* Compare string characters */
                    if (data[i] != str[i])
                        return false;
                }
                
                return true;
            }
            
            bool operator!=(const Tchar * str) const {
                return (!operator==(str));
            }

            
            this_type Substr(const size_type base, const size_type length = (size_type) -1) const {
                if ((Empty()) || (base >= Len()))
                    return this_type();
                
                size_type len;
                
                if ((length == (size_type) -1) || (base + length > Len())) /* Truncate length */
                    len = Len() - base;
                else
                    len = length;
                
                return this_type(data + base, len);
            }
            
            
            bool Empty() const {
                return (Len() == 0);
            }
            
            
            void Discart(const bool shrink = false) {
                data.Discart(shrink);
                /* Add NULL-termination */
                data << 0;
            }
            
            
            bool Pos(const this_type & needle, size_type & pos, const size_type from = 0) const {
                if ((Empty()) || (needle.Empty()))
                    return false;
            
                size_type ni = 0;
                
                for (size_type i = from; i < Len(); i++) { /* For each character in haystack */
                    while ((i + ni < Len()) && (data[i + ni] == needle.data[ni])) { /* Compare characters with needle */
                        ni++;
                        
                        if (ni == needle.Len()) { /* Found match */
                            pos = i;
                            return true;
                        }
                    }
                    ni = 0;
                }
                
                return false;
            }
            
            size_type Subst(const this_type & needle, const this_type & replacement) {
                size_type cnt = 0;
                size_type i = 0;
                size_type pos;
                size_type nlen = needle.Len();
                size_type rlen = replacement.Len();
                
                while (Pos(needle, pos, i)) {
                    data.Cut(pos, nlen);                      /* Cut out needle */
                    data.Insert(pos, rlen, replacement.data); /* Insert replacement */
                    
                    i = pos + rlen;
                    cnt++;
                }
                
                return cnt;
            }
            
            
            this_type HTML(const this_type & nl = "") const {
                this_type str;
                bool nl_subst = (nl != "");
                
                for (size_type i = 0; i < Len(); i++) {
                    switch (data[i]) {
                        case '&':
                            str += "&amp;";
                            break;
                        case '<':
                            str += "&lt;";
                            break;
                        case '>':
                            str += "&gt;";
                            break;
                        case '"':
                            str += "&quot;";
                            break;
                        case '\n':
                            if (nl_subst) {
                                str += nl;
                                break;
                            }
                        default:
                            str << data[i];
                    }
                }
                
                return str;
            }
            
            
            this_type HTMLdecode() const {
                this_type str;
                
                for (size_type i = 0; i < Len(); i++) {
                    if (data[i] == '&') {
                        if (Substr(i + 1, 4) == "amp;") {
                            str << '&';
                            i += 4;
                        } else if (Substr(i + 1, 3) == "lt;") {
                            str << '<';
                            i += 3;
                        } else if (Substr(i + 1, 3) == "gt;") {
                            str << '>';
                            i += 3;
                        } else if (Substr(i + 1, 5) == "quot;") {
                            str << '"';
                            i += 5;
                        } else
                            CB2_CONVERSION(false, "Unsupported HTML entity");
                    } else
                        str << data[i];
                }
                
                return str;
            }
            
            
            this_type SQL() const {
                this_type str;
                
                for (size_type i = 0; i < Len(); i++) {
                    switch (data[i]) {
                        case '\'':
                            str += "\\\'";
                            break;
                        case '"':
                            str += "\\\"";
                            break;
                        case '\\':
                            str += "\\\\";
                            break;
                        case 0:
                            str += "\\0";
                            break;
                        default:
                            str << data[i];
                    }
                }
                
                return str;
            }
            
            
            this_type SQLdecode() const {
                this_type str;
                
                for (size_type i = 0; i < Len(); i++) {
                    if (data[i] == '\\') {
                        CB2_CONVERSION(i + 1 < Len(), "Illegal character escape");
                        if (data[i + 1] == '0')
                            str << (Tchar) 0;
                        else
                            str << data[i + 1];
                        i++;
                    } else
                        str << data[i];
                }
                
                return str;
            }
            
            
            this_type URL() const {
                this_type str;
                
                for (size_type i = 0; i < Len(); i++) {
                    switch (data[i]) {
                        case 'a'...'z':
                        case 'A'...'Z':
                        case '0'...'9':
                        case '-':
                        case '_':
                            str << data[i];
                            break;
                        case ' ':
                            str << '+';
                            break;
                        default:
                            str << '%';
                            
                            int ord = (((int) data[i]) >> 4) & 15;
                            if (ord < 10)
                                str << (Tchar) ((int) '0' + ord);
                            else
                                str << (Tchar) ((int) 'A' + ord);
                            
                            ord = ((int) data[i]) & 15;
                            if (ord < 10)
                                str << (Tchar) ((int) '0' + ord);
                            else
                                str << (Tchar) ((int) 'A' + ord);
                    }
                }
                
                return str;
            }
            
            this_type URLdecode() const {
                this_type str;
                
                for (size_type i = 0; i < Len(); i++) {
                    switch (data[i]) {
                        case '+':
                            str << ' ';
                            break;
                        case '%':
                            CB2_CONVERSION(i + 2 < Len(), "Illegal character escape");
                            
                            Tchar c;
                            
                            switch (data[i + 1]) {
                                case '0'...'9':
                                    c = (data[i + 1] - '0') << 4;
                                    break;
                                case 'a'...'f':
                                    c = (data[i + 1] - 'a' + 10) << 4;
                                    break;
                                case 'A'...'F':
                                    c = (data[i + 1] - 'A' + 10) << 4;
                                    break;
                                default:
                                    CB2_CONVERSION(false, "Illegal hexadecimal character");
                            }
                            
                            switch (data[i + 2]) {
                                case '0'...'9':
                                    c += (data[i + 2] - '0');
                                    break;
                                case 'a'...'f':
                                    c += (data[i + 2] - 'a' + 10);
                                    break;
                                case 'A'...'F':
                                    c += (data[i + 2] - 'A' + 10);
                                    break;
                                default:
                                    CB2_CONVERSION(false, "Illegal hexadecimal character");
                            }
                            str << c;
                            i += 2;
                            break;
                        default:
                            str << data[i];
                    }
                }
                
                return str;
            }
            
            
            ref_type RefBegin() const {
                return data.RefBegin();
            }
            
            
            ref_type RefEnd() const {
                return data.RefPrev(data.RevRefBegin());
            }
            
            
            ref_type RevRefBegin() const {
                return data.RefPrev(data.RevRefBegin());
            }
            
            
            ref_type RevRefEnd() const {
                return data.RevRefEnd();
            }
            
            
            ref_type RefNext(const ref_type & prev) const {
                if ((prev >= RefEnd()) || (prev < RefBegin())) /* Check ranges */
                    return RefEnd();
                
                return data.RefNext(prev);
            }
            
            
            ref_type RefPrev(const ref_type & prev) const {
                if ((prev <= RevRefEnd()) || (prev > RevRefBegin())) /* Check ranges */
                    return RevRefEnd();
                
                return data.RefPrev(prev);
            }
            
            
            const Tchar & Deref(const ref_type & ref) const {
                /* Check pointer range */
                CB2_MEMORYCHECK((ref < RefEnd()) && (ref >= RefBegin()));
                return (*ref);
            }
            
            
            const Tchar & RevDeref(const ref_type & ref) const {
                /* Check pointer range */
                CB2_MEMORYCHECK((ref > RevRefEnd()) && (ref <= RevRefBegin()));
                return (*(ref - 1));
            }
            
            
            iterator Begin() const {
                return iterator(*this, RefBegin());
            }
            
            
            iterator End() const {
                return iterator(*this, RefEnd());
            }
            
            
            rev_iterator RevBegin() const {
                return rev_iterator(*this, RevRefBegin());
            }
            
            
            rev_iterator RevEnd() const {
                return rev_iterator(*this, RevRefEnd());
            }
            
        private:
        
            storage_type data ;                     
            static const size_type def_frag = 1024; 
            void cpy(const Tchar * prev) { 
                data.Fill(prev, strlen(prev));
                data << 0;
            }
            
            void cpy(const std::basic_string< Tchar> & prev) { 
                data.Discart();
                
                for (typename std::basic_string< Tchar>::size_type i = 0; i < prev.length(); i++)
                    data << prev[i];
                
                data << 0;
            }
            
            void cpy(const Tchar prev) { 
                data.Fill(&prev, 1);
                data << 0;
            }

            
            template < class Tnum> void cpy_numeric_int(const Tnum prev, const size_type base) {
                CB2_ASSERT((base > 1) || (base < 37), "Invalid numeric base");
            
                bool sign;
                Tnum value = prev;
                
                data.Discart();
                
                if (value < 0) { /* Work with absolute value, note sign */
                    sign = true;
                    value = -value;
                } else
                    sign = false;
                
                while (value > 0) { /* Get orders */
                    Tnum ord = value % base;
                    value = value / base;
                    if (ord < 10)
                        data >> ((Tnum) '0' + ord);
                    else
                        data >> ((Tnum) 'A' + ord);
                }
                
                if (sign) /* Add unary minus */
                    data >> '-';
                
                data << 0;
            }
            
            
            template < class Tnum> void cpy_numeric_float(const Tnum prev) {
                bool sign;
                Tnum value = prev;
                
                data.Discart();
                
                if (value < 0) { /* Work with absolute value, note sign */
                    sign = true;
                    value = -value;
                } else
                    sign = false;
                    
                Tnum value_floor = floor(prev);
                Tnum value_diff = value_floor - value;
                
                while (value_floor > 0) { /* Itegral part */
                    Tnum oval = value_floor;
                    value_floor = floor(value_floor / 10);
                    int ord = (int) (oval - value_floor * 10);
                    data >> ((int) '0' + ord);
                }
                
                if (sign)
                    data >> '-';
                
                bool first = true;
                while (value_diff > 0) { /* Fraction part */
                    value_diff = value_diff * 10;
                    int ord = (int) value_diff;
                    value_floor = floor(value_diff);
                    value_diff = value_diff - value_floor;
                    if (first) {
                        data << '.';
                        first = false;
                    }
                    data << ((int) '0' + ord);
                }
                
                data << 0;
            }
            
            
            template< class Tnum> Tnum numeric_int(const bool signed_type, const Tnum zero) const {
                Tnum value = zero;
                Tnum base = 10;
                Tnum literal;
                
                int state;
                /* State numbers:
                    0 ... awaiting sign character, base prefix or literal
                    1 ... awaiting base prefix or literal
                    2 ... awaiting literal
                    3 ... tailing whitespace */
                bool sign = false;
                
                if (signed_type)
                    state = 0;
                else
                    state = 1; /* Unsigned type -> don't accept sign character */
                
                for (size_type i = 0; i < Len(); i++) {
                    switch (data[i]) {
                        case '+': /* Unary plus */
                            switch (state) {
                                case 0:
                                    state = 1;
                                    break;
                                default:
                                    CB2_CONVERSION(false, "Misplaced sign characters");
                            }
                            break;
                        case '-': /* Unary minus */
                            if (!signed_type)
                                CB2_CONVERSION(false, "Unary minus while converting to unsigned type");
                            switch (state) {
                                case 0:
                                    state = 1;
                                    sign = true;
                                    break;
                                default:
                                    CB2_CONVERSION(false, "Misplaced sign characters");
                            }
                            break;
                        case '0': /* '0' as literal or as base prefix */
                            if (state == 1) { 
                                if ((i + 1 < Len()) && (data[i + 1] == 'x')) { /* Leading '0x' -> hexadecimal */
                                    base = 16;
                                    state = 2;
                                    i++;
                                    break;
                                } else { /* Leading '0' -> octal */
                                    base = 8;
                                    state = 2;
                                    break;
                                }
                            }
                        case '1'...'9': /* Literals */
                            switch (state) {
                                case 0:
                                case 1:
                                case 2:
                                    state = 2;
                                    literal = (Tnum) data[i] - (Tnum) '0';
                                    CB2_CONVERSION(literal < base, "Invalid numeric literal");
                                    value *= base;
                                    value += literal;
                                    break;
                                default:
                                    CB2_CONVERSION(false, "Misplaced character");
                            }
                            break;
                        case 'a'...'z': /* Literals */
                            switch (state) {
                                case 0:
                                case 1:
                                case 2:
                                    state = 2;
                                    literal = (Tnum) data[i] - (Tnum) 'a' + 10;
                                    CB2_CONVERSION(literal < base, "Invalid numeric literal");
                                    value *= base;
                                    value += literal;
                                    break;
                                default:
                                    CB2_CONVERSION(false, "Misplaced character");
                            }
                            break;
                        case 'A'...'Z': /* Literals */
                            switch (state) {
                                case 0:
                                case 1:
                                case 2:
                                    state = 2;
                                    literal = (Tnum) data[i] - (Tnum) 'A' + 10;
                                    CB2_CONVERSION(literal < base, "Invalid numeric literal");
                                    value *= base;
                                    value += literal;
                                    break;
                                default:
                                    CB2_CONVERSION(false, "Misplaced character");
                            }
                            break;
                        case ' ':
                        case '\t':
                        case 0: /* Beginning or tailing whitespace */
                            switch (state) {
                                case 0:
                                    break;
                                case 2:
                                    state = 3;
                                    break;
                                default:
                                    CB2_CONVERSION(false, "Misplaced whitespace");
                            }
                            break;
                        default:
                            CB2_CONVERSION(false, "Invalid character");
                    }
                }
                
                if (sign) /* Sign */
                    value = -value;
                
                CB2_CONVERSION(state >= 2, "Invalid number");
                    
                return value;
                
            }
            
            
            template< class Tnum> Tnum numeric_float(const Tnum zero) const {
                Tnum value = zero;
                Tnum fraction = 10;
                
                int state = 0;
                /* State numbers:
                    0 ... awaiting sign character, integer literal or period
                    1 ... integer literal or period
                    2 ... awaiting fraction literal
                    3 ... tailing whitespace */
                bool sign = false;
                
                for (size_type i = 0; i < Len(); i++) {
                    switch (data[i]) {
                        case '+': /* Unary plus */
                            switch (state) {
                                case 0:
                                    state = 1;
                                    break;
                                default:
                                    CB2_CONVERSION(false, "Misplaced sign characters");
                            }
                            break;
                        case '-': /* Unary minus */
                            switch (state) {
                                case 0:
                                    state = 1;
                                    sign = true;
                                    break;
                                default:
                                    CB2_CONVERSION(false, "Misplaced sign characters");
                            }
                            break;
                        case '0'...'9': /* Literal */
                            switch (state) {
                                case 0:
                                case 1: /* Integral part */
                                    state = 1;
                                    value *= 10;
                                    value += (Tnum) data[i] - (Tnum) '0';
                                    break;
                                case 2: /* Fraction part */
                                    value += ((Tnum) data[i] - (Tnum) '0') / fraction;
                                    fraction *= 10;
                                    break;
                                default:
                                    CB2_CONVERSION(false, "Misplaced character");
                            }
                            break;
                        case '.': /* Period */
                            switch (state) {
                                case 0:
                                case 1:
                                    state = 2;
                                    break;
                                default:
                                    CB2_CONVERSION(false, "Misplaced period");
                            }
                            break;
                        case ' ':
                        case '\t':
                        case 0: /* Beginning or tailing whitespace */
                            switch (state) {
                                case 0:
                                    break;
                                case 1:
                                case 2:
                                    state = 3;
                                    break;
                                default:
                                    CB2_CONVERSION(false, "Misplaced whitespace");
                            }
                            break;
                        default:
                            CB2_CONVERSION(false, "Invalid character");
                    }
                }
                
                if (sign) /* Sign */
                    value = -value;
                
                CB2_CONVERSION(state >= 1, "Invalid number");
                    
                return value;
                
            }
            
            
    };
    
    
    template< class Tmemb> class List : public Class {
        public:
            
            typedef List< Tmemb> this_type; 
            typedef size_t size_type;       
            typedef struct _item_type {
                Tmemb * data;             
                bool local;               
                struct _item_type * prev; 
                struct _item_type * next; 
            } item_type;               
            
            typedef item_type * ref_type;                                  
            typedef Iterator< this_type, ref_type, Tmemb> iterator;        
            typedef RevIterator< this_type, ref_type, Tmemb> rev_iterator; 
            List() {
                list = NULL;
                tail = NULL;
                len = 0;
            }
            
            
            List(const this_type & prev) {
                for (item_type * ac = prev.list; ac != NULL; ac = ac->next) {
                    if (ac->local)
                        PushBack(*(ac->data));
                    else
                        operator<<(ac->data);
                }
            }
            
            
            ~List() {
                Discart();
            }
            
            
            const this_type & operator=(const this_type & prev) {
                if (&prev != this) { /* No self-assignment */
                    Discart();
                    for (item_type * ac = prev.list; ac != NULL; ac = ac->next) { /* Copy list items */
                        if (ac->local)
                            PushBack(*(ac->data));
                        else
                            operator<<(ac->data);
                    }
                }
                return *this;
            }
            
            
            const this_type & operator<<(Tmemb * prev) {
                if (list == NULL) {
                    list = new item_type;
                    list->data = prev;
                    list->local = false;
                    list->prev = NULL;
                    list->next = NULL;
                    tail = list;
                } else {
                    tail->next = new item_type;
                    tail->next->data = prev;
                    tail->next->local = false;
                    tail->next->prev = tail;
                    tail->next->next = NULL;
                    tail = tail->next;
                }
                len++;
                
                return *this;
            }
            
            
            const this_type & operator>>(Tmemb * prev) {
                if (list == NULL) {
                    list = new item_type;
                    list->data = prev;
                    list->local = false;
                    list->prev = NULL;
                    list->next = NULL;
                    tail = list;
                } else {
                    item_type * ac = new item_type;
                    ac->data = prev;
                    ac->local = false;
                    ac->prev = NULL;
                    ac->next = list;
                    list->prev = ac;
                    list = ac;
                }
                len++;
                
                return *this;
            }
            
            
            void PushBack(const Tmemb & prev) {
                Tmemb * local = new Tmemb(prev);
                
                if (list == NULL) {
                    list = new item_type;
                    list->data = local;
                    list->local = true;
                    list->prev = NULL;
                    list->next = NULL;
                    tail = list;
                } else {
                    tail->next = new item_type;
                    tail->next->data = local;
                    tail->next->local = true;
                    tail->next->prev = tail;
                    tail->next->next = NULL;
                    tail = tail->next;
                }
                len++;
            }
            
            
            void PushFront(const Tmemb & prev) {
                Tmemb * local = new Tmemb(prev);
                
                if (list == NULL) {
                    list = new item_type;
                    list->data = local;
                    list->local = true;
                    list->prev = NULL;
                    list->next = NULL;
                    tail = list;
                } else {
                    item_type * ac = new item_type;
                    ac->data = local;
                    ac->local = true;
                    ac->prev = NULL;
                    ac->next = list;
                    list->prev = ac;
                    list = ac;
                }
                len++;
            }
            
            
            Tmemb & operator[](const size_type pos) const {
                CB2_RANGECHECK(pos < len, pos);
                
                item_type * ac = list;
                size_type i = pos;
                
                while (ac != NULL) {
                    if (i == 0)
                        return *(ac->data);
                    i--;
                    ac = ac->next;
                }
                
                CB2_ASSERT(false, "Inconsistent list data");
                return *(list->data); /* Unreachable, just to supress compiler errors */
            }
            
            
            void Discart() {
                item_type * ac = list;
                
                while (ac != NULL) {
                    if (ac->local)
                        delete ac->data;
                    
                    item_type * next = ac->next;
                    delete ac;
                    ac = next;
                }
                
                list = NULL;
                tail = NULL;
            }
            
            
            size_type Len() const {
                return len;
            }
            
            
            bool Empty() const {
                return (len == 0);
            }
            
            
            Tmemb * Head() const {
                if (list != NULL)
                    return list->data;
                
                return NULL;
            }
            
            
            Tmemb * Tail() const {
                if (tail != NULL)
                    return tail->data;
                
                return NULL;
            }
            
            
            ref_type RefBegin() const {
                return list;
            }
            
            
            ref_type RefEnd() const {
                return NULL;
            }
            
            
            ref_type RevRefBegin() const {
                return tail;
            }
            
            
            ref_type RevRefEnd() const {
                return NULL;
            }
            
            
            ref_type RefNext(const ref_type & prev) const {
                return prev->next;
            }
            
            
            ref_type RefPrev(const ref_type & prev) const {
                return prev->prev;
            }
            
            
            const Tmemb & Deref(const ref_type & ref) const {
                CB2_MEMORYCHECK(ref != NULL);
                return *(ref->data);
            }
            
            
            const Tmemb & RevDeref(const ref_type & ref) const {
                CB2_MEMORYCHECK(ref != NULL);
                return *(ref->data);
            }
            
            
            iterator Begin() const {
                return iterator(*this, RefBegin());
            }
            
            
            iterator End() const {
                return iterator(*this, RefEnd());
            }
            
            
            rev_iterator RevBegin() const {
                return rev_iterator(*this, RevRefBegin());
            }
            
            
            rev_iterator RevEnd() const {
                return rev_iterator(*this, RevRefEnd());
            }
            
        private:

            item_type * list; 
            item_type * tail; 
            size_type len;    
    };
    
    
    template< class Tkey, class Tvalue> class PMap : public Class {
        public:
            
            typedef PMap< Tkey, Tvalue> this_type; 
            PMap(const Tkey & key, const Tvalue & value) {
                _key = key;
                _value = value;
                _null = false;
            }
            
            
            PMap(const Tkey & key) {
                _key = key;
                _null = true;
            }
            
            
            PMap(const this_type & prev) {
                _key = prev._key;
                if (prev._null) /* NULL value */
                    _null = true;
                else { /* Non-NULL value */
                    _value = prev._value;
                    _null = false;
                }
            }
            
            
            const this_type & operator=(const this_type & prev) {
                if (&prev != this) { /* No self-assignment */
                    _key = prev._key;
                    if (prev._null) /* NULL value */
                        _null = true;
                    else { /* Non-NULL value */
                        _value = prev._value;
                        _null = false;
                    }
                }
                return *this;
            }
            
            
            const Tkey & GetKey() const {
                return _key;
            }
            
            
            const Tvalue & GetValue() const {
                CB2_ASSERT(_null == false, "Value of NULL field is undefined");
                return _value;
            }
            
            
            bool IsNULL() const {
                return _null;
            }
            
        private:
            
            Tkey _key;     
            Tvalue _value; 
            bool _null;    
    };
    
    
    template< class Tkey, class Tvalue> class PMapList : public Class {
        public:
            
            typedef PMapList< Tkey, Tvalue> this_type;                         
            typedef PMap< Tkey, Tvalue> item_type;                             
            typedef List< item_type> storage_type;                             
            typedef typename storage_type::size_type size_type;                
            typedef typename storage_type::ref_type ref_type;                  
            typedef Iterator< this_type, ref_type, item_type> iterator;        
            typedef RevIterator< this_type, ref_type, item_type> rev_iterator; 
            PMapList() {
                /* Empty */
            }
            
            
            ~PMapList() {
                /* Empty */
            }
            
            
            const this_type & operator<<(const item_type & map) {
                data.PushBack(map);
                return *this;
            }
            
            
            void Add(const Tkey & key, const Tvalue & value) {
                item_type map(key, value);
                data.PushBack(map);
            }
            
            
            void Add(const Tkey & key) {
                item_type map(key);
                data.PushBack(map);
            }
            
            
            const Tvalue & operator[](const Tkey & key) const {
                for (typename storage_type::iterator it = data.Begin(); it != data.End(); ++it) {
                    if (it->GetKey() == key)
                        return it->GetValue();
                }
                CB2_NOTFOUND(false);
            }
            
            
            bool IsNULL(const Tkey & key) const {
                for (typename storage_type::iterator it = data.Begin(); it != data.End(); ++it) {
                    if (it->GetKey() == key)
                        return it->IsNULL();
                }
                CB2_NOTFOUND(false);
            }
            
            
            size_type Len() const {
                return data.Len();
            }
            
            
            bool Empty() const {
                return data.Empty();
            }
            
            
            ref_type RefBegin() const {
                return data.RefBegin();
            }
            
            
            ref_type RefEnd() const {
                return data.RefEnd();
            }
            
            
            ref_type RevRefBegin() const {
                return data.RevRefBegin();
            }
            
            
            ref_type RevRefEnd() const {
                return data.RevRefEnd();
            }
            
            
            ref_type RefNext(const ref_type & prev) const {
                return data.RefNext(prev);
            }
            
            
            ref_type RefPrev(const ref_type & prev) const {
                return data.RefPrev(prev);
            }
            
            
            const item_type & Deref(const ref_type & ref) const {
                return data.Deref(ref);
            }
            
            
            const item_type & RevDeref(const ref_type & ref) const {
                return data.RevDeref(ref);
            }
            
            
            iterator Begin() const {
                return iterator(*this, RefBegin());
            }
            
            
            iterator End() const {
                return iterator(*this, RefEnd());
            }
            
            
            rev_iterator RevBegin() const {
                return rev_iterator(*this, RevRefBegin());
            }
            
            
            rev_iterator RevEnd() const {
                return rev_iterator(*this, RevRefEnd());
            }
            
        private:
            
            storage_type data; 
    };
    
    
    template< class Tmemb> class Tree : public Class {
        public:
            
            typedef Tree< Tmemb> this_type;                                    
            typedef List< this_type> subtrees_type;                            
            typedef typename subtrees_type::size_type size_type;               
            typedef typename subtrees_type::ref_type ref_type;                 
            typedef Iterator< this_type, ref_type, this_type> iterator;        
            typedef RevIterator< this_type, ref_type, this_type> rev_iterator; 
            Tree() {
                data = NULL;
            }
            
            
            ~Tree() {
                if (local)
                    delete data; /* Delete data if local copy */
                /* Subtrees will be deallocated recursivelly  */
            }
            
            
            bool IsNULL() const {
                return (data == NULL);
            }
            
            
            size_type CountSubtrees() const {
                return subtrees.Len();
            }
            
            
            const this_type & operator<<(const Tmemb * prev) {
                CB2_ASSERT(data == NULL, "Tree node can hold just one value");
                data = prev;
                local = false;
            }
            
            
            void Push(const Tmemb & prev) {
                CB2_ASSERT(data == NULL, "Tree node can hold just one value");
                data = new Tmemb(prev);
                local = true;
            }
            
            
            this_type * AddChild() {
                Tree< Tmemb> child;
                subtrees.PushBack(child);
                return subtrees.Tail();
            }
            
            
            ref_type RefBegin() const {
                return subtrees.RefBegin();
            }
            
            
            ref_type RefEnd() const {
                return subtrees.RefEnd();
            }
            
            
            ref_type RevRefBegin() const {
                return subtrees.RevRefBegin();
            }
            
            
            ref_type RevRefEnd() const {
                return subtrees.RevRefEnd();
            }
            
            
            ref_type RefNext(const ref_type & prev) const {
                return subtrees.RefNext(prev);
            }
            
            
            ref_type RefPrev(const ref_type & prev) const {
                return subtrees.RefPrev(prev);
            }
            
            
            const this_type & Deref(const ref_type & ref) const {
                return subtree.Deref(ref);
            }
            
            
            const this_type & RevDeref(const ref_type & ref) const {
                return subtree.RevDeref(ref);
            }
            
            
            iterator Begin() const {
                return iterator(*this, RefBegin());
            }
            
            
            iterator End() const {
                return iterator(*this, RefEnd());
            }
            
            
            rev_iterator RevBegin() const {
                return rev_iterator(*this, RevRefBegin());
            }
            
            
            rev_iterator RevEnd() const {
                return rev_iterator(*this, RevRefEnd());
            }
            
        private:
            Tmemb * data;           
            bool local;             
            subtrees_type subtrees; 
    };
    
    
    template< class Tchar> class PStringTokenizer : public Class {
        public:
            
            typedef PStringTokenizer< Tchar> this_type;                           
            typedef PString< Tchar> item_type;                                    
            typedef List< item_type> storage_type;                                
            typedef typename storage_type::size_type size_type;                   
            typedef typename storage_type::ref_type ref_type;                     
            typedef Iterator< this_type, ref_type, item_type> iterator;           
            typedef RevIterator< this_type, ref_type, item_type> rev_iterator;    
            PStringTokenizer(const item_type & str, const item_type & delim) {
                tokens = new storage_type;
                
                size_type pos = 0;
                size_type len;
                size_type dlen = delim.Len();
                
                while ((pos < str.Len()) && (str.Pos(delim, len, pos))) {
                    tokens->PushBack(str.Substr(pos, len - pos));
                    pos = len + dlen;
                }
                
                tokens->PushBack(str.Substr(pos));
            }
            
            
            ~PStringTokenizer() {
                delete tokens;
            }
            
            
            size_type Len() const {
                return tokens->Len();
            }
            
            
            const item_type & operator[](const size_type pos) const {
                return (*tokens)[pos];
            }
            
            
            ref_type RefBegin() const {
                return tokens->RefBegin();
            }
            
            
            ref_type RefEnd() const {
                return tokens->RefEnd();
            }
            
            
            ref_type RevRefBegin() const {
                return tokens->RevRefBegin();
            }
            
            
            ref_type RevRefEnd() const {
                return tokens->RevRefBegin();
            }
            
            
            ref_type RefNext(const ref_type & prev) const {
                return tokens->RefNext(prev);
            }
            
            
            ref_type RefPrev(const ref_type & prev) const {
                return tokens->RefPrev(prev);
            }
            
            
            const item_type & Deref(const ref_type & ref) const {
                return tokens->Deref(ref);
            }
            
            
            const item_type & RevDeref(const ref_type & ref) const {
                return tokens->RevDeref(ref);
            }
            
            
            iterator Begin() const {
                return iterator(*this, RefBegin());
            }
            
            
            iterator End() const {
                return iterator(*this, RefEnd());
            }
            
            
            rev_iterator RevBegin() const {
                return rev_iterator(*this, RevRefBegin());
            }
            
            
            rev_iterator RevEnd() const {
                return rev_iterator(*this, RevRefEnd());
            }
        
        private:
        
            storage_type * tokens; 
    };
    

    typedef PString< char> String;                   
    typedef PStringTokenizer< char> StringTokenizer; 
    typedef PMap< String, String> Map;               
    typedef PMapList< String, String> MapList;       
    class Exception : public Class {
        public:
            Exception();                                  
            Exception(const String what);                 
            Exception(const String what, const int line); 
            String What() const; 
        private:
            String except; 
    };
    
    
    template< class Tsize> class ExceptionRange : public Exception {
        public:
            
            
            ExceptionRange()
                : Exception() {
                /* Empty */
            }
            
            
            ExceptionRange(const String what)
                : Exception(what) {
                /* Empty */
            }
            
            
            ExceptionRange(const String what, const int line)
                : Exception(what, line) {
            }
            
            
            ExceptionRange(const String what, const Tsize value, const String what2, const int line)
                : Exception(what + String(value) + what2, line) {
            }
    };
    
    
    class ExceptionConversion : public Exception {
        public:
            ExceptionConversion();                                  
            ExceptionConversion(const String what);                 
            ExceptionConversion(const String what, const int line); 
    };
    
    
    class ExceptionMemory : public Exception {
        public:
            ExceptionMemory();                                  
            ExceptionMemory(const String what);                 
            ExceptionMemory(const String what, const int line); 
    };
    
    
    class ExceptionAssert : public Exception {
        public:
            ExceptionAssert();                                  
            ExceptionAssert(const String what);                 
            ExceptionAssert(const String what, const int line); 
    };
    
    
    class ExceptionNotFound : public Exception {
        public:
            ExceptionNotFound();                                  
            ExceptionNotFound(const String what);                 
            ExceptionNotFound(const String what, const int line); 
    };
    
};


#endif

---