transl.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:          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_;
 
    static BufferString         getAssociatedFileName(const IOObj&,
                                                const char* extension);
    static BufferString         getAssociatedFileName(const char* fnm,
                                                const char* extension);
    static bool                 renameAssociatedFile(const char* fnm,
                                    const char* ext,const char* newnm);
    static bool                 removeAssociatedFile(const char* fnm,
                                    const char* ext);
    static bool                 setPermAssociatedFile(const char* fnm,
                                    const char* ext,bool setwritable);
    static bool                 renameLargeFile(const char* fnm,
                                    const char* newfnm,const CallBack* cb=0);
 
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)
 
#define mDefEmptyTranslatorBundle(clss,fmt,stdtyp,fmtky,usrnm,uistrfn) \
    defineTranslatorGroup(clss,usrnm); \
    uiString clss##TranslatorGroup::sTypeName( int num ) \
        { return uistrfn(); } \
    defineTranslator(fmt,clss,fmtky); \
    mDefSimpleTranslatorioContext(clss,stdtyp); \
    mDefSimpleTranslatorSelector(clss)
 
// 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()