nevrax.org : docs

00001 
+00007 /* Copyright, 2000 Nevrax Ltd.
+00008  *
+00009  * This file is part of NEVRAX NEL.
+00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
+00011  * it under the terms of the GNU General Public License as published by
+00012  * the Free Software Foundation; either version 2, or (at your option)
+00013  * any later version.
+00014 
+00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
+00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
+00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+00018  * General Public License for more details.
+00019 
+00020  * You should have received a copy of the GNU General Public License
+00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
+00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+00023  * MA 02111-1307, USA.
+00024  */
+00025 
+00026 #include "stdgeorges.h"
+00027 #include "nel/georges/string_ex.h"
+00028 
+00029 namespace NLGEORGES
+00030 {
+00031 
+00033 // Construction/Destruction
+00035 using namespace std;
+00036 CStringEx::~CStringEx()
+00037 {
+00038 
+00039 }
+00040 
+00041 void CStringEx::remove( const char _c )
+00042 {
+00043         if( empty() )
+00044                 return;
+00045         iterator it = begin();
+00046         while( it != end() ) 
+00047         {
+00048                 if( (*it) == _c )
+00049                         it = erase( it );
+00050                 else
+00051                         ++it;
+00052         }
+00053 }
+00054 
+00055 void CStringEx::remove()
+00056 {
+00057         remove(' ');
+00058         remove('\t');
+00059         remove('\n');
+00060 }
+00061 
+00062 void    CStringEx::make_lower( )
+00063 {
+00064         for( iterator it = begin(); it != end(); ++it )
+00065                 if( (*it >= 'A')&&(*it <= 'Z') )
+00066                         *it += 'a'-'A';
+00067 }
+00068 
+00069 void    CStringEx::make_upper( )
+00070 {
+00071         for( iterator it = begin(); it != end(); ++it )
+00072                 if( (*it >= 'a')&&(*it <= 'z') )
+00073                         *it += 'A'-'a';
+00074 }
+00075 
+00076 void    CStringEx::trim_left( )
+00077 {
+00078         if( empty() )
+00079                 return;
+00080         iterator it;
+00081         for( it = begin(); (it != end())&&( (*it==' ')||(*it=='\t')||(*it=='\n') ); ++it );
+00082         erase( begin(), it );
+00083 }
+00084 
+00085 void    CStringEx::trim_left( const char _c )
+00086 {
+00087         if( empty() )
+00088                 return;
+00089         iterator it;
+00090         for( it = begin(); (it != end())&&( *it == _c ); ++it );
+00091         erase( begin(), it );
+00092 }
+00093 
+00094 void    CStringEx::trim_right( ) 
+00095 {
+00096         if( empty() )
+00097                 return;
+00098         iterator it = end();
+00099         --it;
+00100         while( it != begin() )
+00101         {
+00102                 iterator i = it--;
+00103                 if( (*i==' ')||(*i=='\t')||(*i=='\n') )
+00104                         erase( i );
+00105                 else
+00106                         break;
+00107         }
+00108         if( (*it==' ')||(*it=='\t')||(*it=='\n') )
+00109                 erase( it );
+00110 }
+00111 
+00112 void    CStringEx::trim_right( char c )
+00113 {
+00114         if( empty() )
+00115                 return;
+00116         iterator it = end();
+00117         while( it != begin() )
+00118         {
+00119                 iterator i = it--;
+00120                 if( *i == c )
+00121                         erase( i );
+00122                 else
+00123                         break;
+00124         }
+00125         if( *it == c )
+00126                 erase( it );
+00127 }
+00128 
+00129 void CStringEx::trim()
+00130 {
+00131         trim_left();
+00132         trim_right();
+00133 }
+00134 
+00135 void CStringEx::purge()
+00136 {
+00137         make_lower();
+00138         remove(' ');
+00139         remove('\t');
+00140         remove('\n');
+00141 }
+00142 
+00143 void CStringEx::trim( const char _c )
+00144 {
+00145         trim_left( _c );
+00146         trim_right( _c );
+00147 }
+00148 
+00149 void    CStringEx::mid( const int nFirst )
+00150 {
+00151         CStringEx s( *this );
+00152         erase();
+00153         append( s.get_mid( nFirst ));
+00154 }
+00155 
+00156 void    CStringEx::mid( const int nFirst, const int nCount )
+00157 {
+00158         CStringEx s( *this );
+00159         erase();
+00160         append( s.get_mid( nFirst, nCount ));
+00161 }
+00162 
+00163 void    CStringEx::left( const int nCount )
+00164 {
+00165         CStringEx s( *this );
+00166         erase();
+00167         append( s.get_left( nCount ));
+00168 }
+00169 
+00170 void    CStringEx::right( const int nCount )
+00171 {
+00172         CStringEx s( *this );
+00173         erase();
+00174         append( s.get_right( nCount ));
+00175 }
+00176 
+00177 
+00178 CStringEx CStringEx::get_remove( const char _c ) const
+00179 {
+00180         CStringEx s( *this );
+00181         s.remove( _c );
+00182         return( s );
+00183 }
+00184 
+00185 CStringEx CStringEx::get_remove() const
+00186 {
+00187         CStringEx s( *this );
+00188         s.remove();
+00189         return( s );
+00190 }
+00191 
+00192 CStringEx CStringEx::get_make_lower() const
+00193 {
+00194         CStringEx s( *this );
+00195         s.make_lower();
+00196         return( s );
+00197 }
+00198 
+00199 CStringEx CStringEx::get_make_upper() const
+00200 {
+00201         CStringEx s( *this );
+00202         s.make_upper();
+00203         return( s );
+00204 }
+00205 
+00206 CStringEx CStringEx::get_trim_left() const
+00207 {
+00208         CStringEx s( *this );
+00209         s.trim_left();
+00210         return( s );
+00211 }
+00212 
+00213 CStringEx CStringEx::get_trim_left( const char _c ) const
+00214 {
+00215         CStringEx s( *this );
+00216         s.trim_left( _c );
+00217         return( s );
+00218 }
+00219 
+00220 CStringEx CStringEx::get_trim_right() const
+00221 {
+00222         CStringEx s( *this );
+00223         s.trim_right();
+00224         return( s );
+00225 }
+00226 
+00227 CStringEx CStringEx::get_trim_right( const char _c ) const
+00228 {
+00229         CStringEx s( *this );
+00230         s.trim_right( _c );
+00231         return( s );
+00232 }
+00233 
+00234 CStringEx CStringEx::get_trim() const
+00235 {
+00236         CStringEx s( *this );
+00237         s.trim();
+00238         return( s );
+00239 }
+00240 
+00241 CStringEx CStringEx::get_purge() const
+00242 {
+00243         CStringEx s( *this );
+00244         s.purge();
+00245         return( s );
+00246 }
+00247 
+00248 CStringEx CStringEx::get_trim( const char _c ) const
+00249 {
+00250         CStringEx s( *this );
+00251         s.trim( _c );
+00252         return( s );
+00253 }
+00254 
+00255 CStringEx       CStringEx::get_mid( const int nFirst ) const
+00256 {
+00257         if( !size() )
+00258           {
+00259             CStringEx object;
+00260                 return( object );
+00261           }
+00262         return( get_right( size()-nFirst ) );
+00263 }
+00264 
+00265 CStringEx       CStringEx::get_mid( const int nFirst, const int nCount ) const
+00266 {
+00267         if( !size() )
+00268           {
+00269             CStringEx object;
+00270                 return( object );
+00271           }
+00272         return( substr( nFirst, nCount ) );
+00273 }
+00274 
+00275 CStringEx       CStringEx::get_left( const int nCount ) const
+00276 {
+00277         if( !size() )
+00278           {
+00279             CStringEx object;
+00280                 return( object );
+00281           }
+00282         return( substr( 0, nCount ) );
+00283 }
+00284 
+00285 CStringEx       CStringEx::get_right( const int nCount ) const
+00286 {
+00287         if( !size() )
+00288           {
+00289             CStringEx object;
+00290                 return( object );
+00291           }
+00292         return( substr( size()-nCount, nCount ) );
+00293 }
+00294 
+00295 
+00296 bool  CStringEx::operator <= ( const CStringEx& s ) const 
+00297 {
+00298         const_iterator it = begin();
+00299         const_iterator is = s.begin();
+00300         while( ( it != end() )&&( is != s.end() ) )
+00301         {
+00302                 if( *it != *is )
+00303                         return( *it < *is );
+00304                 it++;
+00305                 is++;
+00306         }
+00307         return( ( it == end() )&&( is == s.end() ) );
+00308 }
+00309 
+00310 bool  CStringEx::operator < ( const CStringEx& s ) const 
+00311 {
+00312         const_iterator it = begin();
+00313         const_iterator is = s.begin();
+00314         while( ( it != end() )&&( is != s.end() ) )
+00315         {
+00316                 if( *it != *is )
+00317                         return( *it < *is );
+00318                 it++;
+00319                 is++;
+00320         }
+00321         return( is != s.end() );
+00322 }
+00323 
+00324 int CStringEx::reverse_find( const char _c ) const
+00325 {
+00326         unsigned int i = length();
+00327         const_iterator it = end();
+00328         while( it != begin() )
+00329         {
+00330                 --it;
+00331                 --i;
+00332                 if( *it == _c )
+00333                         return( i );
+00334         }
+00335         return( npos );
+00336 }
+00337 
+00338 void CStringEx::format( const char* s, ... )
+00339 {
+00340         char *p = new char[256];
+00341         va_list ap;
+00342         va_start(ap, s);
+00343         int x = vsprintf( p, s, ap);
+00344         erase();
+00345         append(p);
+00346         delete[] p;
+00347 }
+00348 
+00349 /*
+00350    #include <stdio.h>
+00351    #include <stdlib.h>
+00352    #include <stdarg.h>
+00353    char *newfmt(const char *fmt, ...)
+00354    {
+00355            char *p;
+00356            va_list ap;
+00357            if ((p = malloc(128)) == NULL)
+00358                            return (NULL);
+00359            va_start(ap, fmt);
+00360            (void) vsnprintf(p, 128, fmt, ap);
+00361            va_end(ap);
+00362            return (p);
+00363    }
+00364 */
+00365 
+00366 }
+
string_ex.cpp
