xref: /trunk/main/autodoc/inc/cosv/streamstr.hxx (revision 0cb2ec9199fb5d9d8559bd2a77a1f1aa86ec209c)

/**************************************************************
 *
 * 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 <cosv/bstream.hxx>
// USED SERVICES
#include <cosv/str_types.hxx>
#include <string.h>




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
        operators 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<String>::const_iterator
                                                i_rBegin,
                            std::vector<String>::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<String> &
                                            o_list,
                        const char *        i_text );
inline void         Join(
                        StreamStr &         o_text,
                        std::vector<String> &
                                            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<String> & i_list,
      const char *          i_sLink )
{
    o_text.operator_join(i_list.begin(),i_list.end(),i_sLink);
}




}   // namespace csv
#endif