bufstring.h

Go to the documentation of this file.

#pragma once

/*+
________________________________________________________________________

 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        A.H.Bril
 Date:          12-4-2000
 Contents:      Variable buffer length strings with minimum size.
________________________________________________________________________

-*/

#include "basicmod.h"
#include "fixedstring.h"
#include "string2.h"
class QString;

mExpClass(Basic) BufferString : public OD::String
{
public:

    inline              BufferString();
    inline              BufferString(const char*);
                        BufferString(const OD::String&);
                        BufferString(int minlen,bool setnull);
                        BufferString(const BufferString&);
    template <class T>
    inline              BufferString(const char*,const T&,const char* s=0);
                        BufferString(const QString&);
    virtual             ~BufferString();
    inline BufferString& operator=( const BufferString& b )
                                                { return assignTo(b.buf_); }
    inline BufferString& operator=( const char* s )
                                                { return assignTo(s); }
    inline BufferString& operator=( const FixedString& s )
                                                { return assignTo(s.str()); }
    inline BufferString& operator=( const OD::String& s )
                                                { return assignTo(s.str()); }
    template <class T>
    inline BufferString& operator=(const T&);

    inline              operator const char*() const    { return buf(); }

    inline bool         operator==(const BufferString&) const;
    inline bool         operator!=(const BufferString&) const;
    inline bool         operator==(const char*) const;
    inline bool         operator!=(const char*) const;
    inline bool         operator==(const OD::String&) const;
    inline bool         operator!=(const OD::String&) const;
    inline bool         operator==(const FixedString&) const;
    inline bool         operator!=(const FixedString&) const;

    inline char*        getCStr()
    { return const_cast<char*>(const_cast<BufferString*>(this)->gtBuf()); }
    void                fill(char*,int maxnrchar) const;

    inline char&        operator []( int idx )  { return getCStr()[idx]; }
    inline char&        first()                 { return getCStr()[0]; }
    inline char&        last()                  { return getCStr()[size()-1]; }
    char*               find(char);
    char*               find(const char*);
    inline const char*  find(char) const;
    inline const char*  find(const char*) const;
    char*               findLast(char);
    char*               findLast(const char*);
    inline const char*  findLast(char) const;
    inline const char*  findLast(const char*) const;

    BufferString&       setEmpty();
    BufferString&       set(const char*);
    BufferString&       set( const OD::String& s )      { return set(s.str()); }
    template <class T>
    BufferString&       set(const T&);
    BufferString&       set(float,int nrdec);
    BufferString&       set(double,int nrdec);
    BufferString&       setLim(float,int maxnrchars);
    BufferString&       setLim(double,int maxnrchars);

    BufferString&       add(char);
    BufferString&       add(const char*);
    BufferString&       add( const OD::String& s )      { return add(s.str()); }
    BufferString&       add(const QString&);
    template <class T>
    BufferString&       add(const T&);
    BufferString&       add(float,int nrdec);
    BufferString&       add(double,int nrdec);
    BufferString&       addLim(float,int maxnrchars);
    BufferString&       addLim(double,int maxnrchars);

    BufferString&       addSpace(int nrspaces=1);
    BufferString&       addTab(int nrtabs=1);
    BufferString&       addNewLine(int nrnewlines=1);

    inline unsigned int bufSize() const         { return len_; }
    bool                setBufSize(unsigned int);
    inline unsigned int minBufSize() const      { return minlen_; }
    void                setMinBufSize(unsigned int);

    BufferString&       replace(char from,char to);
    BufferString&       replace(const char* from,const char* to);
    BufferString&       remove(char);
    inline BufferString& remove( const char* s )        { return replace(s,0); }
    BufferString&       trimBlanks(); 

    BufferString&       insertAt(int idx, const char*);
                                //< If idx >= size(), pads spaces
    BufferString&       replaceAt(int idx, const char*,bool cutoff=true);
                                //< If idx >= size(), pads spaces
    BufferString&       toLower();
    BufferString&       toUpper();
    BufferString&       embed(char open,char close);
    BufferString&       unEmbed(char open,char close);
    inline BufferString& quote( char q='\'' )           { return embed(q,q); }
    inline BufferString& unQuote( char q='\'' )         { return unEmbed(q,q); }

    enum CleanType      { OnlyAlphaNum, AllowDots,
                          NoSpaces, NoFileSeps, NoSpecialChars };
    BufferString&       clean(CleanType ct=OnlyAlphaNum);

    static const BufferString& empty();

protected:

    char*               buf_;
    unsigned int        len_;
    const unsigned int  minlen_;

    BufferString&       assignTo(const char*);

    const char*         gtBuf() const;
    inline const char*  gtStr() const;

private:

    void                init();
    inline void         destroy()       { delete [] buf_; buf_ = 0; }
    BufferString&       addArr32Chars(const char*,int);

public:

    // use add instead
    inline BufferString& operator+=( const char* s )    { return add( s ); }
    inline BufferString& operator+=( const OD::String& s )
                                                        { return add(s.str()); }
    template <class T>
    inline BufferString& operator+=( const T& t )       { return add( t ); }

};


//Not implemented on purpose as it leads unwanted conversions to
//BufferStrings on the fly
inline bool operator==(const char*,const BufferString&) = delete;
inline bool operator!=(const char*,const BufferString&) = delete;

#define mBufferStringSimpConstrInitList \
    minlen_(mMaxFilePathLength+1), buf_(0), len_(0)

inline BufferString::BufferString()
    : mBufferStringSimpConstrInitList   {}
inline BufferString::BufferString( const char* s )
    : mBufferStringSimpConstrInitList   { assignTo(s); }
inline BufferString::BufferString( const OD::String& s )
    : mBufferStringSimpConstrInitList   { assignTo(s.str()); }

template <class T> inline
BufferString::BufferString( const char* s1, const T& t, const char* s2 )
    : mBufferStringSimpConstrInitList
{ *this += s1; *this += t; *this += s2; }

inline const char* BufferString::gtStr() const
{ return buf_ && *buf_ ? const_cast<char*>( buf_ ) : 0; }

inline bool BufferString::operator==( const BufferString& s ) const
{ return isEqual( s.buf_ ); }
inline bool BufferString::operator!=( const BufferString& s ) const
{ return !isEqual( s.buf_ ); }
inline bool BufferString::operator==( const char* s ) const
{ return isEqual( s ); }
inline bool BufferString::operator!=( const char* s ) const
{ return !isEqual( s ); }
inline bool BufferString::operator==( const FixedString& s ) const
{ return isEqual( s.str() ); }
inline bool BufferString::operator!=( const FixedString& s ) const
{ return !isEqual( s.str() ); }
inline bool BufferString::operator==( const OD::String& s ) const
{ return isEqual( s.str() ); }
inline bool BufferString::operator!=( const OD::String& s ) const
{ return !isEqual( s.str() ); }

inline const char* BufferString::find( char c ) const
{ return OD::String::find( c ); }
inline const char* BufferString::find( const char* s ) const
{ return OD::String::find( s ); }
inline const char* BufferString::findLast( char c ) const
{ return OD::String::findLast( c ); }
inline const char* BufferString::findLast( const char* s ) const
{ return OD::String::findLast( s ); }

template <class T> inline BufferString& BufferString::operator=( const T& t )
{ return set( t ); }

template <class T> inline BufferString& BufferString::add( const T& t )
{ return add( toString(t) ); }

inline BufferString& BufferString::set( const char* s )
{ setEmpty(); return add( s ); }

template <class T> inline BufferString& BufferString::set( const T& t )
{ setEmpty(); return add( t ); }

inline BufferString& BufferString::set( float f, int nrdec )
{ setEmpty(); return add( f, nrdec ); }

inline BufferString& BufferString::set( double d, int nrdec )
{ setEmpty(); return add( d, nrdec ); }

inline BufferString& BufferString::setLim( float f, int maxnrchars )
{ setEmpty(); return addLim( f, maxnrchars ); }

inline BufferString& BufferString::setLim( double d, int maxnrchars )
{ setEmpty(); return addLim( d, maxnrchars ); }


mExpClass(Basic) StringPair
{
public:

                        StringPair(const char* str1, const char* str2)
                            : first_(str1), second_(str2) {}
                        StringPair(const char* compstr);

    static char         separator() { return '|'; }

    const BufferString& first() const   { return first_; }
    BufferString&       first()         { return first_; }
    const BufferString& second() const  { return second_; }
    BufferString&       second()        { return second_; }

    const OD::String&   getCompString() const;

protected:

    BufferString        first_;
    BufferString        second_;

};