Beesnest/DcString.h

Go to the documentation of this file.

/*
Copyright 2007 Erez Bibi (erezbibi@users.sourceforge.net)
This file is part of Beesnest.

Beesnest 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.

Beesnest 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 Beesnest; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/

/* DcString.h: interface for the CdcString class. */

#ifndef __CDC_STRING
#define __CDC_STRING

#include "Interfaces/BufferHolder.h"
#include <string>
using namespace std;

/**
 * This class is a wrapper of the STL string class. I wrote it because I started
 * the project using MFC, and then decided not to use it. This class take some
 * of the interface of CString and implements it with an STL string. In addition
 * if I will ever decide to make this CdcString working with Reference Counting
 * method, it will be much easier.
 *
 * <p>
 * @author Erez Bibi
 * @version 1.0
 */
class CdcString : public string
{
public:

    /** Constructors. */
    CdcString ()
        :string () {}
    CdcString (char ch)
        :string (1, ch) {}
    CdcString (const char* str)
        :string (str) {}
    CdcString (char* str)
        :string (str) {}
    CdcString (const char* str, int len)
        :string (str, len) {}
    CdcString (char* str, int len)
        :string (str, len) {}
    CdcString (const string& str)
        :string (str) {}
    CdcString (const CdcString& str)
        :string (str.GetBuffer ()) {}
    CdcString (BufferHolder bh)
    { if (!bh.empty ()) *this = string (bh.pointer, bh.size); }

    /** Return the length of this string, */
    int GetLength () const
    { return length (); }

    /** Return True if the string is empty. */
    bool IsEmpty () const
    { return empty (); }

    /** Compare two strings. */
    int Compare (const CdcString& str) const
    { return compare (str); }

    /** Compare two strings but ignore the case. */
    int CompareNoCase (const CdcString& str) const;

    /** Compare the end of a string to 'str'. */
    int CompareEnd (const CdcString& str) const;

    /** Extract a sub string. if <b>count</b> is missing, it will extract the
     * sub string from <b>first</b> until the end.
     */
    CdcString Mid (int first, int count = CdcString::npos) const
    { return CdcString (substr (first, count)); }

    /** Extract the left part of a string. */
    CdcString Left (int count) const
    { return CdcString (substr (0, count)); }

    /** Extract the right part of a string. */
    CdcString Right (int count) const
    { return CdcString (substr (GetLength () - count)); }

    /** Make a string upper case. */
    void MakeUpper ();

    /** Make a string lower case. */
    void MakeLower ();

    /** Replace chars in a string. */
//  int Replace (char chOld, char chNew);


    /** Replace sub strings in a string. */
    void Replace (const CdcString& strOld, const CdcString& strNew);

    /** Trim white spaces in the left of a string. */
    void TrimLeft ();

    /** Trim white spaces in the right of a string. */
    void TrimRight ();

    /** Trim from left and right. This is not in MFC string. */
    CdcString& Trim ()
    { TrimLeft (); TrimRight (); return *this;}


    /** Find sub string in a string. */
    int Find (const CdcString& str, int start = 0) const
    { return find (str, start); }
    int Find (const char* str, int start = 0) const
    { return find (str, start); }
    int Find (char c, int start = 0) const
    { return find (c, start); }

    int ReverseFind (const CdcString& str, int start = -1) const
    { start = start == -1 ? length () -1 : start;
      return rfind (str, start); }
    int ReverseFind (const char* str, int start = -1) const
    { start = start == -1 ? length () -1 : start;
      return rfind (str, start); }
    int ReverseFind (char c, int start = -1) const
    { start = start == -1 ? length () -1 : start;
      return rfind (c, start); }

    /** Find one char from a set in a string. */
    int FindOneOf (const CdcString& charSet, int start = 0) const
    { return find_first_of (charSet, start); }

    /** Return pointer to the inner buffer of a string. */
    const char* GetBuffer () const
    { return c_str (); }


    /** Format a string like printf. */
//  void Format (char* strFormat, ... );


    /** Extract a sub string from the beginning that includes only characters
     * from charSet.
     */
    CdcString SpanIncluding (const CdcString& charSet) const;

    operator const char*() const
    { return this->GetBuffer (); }

    char operator [] (int place) const
    { return at (place); }

    char& operator [] (int place)
    { return at (place); }

    static CdcString IntToString (int num, const char* format = "%d");
};

#endif /* __CDC_STRING */