separstr.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:          May 1995
 Contents:      String with a separator between the items
________________________________________________________________________

-*/

#include "basicmod.h"
#include "bufstring.h"
#include "fixedstring.h"
#include "convert.h"

class BufferStringSet;
class DBKey;

mExpClass(Basic) SeparString
{
public:

                        SeparString( const char* escapedstr=0, char separ=',' )
                        { initSep( separ ); initRep( escapedstr ); }
                        SeparString( const SeparString& ss )
                        : rep_(ss.rep_) { initSep( ss.sep_[0] ); }

    SeparString&        operator=(const SeparString&);
    SeparString&        operator=(const char* escapedstr);

    inline bool         isEmpty() const         { return rep_.isEmpty(); }
    inline void         setEmpty()              { rep_.setEmpty(); }

    int                 size() const;
    FixedString         operator[](int) const;          
    FixedString         from(int) const;                

    int                 getIValue(int) const;
    od_uint32           getUIValue(int) const;
    od_int64            getI64Value(int) const;
    od_uint64           getUI64Value(int) const;
    float               getFValue(int) const;
    double              getDValue(int) const;
    bool                getYN(int) const;

    int                 indexOf(const char* unescapedstr) const;

    SeparString&        add(const BufferStringSet&);    
    SeparString&        add(const SeparString&);        
    SeparString&        add(const DBKey&);
    SeparString&        add(const char* unescapedstr);
    inline SeparString& add( const OD::String& ods )
                        { return add( ods.buf() ); }
    template <class T>
    inline SeparString& add( T t )
                        { return add( toString(t) ); }

    SeparString&        set( const BufferStringSet& bss )
                        { setEmpty(); return add( bss ); }
    SeparString&        set( const SeparString& s )
                        { setEmpty(); return add( s ); }
    SeparString&        set( const char* unescapedstr )
                        { setEmpty(); return add( unescapedstr ); }
    inline SeparString& set( const OD::String& ods )
                        { return set( ods.buf() ); }
    template <class T>
    inline SeparString& set( T t )
                        { setEmpty(); return add( t ); }

    template <class T>
    inline SeparString& operator +=( T t )      { return add( t ); }
    template <class T>
    inline SeparString& operator +=( const OD::String& ods )
                                                { return add( ods.buf() ); }

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

    inline char*        getCStr()               { return rep_.getCStr(); }
    inline const char*  buf() const             { return rep_.buf(); }
    BufferString&       rep()                   { return rep_; }
    const OD::String&   rep() const             { return rep_; }

    inline const char*  unescapedStr() const    { return getUnescaped(buf()); }
    inline char         sepChar() const         { return *sep_; }
    inline const char*  sepStr() const          { return sep_; }
    void                setSepChar(char);

private:

    char                sep_[2];
    BufferString        rep_;

    void                initRep(const char*);
    inline void         initSep( char s )       { sep_[0] = s; sep_[1] = '\0'; }

    mutable BufferString retstr_;

    const char*         getEscaped(const char* unescapedstr,char sep) const;
    const char*         getUnescaped(const char* escapedstartptr,
                                     const char* nextsep=0) const;

    const char*         findSeparator(const char*) const;
};


mExpClass(Basic) FileMultiString : public SeparString
{
public:

                        FileMultiString(const char* escapedstr=0)
                            : SeparString(escapedstr, separator() )     {}
                        FileMultiString(const char* s1,const char* s2,
                                        const char* s3=0,const char*s4=0);
    template <class T>  FileMultiString( const T& t )
                            : SeparString(t,separator())                {}

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

    // The function template overloading add(const SeparString&) in the base
    // class needs an exact match! Passing a derived object would make the
    // template function convert it to (const char*).
    inline FileMultiString& add( const FileMultiString& fms )
                        { return add( (SeparString&)fms ); }
    template <class T> inline
    FileMultiString&    operator +=( T t )              { return add( t ); }
    inline FileMultiString& operator +=( const OD::String& ods )
                                                { return add( ods.buf() ); }

    template <class T> inline
    FileMultiString&    add( T t )
                        { SeparString::add( t ); return *this; }
    inline FileMultiString& add( const OD::String& ods )
                        { return add( ods.buf() ); }

};