bufstring.h

#ifndef bufstring_h
#define bufstring_h

/*+
________________________________________________________________________

 (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.
 RCS:           $Id: bufstring.h,v 1.41 2010-03-29 20:09:10 cvskris Exp $
________________________________________________________________________

-*/

#include "convert.h"
#include <iosfwd>

mClass BufferString
{
public:

    inline              BufferString();
    inline              BufferString(const char*);
                        BufferString(int minlen,bool setnull);
                        BufferString(const BufferString& bs);
    template <class T>
    inline              BufferString(const char*,T,const char* s=0);
    virtual             ~BufferString();

    BufferString&       operator=(const char*);
    inline BufferString& operator=(const BufferString& bs);
    template <class T>
    inline BufferString& operator=(T);

    inline bool         operator==(const BufferString&) const;
    inline bool         operator!=(const BufferString&) const;
    bool                operator==(const char*) const;
    inline bool         operator!=(const char*) const;
    template <class T>
    inline bool         operator==(T) const;
    template <class T>
    inline bool         operator!=( T t ) const         { return !(*this==t); }

    char*               buf();          
    inline const char*  buf() const     { return buf_ ? buf_ : empty().buf_; }
    inline const char*  str() const;    
    inline              operator const char*() const    { return buf(); }
    inline char&        operator []( int idx )          { return buf()[idx]; }
    inline const char&  operator []( int idx ) const    { return buf()[idx]; }
    bool                isEmpty() const;
    void                setEmpty();
    bool                isEqual(const char*,bool caseinsens=false) const;
    bool                isStartOf(const char*,bool caseinsens=false) const;
    bool                matches(const char*,bool caseinsens=false) const;

    BufferString&       add(const char*);
    template <class T>
    BufferString&       add(T);
    BufferString&       operator+=( const char* s )     { return add( s ); }
    template <class T>
    inline BufferString& operator+=( T t )              { return add( t ); }

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

    void                insertAt(int idx, const char*);
                        //< If idx >= size(), pads spaces
    void                replaceAt(int idx, const char*,bool cutoff=true);
                        //< If idx >= size(), pads spaces

    bool                operator >(const char*) const;
    bool                operator <(const char*) const;
    template <class T>
    inline bool         operator >(T) const;
    template <class T>
    inline bool         operator <(T) const;

    static const BufferString& empty();

protected:

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

private:

    void                init();
    inline void         destroy()       { delete [] buf_; buf_ = 0; }

};

mGlobal std::ostream& operator <<(std::ostream&,const BufferString&);
mGlobal std::istream& operator >>(std::istream&,BufferString&);


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

inline BufferString::BufferString()
    : mBufferStringSimpConstrInitList   {}
inline BufferString::BufferString( const char* s )
    : mBufferStringSimpConstrInitList   { *this = s; }

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


inline
const char* BufferString::str() const   
{ return isEmpty() ? 0 : buf_; }        


inline bool BufferString::operator==( const BufferString& s ) const
{ return operator ==( s.buf() ); }

template <class T> inline bool BufferString::operator==( T t ) const
{ return *this == Conv::to<const char*>( t ); }

inline bool BufferString::operator!=( const BufferString& s ) const
{ return operator !=( s.buf() ); }

inline  bool BufferString::operator!=( const char* s ) const
{ return ! (*this == s); }

inline BufferString& BufferString::operator=( const BufferString& bs )
{ if ( &bs != this ) *this = bs.buf_; return *this; }

template <class T> inline BufferString& BufferString::operator=( T t )
{ *this = Conv::to<const char*>( t ); return *this; }

template <class T> inline BufferString& BufferString::add( T t )
{ return add( Conv::to<const char*>( t ) ); }

template <class T> inline bool BufferString::operator >( T t ) const
{ return *this > ( Conv::to<const char*>( t ) ); }

template <class T> inline bool BufferString::operator <( T t ) const
{ return *this < ( Conv::to<const char*>( t ) ); }


#endif