transl.h

Go to the documentation of this file.

#ifndef transl_h
#define transl_h

/*+
________________________________________________________________________

 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        A.H.Bril
 Date:          21-10-1995
 Contents:      Translators
RCS:            $Id$
________________________________________________________________________

A translator is an object specific for a certain storage mechanism coupled with
specific details about how to interpret/write a certain format.

A Translator is member of a group, e.g. the Wavelet Translator group.
Translator groups have a description of IOObj context needed to select an
object of that type.

*/

#include "generalmod.h"
#include "refcount.h"
#include "objectset.h"
#include "callback.h"
#include "bufstring.h"
#include "streamconn.h"
#include "ctxtioobj.h"
#include "uistring.h"
class Translator;

#define mDGBKey "dGB"
#define mdTectKey "dTect"

#define mObjSelUnrelated        0
#define mObjSelRelated          1
#define mObjSelMatch            2
mGlobal(General) int defaultSelector(const char*,const char*);


mExpClass(General) TranslatorGroup
{ mRefCountImpl(TranslatorGroup);
public:

                                TranslatorGroup( const char* clssnm );

    virtual FixedString         groupName() const = 0;
    virtual uiString            typeName(int num=1) const = 0;
    virtual Translator*         make(const char*,bool usrnm) const;
    const Translator*           getTemplate(const char*,bool usrnm) const;

    const ObjectSet<const Translator>& templates() const { return templs_; }

    virtual const IOObjContext& ioCtxt() const          = 0;
    virtual int                 objSelector(const char*) const = 0;

    bool                        hasConnType(const char*) const;
    virtual const char*         defExtension() const    { return 0; }
    IOPar&                      selHist();
    void                        clearSelHist();

    static const ObjectSet<TranslatorGroup>& groups()   { return getGroups(); }
    static TranslatorGroup&     getGroup(const char* nm);
    static bool                 hasGroup(const char* nm);
    static void                 clearSelHists();

                                // Called from macros
    bool                        add(Translator*);
    static TranslatorGroup&     addGroup(TranslatorGroup*);

    int                         defTranslIdx() const    { return deftridx_; }
    void                        setDefTranslIdx( int i ) { deftridx_ = i; }

    virtual const char*         getSurveyDefaultKey(const IOObj* = 0) const;

    virtual const char*         translationApplication() const;

protected:

    const OD::String&           clssName() const        { return clssname_; }

    BufferString                clssname_;
    ObjectSet<const Translator> templs_;
    int                         deftridx_;
    IOPar*                      selhist_;

    static ObjectSet<TranslatorGroup>& getGroups();

};


mExpClass(General) Translator : public CallBacker
{ mODTextTranslationClass(Translator)
public:
                                Translator(const char* nm,const char* usr_nm);
    virtual                     ~Translator()           {}

    const OD::String&           typeName() const        { return typname_; }
    const OD::String&           userName() const        { return usrname_; }
    const TranslatorGroup*      group() const           { return group_; }

    virtual Translator*         getNew() const          = 0;

    virtual bool                implExists(const IOObj*,bool forread) const;
    virtual bool                implReadOnly(const IOObj*) const;
    virtual bool                implRename(const IOObj*,const char*,
                                                const CallBack* cb=0) const;
    virtual bool                implManagesObjects(const IOObj*) const;
    virtual bool                implRemove(const IOObj*) const;
    virtual bool                implSetReadOnly(const IOObj*,bool) const;

    virtual const char*         connType() const;
    virtual void                usePar(const IOPar&)            {}
    virtual const char*         defExtension() const
                                { return group_ ? group_->defExtension() : 0; }

    void                        setGroup( TranslatorGroup* g )  { group_ = g; }

    virtual bool                isUserSelectable( bool forread=true ) const
                                { return true; }
    virtual IOObj*              createWriteIOObj(const IOObjContext&,
                                                 const MultiID&) const;
    virtual const char*         iconName() const        { return "od"; }
    const char*                 getDisplayName() const; 
    static const Translator*    getTemplateInstance(const char* displayname);

protected:

    BufferString                typname_;
    BufferString                usrname_;
    TranslatorGroup*            group_;

public:
    static uiString             sNoIoobjMsg();
    static uiString             sBadConnection();
    uiString                    sSelObjectIsWrongType();
};




// Essential macros for implementing the concept
#define mImplTranslatorInitClass( spec, clss, usrnm ) \
{ \
    spec##clss##Translator* tr = new spec##clss##Translator( #spec, usrnm ); \
    clss##TranslatorGroup::theInst().add( tr ); \
}

#define mImplTranslatorGroupTheInst( clss ) \
{ \
    mDefineStaticLocalObject(RefMan<TranslatorGroup>, inst, \
        = &TranslatorGroup::addGroup( new clss##TranslatorGroup ));\
    return *inst; \
}


#define isTranslatorGroupBody(clss) \
protected: \
    ~clss##TranslatorGroup() {} \
public: \
    static int selector(const char*); \
    static void initClass() { theInst(); } \
    static const IOObjContext& ioContext(); \
    static FixedString sGroupName(); \
    static uiString sTypeName(int num=1); \
    virtual FixedString groupName() const { return sGroupName(); } \
    virtual uiString typeName(int num=1) const \
    { return sTypeName(num); } \
    virtual const IOObjContext& ioCtxt() const { return ioContext(); } \
    virtual int objSelector( const char* s ) const { return selector(s); } \
    static TranslatorGroup& theInst()


#define isTranslatorGroup( clss ) \
mTextTranslationClass( clss##TranslatorGroup, \
               clss##TranslatorGroup::theInst().translationApplication() ) \
isTranslatorGroupBody(clss);

#define isTranslatorGroupWithInst( clss ) \
isTranslatorGroupBody( clss ) \
mImplTranslatorGroupTheInst( clss )


#define isTranslatorBody(spec,clss) \
public: \
    Translator* getNew() const \
    { \
        Translator* trans = new spec##clss##Translator(typeName().buf(), \
                                                    userName().buf()); \
        trans->setGroup( group_ ); return trans; \
    } \
    static spec##clss##Translator* getInstance(); \
    static const char* translKey(); \
    static void initClass()


#define isTranslator( spec, clss ) \
isTranslatorBody( spec, clss );

#define mIsTranslatorWithInitClass( spec, clss, usrnm ) \
isTranslatorBody(spec, clss) \
mImplTranslatorInitClass(spec, clss, usrnm )

#define defineTranslatorGroup(clss,groupname) \
FixedString clss##TranslatorGroup::sGroupName() \
{ return groupname; } \
TranslatorGroup& clss##TranslatorGroup::theInst() \
mImplTranslatorGroupTheInst( clss )

#define defineTranslator(spec,clss,usrnm) \
spec##clss##Translator* spec##clss##Translator::getInstance() \
{ return new spec##clss##Translator(#clss,usrnm); } \
const char* spec##clss##Translator::translKey() { return usrnm; } \
void spec##clss##Translator::initClass() \
mImplTranslatorInitClass( spec, clss, usrnm )


#define mDefEmptyTranslatorGroupConstructor(clss) \
        clss##TranslatorGroup() \
        : TranslatorGroup(#clss)                {}

#define mDefEmptyTranslatorBaseConstructor(clss) \
        clss##Translator( const char* nm, const char* unm ) \
        : Translator(nm,unm)                    {}

#define mDefEmptyTranslatorConstructor(spec,clss) \
        spec##clss##Translator( const char* nm, const char* unm ) \
        : clss##Translator(nm,unm)              {}

#define mDeclEmptyTranslatorBundle(mod,clss,fmt,defext) \
mExpClass(mod) clss##TranslatorGroup : public TranslatorGroup \
{                       isTranslatorGroup(clss) \
                        mDefEmptyTranslatorGroupConstructor(clss) \
    const char*         defExtension() const    { return defext; } \
}; \
 \
mExpClass(mod) clss##Translator : public Translator \
{ public: \
                        mDefEmptyTranslatorBaseConstructor(clss) \
}; \
 \
mExpClass(mod) fmt##clss##Translator : public clss##Translator \
{                       isTranslator(fmt,clss) \
                        mDefEmptyTranslatorConstructor(fmt,clss) \
};

#define mDefSimpleTranslatorInstances(clss,usrnm,fmt) \
defineTranslatorGroup(clss,usrnm) \
uiString clss##TranslatorGroup::sTypeName(int) { return toUiString(usrnm); } \
defineTranslator(fmt,clss,#fmt)

#define mDefSimpleTranslatorSelector(clss) \
int clss##TranslatorGroup::selector( const char* s ) \
{ return defaultSelector(clss##TranslatorGroup::sGroupName(),s); }

#define mDefSimpleTranslatorioContextWithExtra(clss,stdtyp,extra) \
const IOObjContext& clss##TranslatorGroup::ioContext() \
{ \
    mDefineStaticLocalObject( PtrMan<IOObjContext>, ctxt, = nullptr ); \
    if ( !ctxt ) \
    { \
        ctxt = new IOObjContext( nullptr ); \
        ctxt->stdseltype_ = IOObjContext::stdtyp; \
        extra; \
    } \
    ctxt->trgroup_ = &theInst(); \
    return *ctxt; \
}

#define mDefSimpleTranslatorioContext(clss,stdtyp) \
    mDefSimpleTranslatorioContextWithExtra(clss,stdtyp,)

#define mDefSimpleTranslators(clss,usrnm,fmt,stdtyp) \
mDefSimpleTranslatorSelector(clss)\
mDefSimpleTranslatorInstances(clss,usrnm,fmt) \
mDefSimpleTranslatorioContext(clss,stdtyp)

#define mDefSimpleTranslatorsWithCtioExtra(clss,usrnm,fmt,stdtyp,extra) \
mDefSimpleTranslatorInstances(clss,usrnm,fmt) \
mDefSimpleTranslatorSelector(clss) \
mDefSimpleTranslatorioContextWithExtra(clss,stdtyp,extra)

#define mDefSimpleTranslatorsWithSelKey(clss,usrnm,fmt,stdtyp,selky) \
    mDefSimpleTranslatorsWithCtioExtra(clss,usrnm,fmt,stdtyp, \
                ctxt->selkey_ = selky)


// Convenience macros when using Translator(Group)-related classes

#define mIOObjContext(trgrp) \
        trgrp##TranslatorGroup::ioContext()

#define mTranslGroupName(trgrp) \
        trgrp##TranslatorGroup::sGroupName()

#define mTranslTemplInstance(trgrp,tr) \
        (*trgrp##TranslatorGroup::theInst() \
                .getTemplate(tr##trgrp##Translator::translKey(),true))

#define mTranslCreate(trgrp,tr) \
        (trgrp##Translator*)trgrp##TranslatorGroup::theInst().make(tr)

#define mTranslKey(trgrp,tr) \
        tr##trgrp##Translator::translKey()

#define mMkCtxtIOObj(trgrp) \
        new CtxtIOObj(trgrp##TranslatorGroup::ioContext())

#define mSelHist(trgrp) \
        trgrp##TranslatorGroup::theInst().selHist()


#endif