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
 RCS:           $Id$
________________________________________________________________________
 
-*/
 
#include "string2.h"
#include "threadlock.h"
#include "bufstring.h"
#include "keystrs.h"
 
class BufferStringSet;
class uiStringData;
class uiStringSet;
class uiRetVal;
namespace Pos { class IdxPair; }
 
mFDQtclass( QString );
mFDQtclass( QStringList );
mFDQtclass( QTranslator );
 
#define mTextTranslationClass(clss,pkgkey) \
private: \
static inline uiString tr( const char* text, \
                           const char* disambiguation = nullptr, \
                           int pluralnr=-1 ) \
{ return uiString( text, #clss, pkgkey, disambiguation, pluralnr ); } \
static inline uiString legacyTr( const char* text, \
                                  const char* disambiguation = nullptr,  \
                                  int pluralnr=-1 ) \
{ return uiString( text, #clss, pkgkey, disambiguation, pluralnr ); }
 
#define mODTextTranslationClass(clss) \
mTextTranslationClass( clss, uiString::sODLocalizationApplication() )
 
 
mExpClass(Basic) uiString
{ mODTextTranslationClass(uiString)
public:
 
                uiString();
                uiString(const uiString&);      
                ~uiString();
    bool        operator==( const uiString& oth ) const
                                                { return isEqualTo(oth); }
    bool        operator!=( const uiString& oth ) const
                                                { return !isEqualTo(oth); }
    uiString&   operator=(const uiString&);     
 
#ifdef mNoTranslation
                uiString(const char* str)       { set( str ); }
    uiString&   operator =(const char* str)     { set( str ); return *this; }
#else
                uiString(const char*)           = delete; // try 'set()'
    uiString&   operator =(const char*)         = delete; // try 'set()'
#endif
 
    uiString&   set(const char*);
    uiString&   set( const uiString& s )        { return (*this = s); }
    bool        isEmpty() const;
    void        setEmpty();
    uiString&   toLower(bool yn=true);          
    uiString&   toUpper( bool yn=true )         { return toLower(!yn); }
    bool        operator!() const               { return isEmpty(); }
 
    bool        operator>(const uiString& b) const;
    bool        operator<(const uiString& b) const;
    int         size() const;
    bool        isPlainAscii() const;
 
    static const uiString&  empty()             { return emptystring_; }
    static uiString&        dummy()             { return dummystring_; }
 
 
    template <class T>
    inline uiString&    arg(const T&);
    inline uiString&    arg(float,int nrdecimals);
    inline uiString&    arg(double,int nrdecimals);
    uiString&           arg(const uiString&);
 
 
#   define              muiStringAppendDefArgs \
                            SeparType septyp=uiString::CloseLine, \
                            AppendType apptyp=uiString::OnNewLine
 
    enum SeparType      { NoSep, CloseLine, Space, Tab, Comma, MoreInfo,
                          SemiColon };
    enum AppendType     { OnSameLine, OnNewLine, AfterEmptyLine };
 
    uiString&           appendPhrase(const uiString&,muiStringAppendDefArgs);
    uiString&           appendPhrases(const uiStringSet&,
                                      muiStringAppendDefArgs);
    uiString&           appendPlainText(const char*,bool addspace=false,
                                        bool addquotes=false);
    uiString&           appendPlainText(const OD::String&,bool addspace=false,
                                        bool addquotes=false);
 
    uiString&           appendPhraseSameLine(const uiString&);
    uiString&           appendAfterList(const uiString&);
    uiString&           constructWordWith(const uiString&,bool addspace=false);
    uiString&           preFixWord(const uiString&);
    uiString&           postFixWord(const uiString&);
    uiString&           embed(const char* open,const char* close);
    uiString&           quote(bool single);
    uiString&           parenthesize();
    uiString&           optional();
    uiString&           embedFinalState();
    uiString&           withUnit(const char*); 
    uiString&           withUnit(const uiString&);
    uiString&           withSurvZUnit();
    uiString&           withSurvXYUnit();
    uiString&           withSurvDepthUnit();
    uiString&           withNumber(od_int64); // simple add number like "well 1"
    uiString&           addMoreInfo(const uiString&,bool newline=false);
    uiString&           addMoreInfo(const char*);
    template <class T>
    uiString&           addMoreInfo(const T&);
 
    inline uiString&    appendIncorrect(const uiString&,char sep=' ');
    inline uiString&    appendIncorrect(const char*,char sep=' ');
    inline uiString&    appendIncorrect(const OD::String&,char sep=' ');
 
    // TEMP-- comment out to fix a directory at a time
    inline uiString&    append( const uiString& s, bool nl=false )
                                { return appendIncorrect(s,nl?'\n':' '); }
    inline uiString&    append( const char* s, bool nl=false )
                                { return appendIncorrect(s,nl?'\n':' '); }
    inline uiString&    append( const OD::String& s, bool nl=false )
                                { return appendIncorrect(s,nl?'\n':' '); }
    inline uiString&    addSpace( int =1 )      { return append(" "); }
    inline uiString&    addTab( int =1 )        { return append("\t"); }
    inline uiString&    addNewLine( int =1 )    { return append("\n"); }
    // End TEMP
 
    static uiString     getOrderString(int);    
 
                        // UNtranslated:
    const char*         getOriginalString() const;
    BufferString        getString() const;
 
                        // Translated:
    void                fillUTF8String(BufferString&) const;
    const mQtclass(QString)&            fillQString(QString&) const;
    wchar_t*            createWCharString() const;
 
protected:
 
    bool                isEqualTo(const uiString& oth) const;
 
private:
 
    bool                        isCacheValid() const;
    const mQtclass(QString)&    getQStringInternal() const;
 
    friend class                uiStringData;
    mutable char*               debugstr_; //<! full string only when __debug__
    mutable uiStringData*       data_;
    mutable Threads::Lock       datalock_;
    static const uiString       emptystring_;
    static uiString             dummystring_;
 
    operator bool() const       = delete;
    operator int() const        = delete;
    operator float() const      = delete;
    operator double() const     = delete;
 
public:
 
    // The functions in this section are most likely not for you.
 
                uiString(const char* original,
                         const char* context,
                         const char* package,
                         const char* disambiguation,
                         int pluralnr);
 
    void        encodeStorageString(BufferString&) const;
    int         useEncodedStorageString(const char*);
    void        getHexEncoded(BufferString&) const;
    bool        setFromHexEncoded(const char*);
    void        makeIndependent();
    uiString&   setArg(int,const uiString&);
    void        setFrom(const mQtclass(QString)&);
    void        addAlternateVersion(const uiString&);
    void        addLegacyVersion( const uiString& uistr )
                { addAlternateVersion(uistr); }
    bool        translate(const mQtclass(QTranslator)&,
                          mQtclass(QString)&) const;
 
    static const char*  sODLocalizationApplication() { return "od"; }
 
 
    static const uiString& emptyString()        { return empty(); }
    bool        isSet() const                   { return !isEmpty(); }
 
    const OD::String&           getFullString(BufferString* =nullptr) const;
 
    mDeprecated                 ("Use fillQString")
    const mQtclass(QString)&    getQString() const;
 
};
 
 
typedef uiString uiWord;
typedef uiString uiPhrase;
 
 
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);
mGlobal(Basic) uiString toUiString(float,char format,int precision);
mGlobal(Basic) uiString toUiString(double,char format,int precision);
mGlobal(Basic) uiString toUiString(const Coord&); 
mGlobal(Basic) uiString toUiString(const BufferStringSet&);
 
mGlobal(Basic) const char* toString(const uiString&);
 
template <class T1,class T2>
uiString toUiString( const std::pair<T1,T2>& pair )
{
    return toUiString( "%1/%2" ).arg( pair.first ).arg( pair.second );
}
 
mGlobal(Basic) uiString toUiString(const mQtclass(QString)&);
 
 
inline uiString& uiString::appendPhraseSameLine( const uiString& str )
{ return appendPhrase( str, CloseLine, OnSameLine ); }
inline uiString& uiString::appendAfterList( const uiString& str )
{ return appendPhrase( str, NoSep, OnNewLine ); }
inline uiString& uiString::constructWordWith( const uiString& str, bool addspc )
{ return appendPhrase( str, addspc ? Space : NoSep, OnSameLine ); }
inline uiString& uiString::preFixWord( const uiString& str )
{ const uiString kp(*this); *this = str; return postFixWord(kp); }
inline uiString& uiString::postFixWord( const uiString& str )
{ return constructWordWith( str, true ); }
inline uiString& uiString::withUnit( const char* str )
{ return withUnit( toUiString(str) ); }
inline uiString& uiString::withNumber( od_int64 nr )
{ return postFixWord( toUiString(nr) ); }
inline uiString& uiString::addMoreInfo( const uiString& str, bool newline )
{ return appendPhrase( str, MoreInfo, newline? OnNewLine : OnSameLine ); }
inline uiString& uiString::addMoreInfo( const char* str )
{ return appendPhrase( toUiString(str), MoreInfo, OnSameLine ); }
template <class T>
inline uiString& uiString::addMoreInfo( const T& t )
{ return appendPhrase( toUiString(t), MoreInfo, OnSameLine ); }
 
 
// Use when string should be revisited later
#define mToUiStringTodo(i) ::toUiString(i)
#define mFromUiStringTodo(i) ::toString(i)
 
 
mGlobal(Basic) uiString od_static_tr(const char* function_name,const char* text,
                        const char* disambiguation=nullptr,int pluralnr=-1);
 
mGlobal(Basic) uiString getUiYesNoString(bool res);
 
template <class T> inline
uiString& uiString::arg( const T& var )
{
    return arg( toUiString(var) );
}
 
inline uiString& uiString::arg( float val, int nrdec )
{
    return arg( toUiString(val,nrdec) );
}
 
inline uiString& uiString::arg( double val, int nrdec )
{
    return arg( toUiString(val,nrdec) );
}
 
 
#define mGetQStr( qstr, uistring_var ) \
    QString qstr; (uistring_var).fillQString( qstr )
 
#define mDefIncorrectAppendPhrArgs \
    sep=='\n' ? NoSep : (sep=='\t' ? Tab : Space), \
    sep=='\n' ? OnNewLine : OnSameLine
 
inline uiString& uiString::appendIncorrect( const uiString& str, char sep )
{ return appendPhrase( str, mDefIncorrectAppendPhrArgs ); }
inline uiString& uiString::appendIncorrect( const char* str, char sep )
{ return appendPhrase( toUiString(str), mDefIncorrectAppendPhrArgs ); }
inline uiString& uiString::appendIncorrect( const OD::String& str, char sep )
{ return appendPhrase( toUiString(str), mDefIncorrectAppendPhrArgs ); }
 
 
#define mStoreduiStringPreamble         "^&"
 
 
// We need the sets so often that we include it here
#include "uistringset.h"