---

Ztring.h

Go to the documentation of this file.

// ZenLib::Ztring - std::string is better
// Copyright (C) 2002-2003 Jérôme Martinez, Zen@MediaArea.net
//
// This software is provided 'as-is', without any express or implied
// warranty.  In no event will the authors be held liable for any damages
// arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented; you must not
//    claim that you wrote the original software. If you use this software
//    in a product, an acknowledgment in the product documentation would be
//    appreciated but is not required.
// 2. Altered source versions must be plainly marked as such, and must not be
//    misrepresented as being the original software.
// 3. This notice may not be removed or altered from any source distribution.
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// String
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// Version 0.0.1
// -------------
// Gestion poussées des chaines de caractères
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//---------------------------------------------------------------------------
#ifndef ZenLib_ZtringH
#define ZenLib_ZtringH
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
#include <ZenLib/Utils.h>
#ifdef __BORLANDC__ //Warnings in Borland
#pragma warn -8059  //
#endif              //
#include <string>
#ifdef __BORLANDC__ //Warnings in Borland
#pragma warn .8059  //
#endif              //
//---------------------------------------------------------------------------

namespace ZenLib
{

//---------------------------------------------------------------------------
/// @brief Options for Ztring methods
enum ztring_t
{
    Ztring_Nothing,
    Ztring_Rounded              = 1,            ///< if >.5, upper, else lower
    Ztring_CaseSensitive        = 2,            ///< Case sensitive ("A" and "a" are different)
    Ztring_AddLastItem          = 4,            ///< if Begin is found and End is not found, return between Begin and end of string
    Ztring_Recursive            = 8             ///< Do all strings
};

//---------------------------------------------------------------------------

//***************************************************************************
/// @brief String manipulation (based on std::string)
/// @version 0.0.1
//***************************************************************************

using std::string;
class Ztring : public std::string  //for details about undocumented methods see http://www.sgi.com/tech/stl/basic_string.html
{
public :
    //Gestion de la classe
    Ztring ()                                                           : string(){};
    Ztring (const std::string& s, size_type pos=0, size_type n=npos)    : string(s.c_str(), pos, npos){};
    Ztring (const std::string* s, size_type pos=0, size_type n=npos)    : string(*s, pos, npos){};
    Ztring (const char *s)                                              : string(s){};
    Ztring (const char *s, size_type n)                                 : string(s, n){};
    Ztring (const char s)                                               : string(1, s){};
    Ztring (size_type n, const char s)                                  : string(n, s){};

    Ztring (const int32, size_type radix=10);
    Ztring (const uint32, size_type radix=10);
#if (MAXTYPES >= 64)
    Ztring (const int64, size_type radix=10);
    Ztring (const uint64, size_type radix=10);
#endif
    Ztring (const float);
    Ztring (const double);

    //Operators
    friend Ztring operator + (const char*, const Ztring &);
    Ztring operator + (const Ztring &) const;
    Ztring &operator += (const char*);
    Ztring &operator += (const Ztring &);
    char &operator () (size_type index)                                 {return operator [] (index);};

    //Conversions
        /// @deprecated Use c_str()
    const char* Char() const                                            {return c_str();};
        /// @brief return a new char array
        /// @warning you MUST delete this pointer! (delete[])
    char* ToChar() const;
        /// @brief Convert into Int (32 bits)
        /// @return the value corresponding \n
        ///         0 if there is a problem
    int32 Convert_int32(ztring_t Options=Ztring_Rounded) const;
        /// @brief Convert into unsigned Int (32 bits)
        /// @return the value corresponding
        ///         0 if there is a problem
    uint32 Convert_uint32(ztring_t Options=Ztring_Rounded) const;
#if (MAXTYPES >= 64)
        /// @brief Convert into Int (64 bits)
        /// @return the value corresponding \n
        ///         0 if there is a problem
    int64 Convert_int64(ztring_t Options=Ztring_Rounded) const;
        /// @brief Convert into unsigned Int (64 bits)
        /// @return the value corresponding \n
        ///         0 if there is a problem
    uint64 Convert_uint64(ztring_t Options=Ztring_Rounded) const;
#endif
        /// @brief Convert into float
        /// @return the value corresponding \n
        ///         0 if there is a problem
    float Convert_float(ztring_t Options=Ztring_Rounded) const; //Vers decimal

    //Edition
        /// @brief convert into lowercase
    Ztring* MakeLowerCase();
        /// @brief convert into uppercase
    Ztring* MakeUpperCase();
        /// @brief Remove leading whitespaces from a string
    Ztring* TrimLeft();
        /// @brief Remove trailing whitespaces from a string
    Ztring* TrimRight();
        /// @brief Remove leading and trailing whitespaces from a string
    Ztring* Trim();
        /// @brief Quotes a string
    Ztring* Quote();
        /// @brief return a string between two strings
        /// @param Begin First string
        /// @param End Second string
        /// @param Pos Position to begin to scan string
        /// @param Options Options for searching \n
        ///                Available : Ztring_CaseSensitive
        /// @return The substring \n
        ///         "" if not found
    Ztring SubString (const std::string &Begin, const std::string &End, int Pos=0, ztring_t Options=Ztring_Nothing) const;
        /// @brief replace a string by another one
        /// @param ToFind string to find
        /// @param ToReplace string wich replace the string found
        /// @param Pos Position to begin to scan string
        /// @param Options Options for searching \n
        ///                Available : Ztring_CaseSensitive, Ztring_Recursive
        /// @return The substring \n
        ///         "" if not found
    int FindAndReplace (const std::string &ToFind, const std::string &ReplaceBy, size_t Pos=0, ztring_t Options=Ztring_Nothing); //Remplace une chaine par une autre

/*

    //Edition
    int Rechercher (const Ztring &Trouver, int Pos_Debut=0, int Pos_Fin=-1, int Options=0) const; //Retourne la position d'une chaine de caractère. Sens inverse possible, -1 si jusqu'a la fin
    Ztring RechercherEntre (const Ztring &Debut, const Ztring &Fin, int Pos_Debut=0, int Pos_Fin=-1, int Options=0) const; //Retourne une Chaine situe entre deux chaines
    Ztring SousChaine (int Pos_Debut, int Nb_Char=-1) const; //Retourne une Chaine situe entre deux positions (pos debut puis nombre de characteres)
    Ztring SousChaine_Pos (int Pos_Debut, int Pos_Fin=-1) const; //Retourne une Chaine situe entre deux positions (pos debut et pos fin)
    int Remplacer (const Ztring &Trouver, const Ztring &RemplacerPar, int Pos_Debut=0, int Pos_Fin=-1, int Options=0); //Remplace une chaine par une autre
    Ztring Reformater_Sortie (const Ztring &Trouver, const Ztring &RemplacerPar, int Pos_Debut=0, int Pos_Fin=-1, int Options=0); //Remplace une chaine par une autre
    int Compter(const Ztring &ACompter, int Options=0) const; //Compte le nombre d'occurence d'une chaine
    bool Comparer (const Ztring &AComparer, const Ztring &Comparateur, int Options=0) const; //Comapre une chaine avec une autre

    //Traitements
    Ztring *ToMin (); //Converti en minuscules
    Ztring *ToMaj (); //Converti en majuscules
*/
};

} //NameSpace
#endif

---