enums.h

Go to the documentation of this file.

#ifndef enums_h
#define enums_h

/*+
________________________________________________________________________

 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        A.H.Bril
 Date:          4-2-1994
 Contents:      Enum <--> string conversion
 RCS:           $Id$
________________________________________________________________________

-*/

#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[],
                                        short nrs=0);
    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
    bool                isValidName(const char* key) const
                        { return isValidKey(key); }
    const char*         convert(int idx) const { return getKeyForIndex(idx); }
    int                 convert(const char* txt) const { return indexOf(txt); }
};

template <class ENUM>
mClass(Basic) EnumDefImpl : public EnumDef
{ mODTextTranslationClass(EnumDefImpl);
public:
                        EnumDefImpl(const char* nm,const char* s[],short nrs=0);
    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
    const char*         toString(ENUM theenum) const { return getKey(theenum); }

};


#define mDeclareEnumUtils(enm) \
public: \
    static const EnumDefImpl<enm>& enm##Def(); \
    static const char** enm##Names();\
    static bool parseEnum##enm(const char*,enm&);  /*legacy */ \
    static bool parseEnum(const char*,enm&); \
    static bool parseEnum(const IOPar&,const char*,enm&); \
    static enm parseEnum##enm(const char*);  \
    static const char* toString(enm); \
    static uiString toUiString(enm); \
    static const char* get##enm##String(enm); /*legacy */ \
protected: \
    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) const char** enm##Names();\
    extern const char* enm##Keys_[]; \
    mExtern(mod) bool parseEnum(const IOPar&,const char*,enm&); \
    mExtern(mod) bool parseEnum(const char*,enm&); \
    mExtern(mod) bool parseEnum##enm(const char*,enm&); /*legacy */  \
    mExtern(mod) enm parseEnum##enm(const char*); \
    mExtern(mod) const char* toString(enm); \
    mExtern(mod) uiString toUiString(enm); \
    mExtern(mod) const char* get##enm##String(enm); /*legacy */

#define _DefineEnumNames(prefix,enm,deflen,prettynm) \
const EnumDefImpl<prefix::enm>& prefix::enm##Def() \
{ \
    if ( !enm##Definition_ ) \
    { \
        EnumDefImpl<prefix::enm>* newdef = \
            new EnumDefImpl<prefix::enm>(prettynm,prefix::enm##Keys_,deflen); \
        if ( !enm##Definition_.setIfNull( newdef ) ) \
            delete newdef; \
    } \
 \
    return *enm##Definition_; \
} \
const char** prefix::enm##Names() \
{ return prefix::enm##Keys_; } \
bool prefix::parseEnum##enm(const char* txt, prefix::enm& res ) \
{ \
    const bool isok = prefix::parseEnum( 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 ); } \
const char* prefix::enm##Keys_[] =


#define DefineEnumNames(clss,enm,deflen,prettynm) \
ConstPtrMan<EnumDefImpl<clss::enm> > clss::enm##Definition_ = 0; \
_DefineEnumNames( clss, enm, deflen, prettynm )

#define DefineNameSpaceEnumNames(nmspc,enm,deflen,prettynm) \
static ConstPtrMan<EnumDefImpl<nmspc::enm> > enm##Definition_ = 0; \
_DefineEnumNames( nmspc, enm, deflen, prettynm )

//New Defs
#define mDefineEnumUtils(clss,enm,prettynm) \
DefineEnumNames(clss,enm,0,prettynm)

#define mDefineNameSpaceEnumUtils(nmspc,enm,prettynm) \
DefineNameSpaceEnumNames(nmspc,enm,0,prettynm)

//Legacy
#define DeclareEnumUtils(enm) mDeclareEnumUtils(enm)
#define DefineEnumUtils(clss,enm,prettynm) mDefineEnumUtils(clss,enm,prettynm)
#define DefineNameSpaceEnumUtils(nmspc,enm,prettynm) \
mDefineNameSpaceEnumUtils(nmspc,enm,prettynm)
#define DeclareNameSpaceEnumUtils(mod,enm) mDeclareNameSpaceEnumUtils(mod,enm)

#define mEnumTr(str) tr(str)


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

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

    if ( !iconfiles_.isEmpty() && 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();
}


#endif