datapack.h

Go to the documentation of this file.

#ifndef datapack_h
#define datapack_h

/*+
________________________________________________________________________

 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        A.H.Bril
 Date:          Jan 2007
 RCS:           $Id$
________________________________________________________________________

-*/

#include "basicmod.h"
#include "namedobj.h"
#include "manobjectset.h"
#include "multiid.h"
#include "threadlock.h"
#include "od_iosfwd.h"

class DataPackMgr;


mExpClass(Basic) DataPack : public NamedObject
{
public:

    typedef int         ID;
    typedef MultiID     FullID;
    inline static ID    getID( const FullID& fid )      { return fid.ID(1); }

                        DataPack( const char* categry )
                            : NamedObject("<?>")
                            , category_(categry)
                            , nrusers_( 0 )
                            , manager_( 0 )
                            , id_(getNewID())   {}
                        DataPack( const DataPack& dp )
                            : NamedObject( dp.name().buf() )
                            , category_( dp.category_ )
                            , nrusers_( 0 )
                            , manager_( 0 )
                            , id_(getNewID())   {}
    virtual             ~DataPack()             {}

    ID                  id() const              { return id_; }
    FullID              fullID( int mgrid ) const { return FullID(mgrid,id()); }
    virtual const char* category() const        { return category_.buf(); }

    virtual float       nrKBytes() const        = 0;
    virtual void        dumpInfo(IOPar&) const;

    static const char*  sKeyCategory();
    static ID           cNoID()                 { return 0; }

    virtual bool        isOK() const            { return true; }

    Threads::Lock&      updateLock() const      { return updatelock_; }

    void                release();
    DataPack*           obtain();

protected:

    void                        setManager(const DataPackMgr*);
    const ID                    id_;
    const BufferString          category_;
    mutable int                 nrusers_;
    mutable Threads::Lock       nruserslock_;
    mutable Threads::Lock       updatelock_;
    const DataPackMgr*          manager_;

    static ID           getNewID();     
    static float        sKb2MbFac();    

    void                setCategory( const char* c )
                        { *const_cast<BufferString*>(&category_) = c; }

    friend class        DataPackMgr;
};


mExpClass(Basic) BufferDataPack : public DataPack
{
public:

                        BufferDataPack( char* b=0, od_int64 s=0,
                                        const char* catgry="Buffer" )
                            : DataPack(catgry)
                            , buf_(b)
                            , sz_(s)            {}
                        ~BufferDataPack()       { delete [] buf_; }

    char*               buf()                   { return buf_; }
    char const*         buf() const             { return buf_; }
    od_int64            size() const            { return sz_; }
    void                setBuf( char* b, od_int64 s )
                        { delete [] buf_; sz_ = s; buf_ = b; }

    virtual float       nrKBytes() const        { return sz_*sKb2MbFac(); }

protected:

    char*               buf_;
    od_int64            sz_;

};


mExpClass(Basic) DataPackMgr : public CallBacker
{
public:
                        // You can, but normally should not, construct
                        // a manager. In general, leave it to DPM() - see below.

    typedef int         ID;             
    inline static ID    getID( const DataPack::FullID& fid )
                                                { return fid.ID(0); }

    bool                haveID(DataPack::ID) const;
    inline bool         haveID( const DataPack::FullID& fid ) const
                        { return id() == fid.ID(0) && haveID( fid.ID(1) ); }

    void                add(DataPack*);
    DataPack*           addAndObtain(DataPack*);
    inline DataPack*    obtain( DataPack::ID dpid )
                        { return doObtain(dpid,false); }
    inline const DataPack* obtain( DataPack::ID dpid ) const
                        { return doObtain(dpid,false); }
    inline DataPack*    observe( DataPack::ID dpid )
                        { return doObtain(dpid,true); }
    inline const DataPack* observe( DataPack::ID dpid ) const
                        { return doObtain(dpid,true); }

    void                release(DataPack::ID);
    void                release( const DataPack* dp )
                        { if ( dp ) release( dp->id() ); }
    void                releaseAll(bool donotify);

    Notifier<DataPackMgr> newPack;              
    Notifier<DataPackMgr> packToBeRemoved;      

                        // Standard mgr IDs take the low integer numbers
    static ID           BufID();        
    static ID           PointID();      
    static ID           SeisID();       
    static ID           FlatID();       
    static ID           SurfID();       

                        // Convenience to get info without any obtain()
    const char*         nameOf(DataPack::ID) const;
    static const char*  nameOf(const DataPack::FullID&);
    const char*         categoryOf(DataPack::ID) const;
    static const char*  categoryOf(const DataPack::FullID&);
    virtual float       nrKBytesOf(DataPack::ID) const;
    virtual void        dumpInfoFor(DataPack::ID,IOPar&) const;

    ID                  id() const              { return id_; }
    void                dumpInfo(od_ostream&) const;
    float               nrKBytes() const;

    const ObjectSet<const DataPack>&    packs() const   { return packs_; }

protected:

    ID                          id_;
    ObjectSet<const DataPack>   packs_;

    DataPack*                   doObtain(ID,bool) const;
    int                         indexOf(ID) const;
    mutable Threads::Lock       rwlock_;

    static Threads::Lock        mgrlistlock_;
    static ManagedObjectSet<DataPackMgr> mgrs_;

public:

                        DataPackMgr(ID);
                        ~DataPackMgr();

    static DataPackMgr& DPM(ID);
    static DataPackMgr* gtDPM(ID,bool);
    static void         dumpDPMs(od_ostream&);

};

template <class T>
mClass(Basic) ConstDataPackRef
{
public:
                                ConstDataPackRef(const DataPack* p);
                                ConstDataPackRef(const ConstDataPackRef<T>&);
    virtual                     ~ConstDataPackRef()             { releaseNow();}

    ConstDataPackRef<T>&        operator=(const ConstDataPackRef<T>&);

    void                        releaseNow();

                                operator bool() const           { return ptr_; }
    const T*                    operator->() const              { return ptr_; }
    const T&                    operator*() const               { return *ptr_;}
    const T*                    ptr() const                     { return ptr_; }
    const DataPack*             dataPack() const                { return dp_; }

protected:

    DataPack*                   dp_;
    T*                          ptr_;
};

template <class T>
mClass(Basic) DataPackRef : public ConstDataPackRef<T>
{
public:
                        DataPackRef(DataPack* p);
                        DataPackRef(const DataPackRef<T>&);

    DataPackRef<T>&     operator=(const DataPackRef<T>&);

    void                releaseNow();

    T*                  operator->()                    { return this->ptr_; }
    T&                  operator*()                     { return *this->ptr_;}
    T*                  ptr()                           { return this->ptr_; }
    DataPack*           dataPack()                      { return this->dp_; }
};


mGlobal(Basic) DataPackMgr& DPM(DataPackMgr::ID);
mGlobal(Basic) DataPackMgr& DPM(const DataPack::FullID&);

#define mObtainDataPack( var, type, mgrid, newid ) \
{ \
    if ( var ) \
    { \
        DPM( mgrid ).release( var->id() ); \
        var = 0; \
    } \
 \
    DataPack* __dp = DPM( mgrid ).obtain( newid ); \
    mDynamicCastGet( type, __dummy, __dp ); \
    if ( !__dummy && __dp ) \
         DPM( mgrid ).release( __dp->id() ); \
    else \
        var = __dummy; \
}


#define mObtainDataPackToLocalVar( var, type, mgrid, newid ) \
type var = 0; \
mObtainDataPack( var, type, mgrid, newid ); \

//Implementations
template <class T> inline
ConstDataPackRef<T>::ConstDataPackRef(const DataPack* p)
    : dp_(const_cast<DataPack*>(p) )
    , ptr_( 0 )
{
    mDynamicCast(T*, ptr_, dp_ );
}


template <class T> inline
ConstDataPackRef<T>::ConstDataPackRef(const ConstDataPackRef<T>& dpr)
    : ptr_( dpr.ptr_ )
    , dp_( dpr.dp_ )
{
    if ( dp_ ) dp_->obtain();
}


template <class T> inline
ConstDataPackRef<T>&
ConstDataPackRef<T>::operator=(const ConstDataPackRef<T>& dpr)
{
    releaseNow();
    ptr_ = dpr.ptr_;
    dp_ = dpr.dp_;

    if ( dp_ ) dp_->obtain();
    return *this;
}


template <class T> inline
void ConstDataPackRef<T>::releaseNow()
{
    ptr_ = 0;
    if ( dp_ )
    {
        dp_->release();
        dp_ = 0;
    }
}


template <class T> inline
DataPackRef<T>::DataPackRef(DataPack* p)
    : ConstDataPackRef<T>( p )
{ }


template <class T> inline
DataPackRef<T>::DataPackRef(const DataPackRef<T>& dpr)
    : ConstDataPackRef<T>( dpr )
{ }


template <class T> inline
DataPackRef<T>& DataPackRef<T>::operator=(const DataPackRef<T>& dpr)
{
    ConstDataPackRef<T>::operator=(dpr);
    return *this;
}


#endif