uistring.h

Go to the documentation of this file.

#ifndef uistring_h
#define uistring_h

/*+
________________________________________________________________________

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

-*/

#include "gendefs.h"
#include "keystrs.h"
#include "threadlock.h"
#include "string2.h"
#include "typeset.h"

class uiStringData;

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        isSet() const                   { return !isEmpty(); }
    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;
    void                        getHexEncoded(BufferString&) const;
    bool                        setFromHexEncoded(const char*);
private:

#ifdef __debug__
    char*       debugstr_;      
#endif
    bool                        isCacheValid() const;
    const mQtclass(QString)&    getQStringInternal() const;

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

public:

                //Only for expert users
#ifdef mNoAutoUiString
    mDeprecated                 uiString(const char* inp);
    mDeprecated                 uiString(const OD::String&);
    mDeprecated uiString&       operator=(const char*);
    mDeprecated uiString&       operator=(const OD::String&);
#else
                                uiString(const char*);
                                uiString(const OD::String&);
    uiString&                   operator=(const char*);
    uiString&                   operator=(const OD::String&);
#endif

    bool        operator==(const uiString& b) const;
    bool        operator!=(const uiString& b) const { return !(*this==b); }
    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);
};


mExpClass(Basic) uiStringSet : public TypeSet<uiString>
{ mODTextTranslationClass(uiStringSet);
public:
                uiStringSet()                           {}
                uiStringSet( const uiString* );
                uiStringSet( const uiStringSet& sl )
                    : TypeSet<uiString>(sl)             {}
                uiStringSet( const uiString& s )        { add( s ); }

    uiString    createOptionString(bool use_and=true,int maxnritems=-1,
                                   char space = ' ') const;
    void        fill(mQtclass(QStringList)&) const;
    uiString    cat(const char* sepstr="\n") const;
};


/*\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_; }
    uiRetVal&           operator =(const uiRetVal&);
    uiRetVal&           operator =(const uiString&);
    uiRetVal&           operator =(const uiStringSet&);
                        operator uiString() const;

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

    uiRetVal&           setOK();
    uiRetVal&           set(const uiRetVal&);
    uiRetVal&           set(const uiString&);
    uiRetVal&           set(const uiStringSet&);
    uiRetVal&           add(const uiRetVal&);
    uiRetVal&           add(const uiString&);
    uiRetVal&           add(const uiStringSet&);
    void                resetError() { msgs_.setEmpty(); }

    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(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);


//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) );
}




#endif