transl.h

#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: transl.h,v 1.37 2009-07-22 16:01:16 cvsbert Exp $
________________________________________________________________________

A translator is an object specific for a certain storage mechanism coupled with
specific details about e.g. vendor specific file transls. A Translator is member
of a group, e.g. the Grid Translator group. Translator groups have a
description of IOObj context.

*/

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

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

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


mClass TranslatorGroup
{ mRefCountImpl(TranslatorGroup);
public:

                                TranslatorGroup( const char* clssnm,
                                                 const char* usrnm );

    const BufferString&         clssName() const        { return clssname_; }
    const BufferString&         userName() const        { return usrname_; }
    virtual Translator*         make(const char*,bool usrnm=true) 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,bool usr=true);

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

protected:

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

    static ObjectSet<TranslatorGroup>& getGroups();

};


mClass Translator : public CallBacker
{
public:
                                Translator( const char* nm, const char* unm )
                                : typname_(nm)
                                , usrname_(unm)
                                , group_(0)             {}
    virtual                     ~Translator()           {}

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

    virtual Translator*         getNew() const          = 0;

    virtual bool                implExists(const IOObj*,int forread) const;
    virtual bool                implReadOnly(const IOObj*) const;
    virtual bool                implRemove(const IOObj*) const;
    virtual bool                implShouldRemove(const IOObj*) const;
    virtual bool                implRename(const IOObj*,const char*,
                                                const CallBack* cb=0) 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                isReadDefault() const           { return true; }

protected:

    BufferString                typname_;
    BufferString                usrname_;
    TranslatorGroup*            group_;

};


// Essential macros for implementing the concept

#define isTranslatorGroup(clss) \
public: \
    static TranslatorGroup& theInst();  \
    static int selector(const char*); \
    static const IOObjContext& ioContext(); \
    virtual const IOObjContext& ioCtxt() const { return ioContext(); } \
    virtual int objSelector( const char* s ) const { return selector(s); } \


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


#define defineTranslatorGroup(clss,usrnm) \
static RefMan<TranslatorGroup> clss##inst = \
    &TranslatorGroup::addGroup( new clss##TranslatorGroup(#clss,usrnm) );\
TranslatorGroup& clss##TranslatorGroup::theInst() \
{ return *clss##inst; }


#define defineTranslator(spec,clss,usrnm) \
static int spec##clss##listid_ \
    = TranslatorGroup::getGroup( #clss , false ).add( \
            new spec##clss##Translator( #spec, usrnm ) ); \
int spec##clss##Translator::listID()    { return spec##clss##listid_; }\
spec##clss##Translator* spec##clss##Translator::getInstance() \
{ return new spec##clss##Translator(#clss,usrnm); } \
const char* spec##clss##Translator::translKey() { return usrnm; }



#define mDefEmptyTranslatorGroupConstructor(clss) \
        clss##TranslatorGroup( const char* nm, const char* unm ) \
        : TranslatorGroup(nm,unm)               {}

#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(clss,fmt,defext) \
mClass clss##TranslatorGroup : public TranslatorGroup \
{                       isTranslatorGroup(clss) \
                        mDefEmptyTranslatorGroupConstructor(clss) \
    const char*         defExtension() const    { return defext; } \
}; \
 \
mClass clss##Translator : public Translator \
{ public: \
                        mDefEmptyTranslatorBaseConstructor(clss) \
}; \
 \
mClass fmt##clss##Translator : public clss##Translator \
{                       isTranslator(fmt,clss) \
                        mDefEmptyTranslatorConstructor(fmt,clss) \
};

#define mDefSimpleTranslatorInstances(clss,usrnm,fmt) \
defineTranslatorGroup(clss,usrnm) \
defineTranslator(fmt,clss,#fmt)

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

#define mDefSimpleTranslatorioContextWithExtra(clss,stdtyp,extra) \
const IOObjContext& clss##TranslatorGroup::ioContext() \
{ \
    static IOObjContext* ctxt = 0; \
    if ( !ctxt ) \
    { \
        ctxt = new IOObjContext( 0 ); \
        ctxt->stdseltype = IOObjContext::stdtyp; \
        extra; \
    } \
    ctxt->trgroup = &theInst(); \
    return *ctxt; \
}

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

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

#define mDefSimpleTranslatorsWithCtioExtra(clss,usrnm,fmt,stdtyp,extra) \
mDefSimpleTranslatorInstances(clss,usrnm,fmt) \
mDefSimpleTranslatorSelector(clss,usrnm) \
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 mSelHist(clss) \
        clss##TranslatorGroup::theInst().selHist()

#define mTranslCreate(clss,nm) \
        (clss##Translator*)clss##TranslatorGroup::theInst().make(nm)

#define mTranslGroupName(clss) \
        clss##TranslatorGroup::theInst().userName()

#define mTranslKey(clss) \
        clss##Translator::translKey()

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

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


#endif