/************************************************************** * * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. * *************************************************************/ #ifndef CSV_STREAMSTR_HXX #define CSV_STREAMSTR_HXX // BASE CLASSES #include // USED SERVICES #include #include namespace csv { class String; void c_str(); // Dummy needed for StreamStr::operator<<(StreamStr::F_CSTR); /** A string buffer class for all kinds of string manipulation. */ class StreamStr : public bostream { public: typedef StreamStr self; typedef str::size size_type; typedef str::position position_type; typedef intt seek_type; typedef str::insert_mode insert_mode; typedef const char * const_iterator; typedef char * iterator; typedef void (*F_CSTR)(); /** Represents an area within a string. */ struct Area { typedef str::size size_type; Area( const char * i_str = "", size_type i_nLength = str::maxsize ) : sStr(i_str), nLength( i_nLength == str::maxsize ? strlen(i_str) : i_nLength ) {} const char * sStr; size_type nLength; }; // LIFECYCLE StreamStr( size_type i_nCapacity ); StreamStr( const char * i_sInitStr, size_type i_nCapacity ); /// Only used if > strlen(i_sInitStr). StreamStr( size_type i_nGuessedCapacity, const char * str1, // [!= 0] const char * str2, // [!= 0] ... ); // Has to end with NIL . StreamStr( csv::bstream & i_source ); /// Copies also insert_mode and current position. StreamStr( const self & i_rOther ); ~StreamStr(); // OPERATORS /// Copies also insert_mode and current position. self & operator=( const self & i_rOther ); self & operator<<( const char * i_s ); self & operator<<( const String & i_s ); self & operator<<( char i_c ); self & operator<<( unsigned char i_c ); self & operator<<( signed char i_c ); self & operator<<( short i_n ); self & operator<<( unsigned short i_n ); self & operator<<( int i_n ); self & operator<<( unsigned int i_n ); self & operator<<( long i_n ); self & operator<<( unsigned long i_n ); self & operator<<( float i_n ); self & operator<<( double i_n ); /** This operator is used to finish a sequence of streaming oeprators by returning the c-string of the complete string. @return The same as ->c_str(). @example csv::StreamStr s(100); const char * fullname = s << qualifier() << "::" << name() << csv::c_str; */ const char * operator<<( F_CSTR i_f ); const char & operator[]( position_type i_nPosition ) const; char & operator[]( position_type i_nPosition ); // OPERATIONS void resize( size_type i_nMinimumCapacity ); void clear(); void swap( StreamStr & io_swap ); /** Sets start point for the next operator<<() call. if the intended position is not reachable, nothing happens. */ self & seekp( seek_type i_nCount, seek_dir i_eDirection = ::csv::beg ); self & reset() { return seekp(0); } /** Sets the insertion mode of all and only the operator<<() calls. Default is str::overwrite: str::overwrite: seekp() always sets the cur end of the string. operator<<() calls push the end of the string forward. str::insert: seekp() only sets the insertion point. operator<<() calls insert their text at the tellp() position and keep the rest of the string. tellp() is then after the inserted text, on the beginning of the rest of the string. */ self & set_insert_mode( insert_mode i_eMode ); void push_front( const char * i_str ); void push_front( char i_c ); void push_back( const char * i_str ); void push_back( char i_c ); void pop_front( size_type i_nCount ); void pop_back( size_type i_nCount ); /// Works like operator<<(). Does the same as Perl's join(). self & operator_join( std::vector::const_iterator i_rBegin, std::vector::const_iterator i_rEnd, const char * i_sLink ); /// Works like operator<<() self & operator_add_substr( const char * i_sText, size_type i_nLength ); /// Works like operator<<() self & operator_add_token( const char * i_sText, char i_cDelimiter ); /// Works like operator<<() self & operator_read_line( bstream & i_src ); void strip_front( char i_cToRemove ); void strip_back( char i_cToRemove ); void strip_frontback( char i_cToRemove ); void strip_front_whitespace(); /// removes space, tab and crlf. void strip_back_whitespace(); void strip_frontback_whitespace(); /** @precond i_begin is valid @precond i_end is valid @precond i_end >= i_begin */ void remove( iterator i_begin, iterator i_end ); void replace( position_type i_nStart, size_type i_nSize, Area i_aReplacement ); void replace_all( char i_cCarToSearch, char i_cReplacement ); void replace_all( Area i_aStrToSearch, Area i_aReplacement ); StreamStr & to_lower( position_type i_nStart = 0, size_type i_nLength = str::maxsize ); StreamStr & to_upper( position_type i_nStart = 0, size_type i_nLength = str::maxsize ); // INQUIRY const char * c_str() const; const char * data() const; bool empty() const; size_type size() const; size_type length() const; size_type capacity() const; position_type tellp() const; const_iterator begin() const; const_iterator cur() const; const_iterator end() const; size_type token_count( char i_cSplit ) const; String token( position_type i_nNr, /// Starting with 0. char i_cSpli ) const; // ACCESS iterator begin(); iterator cur(); iterator end(); private: // Interface bostream virtual UINT32 do_write( const void * i_pSrc, UINT32 i_nNrofBytes); // Locals void ProvideAddingSize( size_type i_nSize2Add ); /// Resizes with the factor 2.0 (under 128), 1.5 or until i_nMinimumCapacity, whatever is bigger. void Resize( size_type i_nMinimumCapacity = 0 ); void Advance( size_type i_nAddedSize ); void MoveData( char * i_pStart, char * i_pEnd, seek_type i_nDiff ); // DATA size_type nCapacity1; /// Capacity of characters to contain + 1 for terminating 0. DYN char * dpData; char * pEnd; char * pCur; insert_mode eMode; }; class StreamStrLock { public: StreamStrLock( uintt i_nMinimalSize ); ~StreamStrLock(); StreamStr & operator()() { return *pStr; } private: StreamStr * pStr; }; /** Splits a string into tokens by whitespace. The tokens are added to the end of o_list. */ void Split( std::vector & o_list, const char * i_text ); inline void Join( StreamStr & o_text, std::vector & i_list, const char * i_sLink = " "); // IMPLEMENTATION inline const char * StreamStr::operator<<( F_CSTR ) { return dpData; } inline void StreamStr::clear() { pEnd = pCur = dpData; *pEnd = '\0'; } inline const char * StreamStr::c_str() const { return dpData; } inline const char * StreamStr::data() const { return dpData; } inline bool StreamStr::empty() const { return dpData == pEnd; } inline StreamStr::size_type StreamStr::size() const { return pEnd - dpData; } inline StreamStr::size_type StreamStr::length() const { return size(); } inline StreamStr::size_type StreamStr::capacity() const { return nCapacity1-1; } inline StreamStr::position_type StreamStr::tellp() const { return size_type(pCur-dpData); } inline StreamStr::const_iterator StreamStr::begin() const { return dpData; } inline StreamStr::const_iterator StreamStr::cur() const { return pCur; } inline StreamStr::const_iterator StreamStr::end() const { return pEnd; } inline StreamStr::iterator StreamStr::begin() { return dpData; } inline StreamStr::iterator StreamStr::cur() { return pCur; } inline StreamStr::iterator StreamStr::end() { return pEnd; } inline void Join( StreamStr & o_text, std::vector & i_list, const char * i_sLink ) { o_text.operator_join(i_list.begin(),i_list.end(),i_sLink); } } // namespace csv #endif