uistring.h

Go to the documentation of this file.

#pragma once

/*+
________________________________________________________________________

 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        K. Tingdahl
 Date:          Jan 2014
________________________________________________________________________

-*/

#include "gendefs.h"
#include "threadlock.h"
#include "string2.h"
#include "objectset.h"

class uiStringData;
class uiStringSet;
class uiRetVal;

mFDQtclass( QString );
mFDQtclass( QStringList );
mFDQtclass( QTranslator );


#define mTextTranslationClass(clss,application) \
private: \
 static inline uiString tr( const char* text, const char* disambiguation = 0,  \
 int pluralnr=-1 ) \
 { return uiString( text, #clss, application, disambiguation, pluralnr ); } \
 static inline uiString legacyTr( const char* text, \
                                  const char* disambiguation = 0,  \
                                  int pluralnr=-1 ) \
 { return uiString( text, #clss, application, disambiguation, pluralnr ); }

#define mODTextTranslationClass(clss) \
mTextTranslationClass( clss, uiString::sODLocalizationApplication() )


mExpClass(Basic) uiString
{ mODTextTranslationClass(uiString);
public:
                uiString();
                uiString(const uiString&);      
                ~uiString();

    uiString&   set(const char*);
    bool        isEmpty() const;
    void        setEmpty();
    uiString&   toLower(bool yn=true);
    bool        operator!() const               { return isEmpty(); }

    uiString&   operator=(const uiString&);     
    bool        operator>(const uiString& b) const;
    bool        operator<(const uiString& b) const;
    int         size() const;
    static const uiString& emptyString()        { return emptystring_; }


    template <class T>
    uiString&   arg(const T& var);
    uiString&   arg(const uiString&);

    uiString&   append(const char*, bool withnewline=false);
    uiString&   append(const OD::String&, bool withnewline=false);
    uiString&   append(const uiString&, bool withnewline=false);


    const OD::String&           getFullString(BufferString* = 0) const;
    wchar_t*                    createWCharString() const;
    const char*                 getOriginalString() const;
    const mQtclass(QString)&    getQString() const;
    const mQtclass(QString)&    fillQString(QString&) const;
    const BufferString&         fillUTF8String(BufferString&) const;
    void                        getHexEncoded(BufferString&) const;
    bool                        setFromHexEncoded(const char*);
private:

    inline                      operator bool() const   { return !isEmpty(); }
    bool                        isCacheValid() const;
    const mQtclass(QString)&    getQStringInternal() const;

    friend class                uiStringData;

    char*                       debugstr_;
                                /*<!< Contains getFullString() for easy debuggin
                                      Only filled in in debug builds. */

    mutable uiStringData*       data_;
    mutable Threads::Lock       datalock_;      
    static const uiString       emptystring_;

    bool                        operator==( const uiString&  oth ) const
                                { return isEqualTo( oth ); }
    bool                        operator!=( const uiString& oth ) const
                                { return !isEqualTo( oth ); }

public:

                //Only for expert users
    mDeprecated                 uiString(const char* inp);
    mDeprecated                 uiString(const OD::String&);
    mDeprecated uiString&       operator=(const char*);
    mDeprecated uiString&       operator=(const OD::String&);
    mDeprecated bool            isSet() const   { return !isEmpty(); }

    bool        isEqualTo(const uiString& oth) const;

    static const char*  sODLocalizationApplication() { return "od"; }

    void        makeIndependent();
                uiString(const char* original,
                         const char* context,
                         const char* application,
                         const char* disambiguation,
                         int pluralnr);
    void        setFrom(const mQtclass(QString)&);
    void        addLegacyVersion(const uiString&);
    bool        translate(const mQtclass(QTranslator)&,
                          mQtclass(QString)&) const;

    static uiString getOrderString(int);
                //Returns 1st, 2nd, 3rd

    uiString&   addSpace(int nr=1);
    uiString&   addTab(int nrtabs=1);
    uiString&   addNewLine(int nrnl=1);
};


mGlobal(Basic) uiString toUiString(const uiString&);
mGlobal(Basic) uiString toUiString(const char*);
mGlobal(Basic) uiString toUiString(const OD::String&);
mGlobal(Basic) uiString toUiString(od_int32);
mGlobal(Basic) uiString toUiString(od_int64);
mGlobal(Basic) uiString toUiString(od_uint32);
mGlobal(Basic) uiString toUiString(od_uint64);
mGlobal(Basic) uiString toUiString(float);
mGlobal(Basic) uiString toUiString(double);
mGlobal(Basic) uiString toUiString(float,int nrdec);
mGlobal(Basic) uiString toUiString(double,int nrdec);



/*\brief Set of uiStrings */

mExpClass(Basic) uiStringSet
{ mODTextTranslationClass(uiStringSet);
public:

    typedef ObjectSet<uiString>::size_type      size_type;
    typedef size_type                           IdxType;

                        uiStringSet()                           {}
                        uiStringSet( const uiString& s )        { set(s); }
                        uiStringSet( const uiStringSet& oth )   { *this = oth; }
                        uiStringSet(const uiString[]);
                        ~uiStringSet();
    uiStringSet&        operator =(const uiStringSet&);

    inline size_type    size() const                { return strs_.size(); }
    inline bool         validIdx( IdxType i ) const { return strs_.validIdx(i);}
    bool                isEmpty() const             { return strs_.isEmpty(); }
    bool                isPresent(const uiString&) const;
    IdxType             indexOf(const uiString&) const;
    uiString            get(IdxType) const;
    uiString&           operator[]( IdxType idx )       { return *strs_[idx]; }
    const uiString&     operator[]( IdxType idx ) const { return *strs_[idx]; }

    void                setEmpty();
    uiStringSet&        set(const uiString&);
    uiStringSet&        set( const uiStringSet& oth )   { return (*this=oth); }
    uiStringSet&        set(const uiRetVal&);
    uiStringSet&        add(const uiString&);
    uiStringSet&        add(const uiStringSet&);
    uiStringSet&        add(const uiRetVal&);
    uiStringSet&        append( const uiStringSet& ss ) { return add(ss); }
    uiStringSet&        insert(IdxType,const uiString&);
    uiStringSet&        operator +=( const uiString& s ) { return add(s); }
    void                removeSingle(IdxType,bool keep_order=true);
    void                removeRange(IdxType,IdxType);

    uiString            cat(const char* sepstr="\n") const;
    uiString            createOptionString(bool use_and=true,int maxnritems=-1,
                                   bool separate_using_newlines=false) const;

    void                fill(mQtclass(QStringList)&) const;
    void                sort(const bool caseinsens,bool asc);
    void                sort(bool);
    void                useIndexes( const IdxType* idxs );
    IdxType*            getSortIndexes(bool caseinsens,bool asc) const;



protected:

    ObjectSet<uiString> strs_;

};


/*\brief allows returning status and accompanying user info.

  This class helps us make sure there is always user info on errors. Therefore,
  you will find a 'setIsOK' but not OK means setting a non-empty message.

*/

mExpClass(Basic) uiRetVal
{
public:

                        uiRetVal()              {}
                        uiRetVal(const uiString&);
                        uiRetVal(const uiStringSet&);
                        uiRetVal(const uiRetVal&);
    static uiRetVal     OK()                    { return ok_; }
    static uiRetVal     Empty()                 { return ok_; }
    uiRetVal&           operator =(const uiRetVal&);
    uiRetVal&           operator =(const uiString&);
    uiRetVal&           operator =(const uiStringSet&);
                        operator uiString() const;
                        operator uiStringSet() const;

    bool                isOK() const;
    inline bool         isEmpty() const         { return isOK(); }
    inline bool         isError() const         { return !isOK(); }
    bool                isMultiMessage() const;
    uiStringSet         messages() const;
    bool                isSingleWord(const uiString&) const;

    inline uiRetVal&    setOK()                 { *this = ok_; return *this; }
    inline uiRetVal&    setEmpty()              { return setOK(); }
    uiRetVal&           insert(const uiString&);
    uiRetVal&           set(const uiRetVal&);
    uiRetVal&           set(const uiString&);
    uiRetVal&           set(const uiStringSet&);
    uiRetVal&           add(const uiRetVal&);
    uiRetVal&           add(const uiString&);
    uiRetVal&           add(const uiStringSet&);

    BufferString        getText() const;

private:

    uiStringSet         msgs_;
    mutable Threads::Lock lock_;

    static const uiRetVal ok_;

};


mGlobal(Basic) bool isFinished(const uiRetVal&);
mGlobal(Basic) bool isCancelled(const uiRetVal&);
mGlobal(Basic) uiString toUiString(float,char format,int precision);
mGlobal(Basic) uiString toUiString(double,char format,int precision);


//User when string should be revisited later
#define mToUiStringTodo(i) ::toUiString(i)
#define mFromUiStringTodo(i) i.getFullString()


//Legacy Will be removed
mGlobal(Basic) mDeprecated inline uiString mkUiString(const char* var)
{ return toUiString(var); }

mGlobal(Basic) uiString od_static_tr( const char* function, const char* text,
        const char* disambiguation = 0, int pluralnr=-1 );
mGlobal(Basic) uiString getUiYesNoString(bool res);

template <class T> inline
uiString& uiString::arg( const T& var )
{
    return arg( toUiString(var) );
}