sprint/container/light_string.h

Go to the documentation of this file.

/******************************************************************************
*   sprint::light_string
*
*   Copyright (C) 2005-2011 Paolo Medici <www.pmx.it>
*
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *******************************************************************************/

#ifndef _SPRINT_LIGHT_STRING_H
#define _SPRINT_LIGHT_STRING_H

#include <string.h>
// User should include before
// #include <sprint/buffer_cast.h>

namespace sprint { 
        
class light_string {
    char *m_str;
    protected:
          inline void _dtor() 
                        { 
                                if(m_str) 
                                        delete [] m_str; 
                        }
                inline void alloc(unsigned int size)
                        {
                                m_str = new char[size];
                        }               

                void _ctor(const char *str, int __lenght)
                {
                        if(str)
                                {
                                int len = __lenght + 1;
                            alloc(len);
                            memcpy(m_str, str, __lenght);
                            m_str[__lenght]=0;
                                }
                        else
                                m_str = NULL;                   
                }
                void _ctor(const char *str)
                {
                        if(str)
                                {
                                _ctor(str, strlen(str));
                                }
                        else
                                m_str = NULL;                   
                }
    
    void assign(const char *str)
    {
    _dtor();
    _ctor(str);
    }
    
    public:
    
    typedef int size_type;
    
    static const size_type npos = -1;

    public:
    inline
    light_string() : m_str(NULL) {}
    
    inline
    light_string(const light_string &s, size_type __pos = 0) 
    {
        _ctor(s.m_str + __pos);
    }

    inline
    light_string(const light_string &s, size_type __pos, size_type __lenght) 
    {
        _ctor(s.m_str + __pos, __lenght);
    }
    
    inline
    light_string(const char *c, size_type __pos = 0)
    {
                        _ctor(c + __pos);
    }

    inline
    light_string(const char *c, size_type __pos, size_type __lenght)
    {
                        _ctor(c + __pos, __lenght);
    }
    
    char *reserve(unsigned int size)
    {
                        alloc(size);
                        return m_str;
                }


    inline
    light_string(const char *a, const char *b) 
        {
                          int len1 = strlen(a);
                          int len2 = strlen(b);
                          alloc(len1 + len2 + 1);
                          memcpy(m_str, a, len1);
                          memcpy(m_str + len1, b, len2);
                          m_str[len1+len2]=0;
    }

#ifdef ENABLE_STRING_CAT_COSTRUCTOR
    
    inline
    light_string(const char *a, const char *b, const char *c) 
                {
                                int len1 = strlen(a);
                                int len2 = strlen(b);
                                int len3 = strlen(c) + 1;                               
                                alloc(len1 + len2 + len3);
                          memcpy(m_str, a, len1);
                          memcpy(m_str + len1, b, len2);
                          memcpy(m_str + len1 + len2, c, len3);
    }

    inline
    light_string(const char *a, const char *b, const char *c, const char *d) 
                {
                                int len1 = strlen(a);
                                int len2 = strlen(b);
                                int len3 = strlen(c);                           
                                int len4 = strlen(d) + 1;                                                               
                                alloc(len1 + len2 + len3 + len4);
                          memcpy(m_str, a, len1);
                          memcpy(m_str + len1, b, len2);
                          memcpy(m_str + len1 + len2, c, len3);
                          memcpy(m_str + len1 + len2 + len3, d, len4);                    
    }               
#endif
    
    ~light_string() 
      { 
        _dtor();
      }
    
    inline bool IsValid() const { return m_str!=NULL;}
    
    inline bool empty() const { return (m_str==NULL) || (m_str[0]==0); }
       
    void assignf(const char *format, ...);
    
    inline light_string & operator = (const char *str) 
    {
        assign(str);
        return *this;
    }
    inline light_string & operator = (const light_string &s)
    {
        assign(s.m_str);
        return *this;
    }
    
    void push_back(char c)
    {
         if(m_str)
         {
            int src_len = strlen(m_str);
            char *new_str = new char[src_len + 1 + 1];
            memcpy(new_str, m_str, src_len);
            new_str[src_len]=c;
            new_str[src_len + 1]=0;
            delete [] m_str;
            m_str = new_str;
         }
         else
         _ctor(&c, 1);
    }

    void append(const char *str, int add_len)
    {
         if(m_str)
         {
         int src_len = strlen(m_str);
         
         char *new_str = new char[src_len + add_len+1];
         memcpy(new_str, m_str, src_len);
         memcpy(new_str + src_len, str, add_len);
         new_str[src_len + add_len]=0;
         delete [] m_str;
         m_str = new_str;
         }
         else
         {
             _ctor(str, add_len);
         }
    }
    
    void append(const char *str)
    {
         append(str, strlen(str));
    }
    
    void append(const light_string & str)
     {
         append(str.c_str());
     }

    void operator += (const char * str)
     {
         append(str);
     }

    void operator += (const light_string & str)
     {
         append(str.c_str());
     }
    
    // operatore per ritornare il buffer
    inline char operator [](int i) const
     {
     return m_str[i];
     }

    inline char & operator [](int i)
     {
     return m_str[i];
     }
    
    // compatibilita verso STL 
    // TODO: garantire di non ritornare NULL a scapito di un confronto aggiuntivo
    inline const char *c_str() const 
      { 
        return m_str; 
       }
    
    inline unsigned int size() const 
        {
                                return strlen(m_str);
                        }
    
    inline 
    bool operator == (const char *c) const
      {
      return (IsValid()&&(c)) ? (!strcmp(m_str, c)) : false;
      }
    
    inline
    bool operator == (const light_string & s) const
      {
      return !strcmp(m_str, s.m_str);
      }

    bool Like(const char *c) const
    {
     return (IsValid()&&(c)) ? (!strcasecmp(m_str, c)) : false;
    }    
    
    // TODO case insensitive version?
    inline
    bool operator < (const char *string) const
    {
      return strcmp(m_str, string)==-1;
    }
    inline
    bool operator < (const light_string & string) const
    {
      return strcmp(m_str, string.m_str)==-1;
    }
    
    inline
    bool operator > (const char *string) const
    {
      return strcmp(m_str, string)==+1;
    }

    inline
    bool operator > (const light_string & string) const
    {
      return strcmp(m_str, string.m_str)==+1;
    }
    
    size_type find_first_of(char c, size_type __pos = 0) const
    {
        const char *e = strchr(m_str + __pos, c);
        return (e == NULL) ? npos : (long) (e - m_str);
    }
    
    size_type find_first_not_of(char c, size_type __pos = 0) const    
    {
       if(m_str)
       {
       size_type i = __pos;
       while(m_str[i] != 0) {
         if(m_str[i] != c)
           return i;
         ++i;
       }
       return npos;
       }
       else
       {
           return npos;
       } 
    }
    
    size_type find_last_not_of(char c) const    
    {
       if(m_str)
       {
       size_type i = strlen(m_str) - 1;
       while(i>0) {
         if(m_str[i] != c)
           return i;
       }
       return npos;
       }
       else
       {
           return npos;
       } 
    }
    
    size_type find_last_not_of(const char *pattern) const    
    {
       if(m_str)
       {
       int npat = strlen(pattern);
       size_type i = strlen(m_str) - 1;
       while(i>0) {
         if(memchr(pattern, m_str[i], npat)==NULL)
           return i;
       }
       return npos;
       }
       else
       {
           return npos;
       } 
    }    
       
    size_type find_last_of(char c, size_type __pos = 0) const
    {
        const char *e = strrchr(m_str + __pos, c);
        return (e == NULL) ? npos : (long) (e - m_str);
    }

};

inline
light_string operator +(const light_string &a, const char *str)
{
             return light_string(a.c_str(), str);
}

inline    
light_string operator +(const light_string &a, const light_string & b)
{
             return light_string(a.c_str(), b.c_str());
}

}

#ifdef _BUFFER_CAST_H

namespace sprint {
          
 template<>
inline buffer_cast::buffer_cast<sprint::light_string>(const sprint::light_string & value) 
       {
       ptr = value.c_str();
       }
       
       }

#endif

#endif