enums.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:          4-2-1994
 Contents:      Enum <--> string conversion
________________________________________________________________________

-*/

#include "basicmod.h"
#include "iopar.h"
#include "uistring.h"
#include "bufstringset.h"

#include "namedobj.h"

mExpClass(Basic) EnumDef : public NamedObject
{
public:
                                EnumDef();
                                EnumDef(const char* nm,const char* s[]);
    bool                        isValidKey(const char*) const;
    int                         indexOf(const char* s) const;
    int                         indexOf(int enumval) const;
    int                         getEnumValForIndex(int) const;
    const char*                 getKeyForIndex(int i) const;
    uiString                    getUiStringForIndex(int i) const;
    void                        setUiStringForIndex(int,const uiString&);
    const BufferStringSet&      keys() const { return keys_; }
    const uiStringSet&          strings() const { return uistrings_; }

    const char*                 getIconFileForIndex(int idx) const;
    void                        setIconFileForIndex(int idx,const char*);

    int                         size() const;

    //Expert use only!
    void                        remove(const char* key);
    void                        add(const char* key, const uiString&,
                                    int enumval, const char* iconfile);

protected:
    void                fillUiStrings();
    uiStringSet         uistrings_;
    BufferStringSet     keys_;
    TypeSet<int>        enums_;
    BufferStringSet     iconfiles_;
public:
    //Legacy
    mDeprecated bool            isValidName(const char* key) const;
    mDeprecated const char*     convert(int idx) const;
    mDeprecated int             convert(const char* txt) const;
};

template <class ENUM>
mClass(Basic) EnumDefImpl : public EnumDef
{ mODTextTranslationClass(EnumDefImpl);
public:
                        EnumDefImpl(const char* nm,const char* s[]);
    bool                parse(const char* txt,ENUM& res) const;
    bool                parse(const IOPar& par,const char* key,ENUM& res) const;
    ENUM                parse(const char* txt) const;
    ENUM                getEnumForIndex(int idx) const;
    const char*         getKey(ENUM theenum) const;
    uiString            toUiString(ENUM theenum) const;
private:
    void                init();
public:
    //Legacy
    mDeprecated const char*
                        toString(ENUM theenum) const { return getKey(theenum); }
};


#define mDeclareEnumUtils(enm) \
public: \
    static const EnumDefImpl<enm>& enm##Def(); \
    static mDeprecated const char** enm##Names();\
    static mDeprecated bool parseEnum##enm(const char*,enm&);  /*legacy */ \
    static mDeprecated bool parseEnum(const char*,enm&); \
    static mDeprecated bool parseEnum(const IOPar&,const char*,enm&); \
    static mDeprecated enm parseEnum##enm(const char*);  \
    static const char* toString(enm); \
    static uiString toUiString(enm); \
    static mDeprecated const char* get##enm##String(enm); /*legacy */ \
private: \
    static EnumDefImpl<enm>* enm##CreateDef(); \
    static const char* enm##Keys_[]; \
    static ConstPtrMan<EnumDefImpl<enm> > enm##Definition_; \
public:

#define mDeclareNameSpaceEnumUtils(mod,enm) \
    mExtern(mod) const EnumDefImpl<enm>& enm##Def(); \
    mExtern(mod) mDeprecated const char** enm##Names();\
    mExtern(mod) mDeprecated bool parseEnum(const IOPar&,const char*,enm&); \
    mExtern(mod) mDeprecated bool parseEnum(const char*,enm&); \
    mExtern(mod) mDeprecated bool parseEnum##enm(const char*,enm&); /*legacy */\
    mExtern(mod) mDeprecated enm parseEnum##enm(const char*); \
    mExtern(mod) const char* toString(enm); \
    mExtern(mod) uiString toUiString(enm); \
    mExtern(mod) mDeprecated const char* get##enm##String(enm); /*legacy */

//Legacy
#define DeclareEnumUtils(enm) mDeclareEnumUtils(enm)
#define DeclareNameSpaceEnumUtils(mod,enm) \
mDeclareNameSpaceEnumUtils(mod,enm)

#define _mDefineEnumUtils(prefix,enm,createfunc,prettynm) \
const EnumDefImpl<prefix::enm>& prefix::enm##Def() \
{ return *enm##Definition_.createIfNull( createfunc ); } \
bool prefix::parseEnum##enm(const char* txt, prefix::enm& res ) \
{ \
    const bool isok = prefix::enm##Def().parse( txt, res ); \
    if ( !isok ) res = (prefix::enm) 0; \
    return isok; \
} \
bool prefix::parseEnum(const char* txt, prefix::enm& res ) \
{ return prefix::enm##Def().parse( txt, res ); } \
bool prefix::parseEnum( const IOPar& par, const char* key, prefix::enm& res ) \
{ return prefix::enm##Def().parse( par, key, res ); } \
prefix::enm prefix::parseEnum##enm(const char* txt) \
{ return prefix::enm##Def().parse( txt ); } \
const char* prefix::get##enm##String( prefix::enm theenum ) \
{ return prefix::toString( theenum ); } \
const char* prefix::toString( prefix::enm theenum ) \
{ return enm##Def().getKey( theenum ); } \
uiString prefix::toUiString( prefix::enm theenum ) \
{ return enm##Def().toUiString( theenum ); } \


#define mDefineEnumUtils(clss,enm,prettynm) \
EnumDefImpl<clss::enm>* clss::enm##CreateDef() \
{ return new EnumDefImpl<clss::enm>( prettynm, clss::enm##Keys_ ); } \
const char** clss::enm##Names() { return clss::enm##Keys_ ; } \
ConstPtrMan<EnumDefImpl<clss::enm> > clss::enm##Definition_ = 0; \
_mDefineEnumUtils( clss, enm, clss::enm##CreateDef, prettynm ); \
const char* clss::enm##Keys_[] =

#define mDefineNameSpaceEnumUtils(nmspc,enm,prettynm) \
extern const char* nmspc##enm##Keys_[]; \
static EnumDefImpl<nmspc::enm>* nmspc##enm##CreateDef() \
{ return new EnumDefImpl<nmspc::enm>( prettynm, nmspc##enm##Keys_ ); } \
const char** nmspc::enm##Names() { return nmspc##enm##Keys_; } \
static ConstPtrMan<EnumDefImpl<nmspc::enm> > enm##Definition_ = 0; \
_mDefineEnumUtils( nmspc, enm, nmspc##enm##CreateDef, prettynm );\
const char* nmspc##enm##Keys_[] =

//Legacy
#define DefineEnumNames(clss,enm,deflen,prettynm) \
mDefineEnumUtils(clss,enm,prettynm)
#define DefineNameSpaceEnumNames(nmspc,enm,deflen,prettynm) \
mDefineNameSpaceEnumUtils(nmspc,enm,prettynm)
#define mEnumTr(str) tr(str)

template <class ENUM> inline
EnumDefImpl<ENUM>::EnumDefImpl( const char* nm, const char* nms[] )
    : EnumDef( nm, nms )
{
    init();
    if ( uistrings_.size()!=size() )
    {
        pErrMsg( "Wrong number of uistrings" );
    }

    for ( int idx=uistrings_.size(); idx<size(); idx++ )
        uistrings_ += ::toUiString( keys_.get(idx) );

    if ( iconfiles_.size() && iconfiles_.size()!=size() )
    {
        pErrMsg( "Wrong number of iconfiles" );
    }
}

template <class ENUM> inline
bool EnumDefImpl<ENUM>::parse(const char* txt, ENUM& res ) const
{
    const int idx = isValidKey( txt )
        ?  indexOf( txt )
        : -1;
    if ( idx<0 )
        return false;

    res = (ENUM) enums_[idx];
    return true;
}


template <class ENUM> inline
bool EnumDefImpl<ENUM>::parse( const IOPar& par, const char* key,
                               ENUM& res ) const
{
    const char* val = par.find( key );
    return parse( val, res );
}


template <class ENUM> inline
ENUM EnumDefImpl<ENUM>::getEnumForIndex( int idx ) const
{
    return (ENUM) enums_[idx];
}


template <class ENUM> inline
ENUM EnumDefImpl<ENUM>::parse(const char* txt) const
{
    return getEnumForIndex( indexOf( txt ) );
}


template <class ENUM> inline
const char* EnumDefImpl<ENUM>::getKey( ENUM theenum ) const
{
    if ( !size() )
        return 0;

    const int idx = enums_.indexOf( (int) theenum );
    return keys_.get(idx>=0?idx:0).buf();
}


template <class ENUM> inline
uiString EnumDefImpl<ENUM>::toUiString( ENUM theenum ) const
{
    const int idx = enums_.indexOf( (int) theenum );
    return getUiStringForIndex( idx );
}


template <class ENUM> inline
void EnumDefImpl<ENUM>::init()
{
     fillUiStrings();
}