string.h

Go to the documentation of this file.

// Copyright (C) 1999-2001 Open Source Telecom Corporation.
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
// 
// This program 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 General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
// 
// As a special exception to the GNU General Public License, permission is 
// granted for additional uses of the text contained in its release 
// of Common C++.
// 
// The exception is that, if you link the Common C++ library with other
// files to produce an executable, this does not by itself cause the
// resulting executable to be covered by the GNU General Public License.
// Your use of that executable is in no way restricted on account of
// linking the Common C++ library code into it.
//
// This exception does not however invalidate any other reasons why
// the executable file might be covered by the GNU General Public License.
// 
// This exception applies only to the code released under the 
// name Common C++.  If you copy code from other releases into a copy of
// Common C++, as the General Public License permits, the exception does
// not apply to the code that you add in this way.  To avoid misleading
// anyone as to the status of such modified files, you must delete
// this exception notice from them.
// 
// If you write modifications of your own for Common C++, it is your choice
// whether to permit this exception to apply to your modifications.
// If you do not wish that, delete this exception notice.

#ifndef CCXX_STRING_H_
#define CCXX_STRING_H_

#ifndef CCXX_MISSING_H_
#include <cc++/missing.h>
#endif

#ifndef CCXX_STRCHAR_H_
#include <cc++/strchar.h>
#endif

#ifdef  CCXX_NAMESPACES
namespace ost {
#endif

class __EXPORT String
{
protected:
        static const unsigned minsize;
        static const unsigned slotsize;
        static const unsigned pagesize;
        static const unsigned slotlimit;
        static const unsigned slots;

private:
        friend class MemPager;

        static MemPager *pager;
        static char **idx;

#pragma pack(1)
        union
        {
                struct
                {
                        char *text;
                        unsigned size;
                        unsigned length;
                }       bigstring;
                struct
                {
                        char text[(sizeof(char *) + (sizeof(unsigned) * 2) + 1)];
                        char length : 6;
                        bool big : 1;
                }       ministring;
        }       content;
#pragma pack()

protected:
        inline bool isBig(void) const
                {return content.ministring.big;};

        const char *set(const char *str, unsigned len = 0);

        void set(const String &str);

#ifdef  HAVE_SNPRINTF

        const char *set(unsigned size, const char *format, ...);
#endif

        void copy(const String &str);

        void init(void);

        char *getSpace(unsigned size);

        unsigned setSize(unsigned size);

        void setLength(unsigned len);

        virtual int compare(const char *text, unsigned len = 0, unsigned index = 0) const;

        unsigned search(const char *text, unsigned clen = 0, unsigned offset = 0) const;

public:
        static const unsigned npos;

        typedef unsigned size_type;

        String();

        String(const String &original)
                {copy(original);};

        String(const char *str);

        String(const String &str, unsigned offset, unsigned len = npos);

#ifdef  HAVE_SNPRINTF

        String(unsigned count, const char *fmt, ...);
#else

        String(unsigned count, const char *str);
#endif

        String(unsigned count, char fill = ' ');

        virtual ~String();

        const char *getIndex(unsigned index) const;

        char *getText(void) const;

        const unsigned getLength(void) const;

        const unsigned getSize(void) const;

        bool isEmpty(void) const;

        void resize(unsigned size);

        void clear(void);

        char at(int offset) const;

        unsigned count(const String &s, unsigned offset = 0) const;

        unsigned count(const char *s, unsigned offset = 0, unsigned len = 0) const;

        String token(const char *delim = " \t\n\r", unsigned offset = 0);

        unsigned find(const String &s, unsigned offset = 0, unsigned instance = 1) const;

        unsigned rfind(const String &s, unsigned offset = 0) const;

        unsigned find(const char *s, unsigned offset = 0, unsigned len = 0, unsigned count = 1) const;

        unsigned rfind(const char *s, unsigned offset = 0, unsigned len = 0) const;

        inline void trim(const char *cs)
                {setLength(strtrim(cs, getText(), getLength()));};

        inline void chop(const char *cs)
                {setLength(strchop(cs, getText(), getLength()));};

        void strip(const char *cs);

        inline void chop(unsigned count)
                {erase(0, count);};

        void trim(unsigned count);

        void erase(unsigned start, unsigned len = npos);

        void insert(unsigned start, const char *text, unsigned len = 0);

        void insert(unsigned start, const String &str);

        void replace(unsigned start, unsigned len, const char *text, unsigned count = 0);

        void replace(unsigned start, unsigned len, const String &s);

        inline unsigned find(unsigned instance, const char *text, unsigned offset = 0, unsigned len = 0) const
                {return find(text, offset, len, instance);};

        inline unsigned find(unsigned instance, const String &s, unsigned offset = 0) const
                {return find(s, offset, instance);};

        inline String substr(unsigned start, unsigned len) const
                {return String(*this, start, len);};

        inline const char *index(unsigned idx) const
                {return getIndex(idx);};

        inline void compact(void)
                {resize(getLength() + 1);};

        inline char *c_str(void) const
                {return getText();};

        inline operator char *() const
                {return getText();};

        inline bool operator!(void) const
                {return isEmpty();};

        inline char *text(void) const
                {return getText();};

        inline char *data(void) const
                {return getText();};

        inline unsigned length(void) const
                {return strlen(getText());};

        inline unsigned size(void) const
                {return getLength();};

        inline unsigned capacity(void) const
                {return getSize();};

        bool empty(void) const
                {return isEmpty();};

        void append(const char *str, unsigned count = 0);

#ifdef  HAVE_SNPRINTF

        void append(unsigned size, const char *format, ...);
#endif

        void append(const char *str, unsigned offset, unsigned count);

        void add(char c);

        void append(const String &str);

        inline const char operator[](unsigned index) const
                {return at(index);};

        inline void operator =(const String& str)
                {set(str);};

        inline const char *operator =(const char *str)
                {return set(str);};

        friend __EXPORT String operator+(const String &s1, const String &s2);

        friend __EXPORT String operator+(const String &s1, const char *s2);

        friend __EXPORT String operator+(const char *s1, const String &s2);

        friend __EXPORT String operator+(const String &s1, const char c2);
        
        friend __EXPORT String operator+(const char c1, const String &s2);

        inline String &operator+=(const String &str)
                {append(str); return *this;};

        inline String &operator+=(char c)
                {add(c); return *this;};

        inline String &operator+=(const char *str)
                {append(str); return *this;};

        friend __EXPORT std::istream &getline(std::istream &is, String &str, char delim = '\n', unsigned size = 0);

        friend __EXPORT std::ostream &operator<<(std::ostream &os, const String &str);

        inline friend std::istream &operator>>(std::istream &is, String &str)
                {return getline(is, str);};

#ifdef  HAVE_SNPRINTF

        friend __EXPORT int strprintf(String &str, unsigned size, const char *fmt, ...);
#endif

        bool operator<(const String &str);
        bool operator<(const char *str);
        bool operator>(const String &str);
        bool operator>(const char *str);
        bool operator<=(const String &str);
        bool operator<=(const char *str);
        bool operator>=(const String &str);
        bool operator>=(const char *str);
        bool operator==(const String &str);
        bool operator==(const char *str);
        bool operator!=(const String &str);
        bool operator!=(const char *str);

#ifdef  HAVE_SNPRINTF

        inline String &operator+=(int i)
                {append(16, "%d", i); return *this;};

        inline String &operator+=(unsigned int i)
                {append(16, "%u", i); return *this;};

        inline String &operator+=(long l)
                {append(16, "%l", l); return *this;};

        inline String &operator+=(unsigned long l)
                {append(16, "%ul", l); return *this;};

        inline String &operator+=(float f)
                {append(32, "%f", f); return *this;};

        inline String &operator+=(double d)
                {append(32, "%f", d); return *this;};

        inline String &operator+=(short s)
                {append(8, "%hd", s); return *this;};

        inline String &operator+=(unsigned short s)
                {append(8, "%hu", s); return *this;};


        inline String &operator=(int i)
                {set(16, "%d", i); return *this;};

        inline String &operator=(unsigned int i)
                {set(16, "%u", i); return *this;};

        inline String &operator=(long l)
                {set(16, "%l", l); return *this;};

        inline String &operator=(unsigned long l)
                {set(16, "%ul", l); return *this;};

        inline String &operator=(float f)
                {set(32, "%f", f); return *this;};

        inline String &operator=(double d)
                {set(32, "%f", d); return *this;};

        inline String &operator=(short s)
                {set(8, "%hd", s); return *this;};

        inline String &operator=(unsigned short s)
                {set(8, "%hu", s); return *this;};

#endif

        bool operator*=(const String &str);

        bool operator*=(const char *str);
};

class __EXPORT SString : public String, protected std::streambuf, public std::ostream
{
protected:
        int overflow(int c);

public:
        SString();

        SString(const SString &from);

        ~SString();
};

#ifdef  CCXX_NAMESPACES
};
#endif

#endif

---