property.h

Go to the documentation of this file.

#pragma once
 
/*+
________________________________________________________________________
 
 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        Bert Bril
 Date:          Dec 2003
 RCS:           $Id$
________________________________________________________________________
 
 
-*/
 
#include "generalmod.h"
#include "propertyref.h"
#include "mnemonics.h"
#include "factory.h"
 
class PropertySet;
class Mnemonic;
 
 
mExpClass(General) Property
{ mODTextTranslationClass(Property);
public:
                        Property( const PropertyRef& pr );
    virtual Property*   clone() const                   = 0;
    static Property*    get(const IOPar&);
    virtual             ~Property()                     {}
 
    bool                isEqualTo(const Property&) const;
    virtual bool        isValue() const                 { return false; }
 
    inline const PropertyRef& ref() const               { return ref_; }
    inline const Mnemonic*    mnem() const              { return mn_; }
    const char*         name() const;
 
    virtual void        reset()                      { lastval_ = mUdf(float); }
    virtual bool        init(const PropertySet&) const;
    virtual uiString    errMsg() const                  {
                                            return uiString::emptyString();
                                                        }
 
    virtual bool        isUdf() const                   = 0;
    virtual bool        dependsOn(const Property&) const { return false; }
 
    virtual const char* type() const                    = 0;
    virtual const char* def() const                     = 0;
    virtual void        setDef(const char*)             = 0;
 
    void                fillPar(IOPar&) const;
    void                usePar(const IOPar&);
 
    mDefineFactory1ParamInClass(Property,const PropertyRef&,factory);
 
    mExpClass(General) EvalOpts
    {
    public:
 
        enum ValOpt     { New, Prev, Avg };
 
                        EvalOpts( ValOpt vo=New, float relpos=0.5 )
                            : valopt_(vo)
                            , relpos_(relpos)
                            , absz_(0.f)
                            , relz_(0.f)        {}
        ValOpt          valopt_;
        float           relpos_;
        float           absz_, relz_;
 
        inline bool     isAvg() const           { return valopt_==Avg; }
        inline bool     isPrev() const          { return valopt_==Prev;}
#       define mPropertyEvalAvg Property::EvalOpts(Property::EvalOpts::Avg)
#       define mPropertyEvalPrev Property::EvalOpts(Property::EvalOpts::Prev)
#       define mPropertyEvalNew(pos) \
                                Property::EvalOpts(Property::EvalOpts::New,pos)
 
    };
 
    float               value( EvalOpts eo=EvalOpts() ) const
                        {
                            return eo.isPrev() || !mIsUdf(lastval_) ? lastval_
                                 : (lastval_ = gtVal(eo));
                        }
 
protected:
 
    const PropertyRef&  ref_;
    const Mnemonic*     mn_;
    mutable float       lastval_;
 
    virtual float       gtVal(EvalOpts) const           = 0;
 
};
 
 
mExpClass(General) PropertySet
{
public:
                        PropertySet()           {}
                        PropertySet(const PropertyRefSelection&);
                        PropertySet( const PropertySet& ps )
                                                { *this = ps; }
    virtual             ~PropertySet()          { erase(); }
    PropertySet&        operator =(const PropertySet&);
 
    inline int          size() const            { return props_.size(); }
    inline bool         isEmpty() const         { return props_.isEmpty(); }
    int                 indexOf(const char*,bool matchaliases=false) const;
    inline bool         isPresent( const char* nm, bool ma=false ) const
                        { return indexOf(nm,ma) >= 0; }
    Property&           get( int idx )          { return *props_[idx]; }
    const Property&     get( int idx ) const    { return *props_[idx]; }
    inline const Property* find( const char* nm, bool ma=false ) const
                                                { return fnd(nm,ma); }
    inline Property*    find( const char* nm, bool ma=false )
                                                { return fnd(nm,ma); }
    int                 indexOf( const Property& p ) const
                                                { return props_.indexOf(&p); }
    int                 indexOf( const PropertyRef& pr ) const
                                                { return indexOf(pr.name()); }
    int                 indexOf(PropertyRef::StdType,int occ=0) const;
    void                getPropertiesOfRefType(PropertyRef::StdType,
                                               ObjectSet<Property>&) const;
 
    bool                add(Property*); 
    int                 set(Property*); 
    void                remove(int);
    void                replace(int,Property*);
    void                erase()                 { deepErase(props_); }
 
    bool                prepareUsage() const;   
    void                resetMemory();
    inline uiString     errMsg() const          { return errmsg_; }
 
 
protected:
 
    ObjectSet<Property> props_;
    mutable uiString    errmsg_;
 
    Property*           fnd(const char*,bool) const;
 
};
 
 
// For impl of Property subclasses. gtVal and the last three must be provided.
#define mDefPropertyFns(clss,typstr) \
protected: \
    virtual float       gtVal(EvalOpts) const; \
public: \
    static const char*  typeStr()               { return typstr; } \
    virtual const char* type() const            { return typeStr(); } \
    virtual const char* factoryKeyword() const  { return type(); } \
    static Property*    create( const PropertyRef& r ) { return new clss(r); } \
    virtual clss*       clone() const           { return new clss( *this ); }\
    static void         initClass() { factory().addCreator(create,typeStr());} \
    virtual const char* def() const; \
    virtual void        setDef(const char*); \
    virtual bool        isUdf() const
 
 
 
mExpClass(General) ValueProperty : public Property
{
public:
                        ValueProperty( const PropertyRef& pr )
                        : Property(pr)
                        , val_(mnem()?mnem()->disp_.typicalrange_.center()
                                     :mUdf(float))      {}
                        ValueProperty( const PropertyRef& pr, float v )
                        : Property(pr)
                        , val_(v)                       {}
    virtual bool        isValue() const         { return true; }
 
    float               val_;
 
    mDefPropertyFns(ValueProperty,"Value");
    void                setValue( float v )     { val_ = v; }
 
};
 
mExpClass(General) RangeProperty : public Property
{
public:
                        RangeProperty( const PropertyRef& pr )
                        : Property(pr)
                        , rg_(mnem()?mnem()->disp_.range_
                                    :Interval<float>::udf())    {}
                        RangeProperty( const PropertyRef& pr,
                                       Interval<float> rg )
                        : Property(pr)
                        , rg_(rg)                       {}
 
    Interval<float>     rg_;
 
    mDefPropertyFns(RangeProperty,"Range");
 
protected:
 
    float               gtAvgVal() const;
};