Generated/html/tabledef_8h_source.html

#pragma once


/*+

________________________________________________________________________


 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt

 Author:        A.H.Bril

 Date:          Oct 2006

 RCS:           $Id$

________________________________________________________________________


-*/


#include "generalmod.h"

#include "coordsystem.h"

#include "sets.h"

#include "rowcol.h"

#include "namedobj.h"

#include "datainpspec.h"

#include "propertyref.h"


class UnitOfMeasure;


namespace Table

{


    enum ReqSpec        { Optional=0, Required=1, Hidden=2 };


mExpClass(General) TargetInfo : public NamedObject

{

public:


    struct Form : NamedObject

    {

                        Form( const char* nm, DataInpSpec* spec )

                            : NamedObject(nm)

                                { add( spec ); }

                        Form( const char* nm, const DataInpSpec& spec )

                            : NamedObject(nm)

                                { add( spec.clone() ); }


                        ~Form() { deepErase(specs_); }


        Form&           add( const DataInpSpec& spec )

                            { specs_ += spec.clone(); return *this; }

        Form&           add( DataInpSpec* spec )

                            { specs_ += spec ? spec : new StringInpSpec;

                              return *this; }


        Form*           duplicate( const char* nm ) const

                        {

                            Form* ret = new Form( nm, *specs_[0] );

                            for ( int idx=1; idx<specs_.size(); idx++ )

                                ret->specs_ += specs_[idx]->clone();

                            return ret;

                        }


        ObjectSet<DataInpSpec>  specs_;

    };


                        TargetInfo( const char* nm, ReqSpec rs=Optional )

                            : NamedObject(nm), req_(rs)

                            , proptype_(PropertyRef::Other)

                                { add( nm ); }

                        TargetInfo( const char* nm, DataInpSpec* spec,

                                  ReqSpec rs=Optional,

                                  PropertyRef::StdType p=PropertyRef::Other )

                            : NamedObject(nm), req_(rs), proptype_(p)

                                { add( nm, spec ); }

                        TargetInfo( const char* nm, const DataInpSpec& spec,

                                  ReqSpec rs=Optional,

                                  PropertyRef::StdType p=PropertyRef::Other )

                            : NamedObject(nm), req_(rs), proptype_(p)

                                { add( nm, spec ); }


                        ~TargetInfo()           { deepErase( forms_ ); }


    TargetInfo&         add( const char* nm, DataInpSpec* spec=0 )

                            { forms_ += new Form( nm, spec ); return *this; }

    TargetInfo&         add( const char* nm, const DataInpSpec& spec )

                            { forms_ += new Form( nm, spec ); return *this; }

    TargetInfo&         add( Form* frm )

                            { forms_ += frm; return *this; }


    bool                isOptional() const      { return req_ != Required; }

    bool                isHidden() const        { return req_ == Hidden; }

    PropertyRef::StdType propertyType() const   { return proptype_; }

    void                setPropertyType( PropertyRef::StdType p )

                            { proptype_ = p; }

    int                 nrForms() const         { return forms_.size(); }

    Form&               form( int idx )         { return *forms_[idx]; }

    const Form&         form( int idx ) const   { return *forms_[idx]; }

    int                 formNr( const char* formnm ) const

                        {

                            for ( int idx=0; idx<forms_.size(); idx++ )

                                if ( forms_[idx]->name() == formnm )

                                    return idx;

                            return -1;

                        }


    struct Selection

    {

        struct Elem

        {

                                Elem()

                                    : pos_(0,-1)                {}

                                Elem( const RowCol& rc, const char* kw=0 )

                                    : pos_(rc), keyword_(kw)    {}

                                Elem( const char* s )

                                    : pos_(0,-1), val_(s)       {}


            bool                isInFile() const

                                    { return pos_.col() >= 0; }

            bool                isKeyworded() const

                                    { return isInFile() && !keyword_.isEmpty();}

            bool                isSpecified() const

                                    { return !val_.isEmpty(); }

            bool                isEmpty() const

                                    { return !isInFile() && !isSpecified();}

            bool                operator ==( const Elem& v ) const

                                    { return pos_ == v.pos_ && val_ == v.val_

                                          && keyword_ == v.keyword_; }


            RowCol              pos_;

            BufferString        keyword_;

            BufferString        val_;

        };


        int                     form_;

        TypeSet<Elem>           elems_;

        const UnitOfMeasure*    unit_;

        ConstRefMan<Coords::CoordSystem>        coordsys_;


                        Selection()

                                : form_(0), unit_(0), coordsys_(0)      {}


        bool            havePos( int ielem ) const

                            { return ielem < elems_.size()

                                  && elems_[ielem].isInFile(); }

        bool            isKeyworded( int ielem ) const

                            { return ielem < elems_.size()

                                  && elems_[ielem].isKeyworded(); }

        bool            isInFile( int ielem=0 ) const

                            { return ielem < elems_.size()

                                  && elems_[ielem].isInFile(); }

        const char*     getVal( int ielem ) const

                            { return ielem >= elems_.size() ? 0

                                   : elems_[ielem].val_.buf(); }

        bool            isFilled() const

                        { return elems_.size() > 0 && !elems_[0].isEmpty(); }

    };


    mutable Selection   selection_;


    void                fillPar(IOPar&) const;

    void                usePar(const IOPar&);


    static TargetInfo*  mkHorPosition(bool isreq,bool wic=true,bool wll=false,

                                      bool wcrs=true);

    static TargetInfo*  mkZPosition( bool isreq, bool withunits=true )

                                { return mkZPos(isreq,withunits); }

    static TargetInfo*  mkDepthPosition( bool isreq, bool withunits=true )

                                { return mkZPos(isreq,withunits,1); }

    static TargetInfo*  mkTimePosition( bool isreq, bool withunits=true )

                                { return mkZPos(isreq,withunits,-1); }

    bool                needsConversion() const;

    Coord               convert(const Coord&) const;


protected:


    ReqSpec             req_;

    PropertyRef::StdType proptype_;

    ObjectSet<Form>     forms_;


    static TargetInfo*  mkZPos(bool,bool wu=false,int zopt=0);


};


mExpClass(General) FormatDesc : public NamedObject

{

public:

                        FormatDesc( const char* nm )

                            : NamedObject(nm)

                            , nrhdrlines_(0)

                            , eohtokencol_(-1)          {}

                        ~FormatDesc()

                        { deepErase( headerinfos_ ); deepErase( bodyinfos_ ); }


    ObjectSet<TargetInfo> headerinfos_;

    ObjectSet<TargetInfo> bodyinfos_;


    int                 nrhdrlines_;

    BufferString        eohtoken_;

    int                 eohtokencol_;

    BufferString        eobtoken_;


    bool                needEOHToken() const

                        { return nrhdrlines_ < 0 && !eohtoken_.isEmpty(); }

    int                 nrHdrLines() const

                        { return needEOHToken() ? mUdf(int)

                               : nrhdrlines_ > 0 ? nrhdrlines_ : 0; }

    bool                haveEOBToken() const

                        { return !eobtoken_.isEmpty(); }


    bool                isGood() const;

    bool                bodyUsesCol(int) const;


    void                fillPar(IOPar&) const;

    void                usePar(const IOPar&);


    void                clear()

                        {

                            nrhdrlines_ = eohtokencol_ = 0;

                            eohtoken_.setEmpty(); eobtoken_.setEmpty();

                        }

};


}; // namespace Table