unitofmeasure.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:          Feb 2004
________________________________________________________________________

-*/

#include "generalmod.h"
#include "propertyref.h"
#include "scaler.h"
#include "repos.h"
#include "survinfo.h"

class UnitOfMeasureRepository;

mGlobal(General) UnitOfMeasureRepository& UoMR();


mExpClass(General) UnitOfMeasure : public NamedObject
{ mODTextTranslationClass(UnitOfMeasure);
public:

                        UnitOfMeasure()
                            : proptype_(PropertyRef::Other)
                            , source_(Repos::Temp) {}
                        UnitOfMeasure( const char* n, const char* s, double f,
                                      PropertyRef::StdType t=PropertyRef::Other)
                            : NamedObject(n), symbol_(s)
                            , scaler_(0,f), source_(Repos::Temp)
                            , proptype_(t)      {}
                        UnitOfMeasure( const UnitOfMeasure& uom )
                            : NamedObject(uom.name())
                                                { *this = uom; }
    UnitOfMeasure&      operator =(const UnitOfMeasure&);

    const char*         symbol() const          { return symbol_.buf(); }
    PropertyRef::StdType propType() const       { return proptype_; }
    const LinScaler&    scaler() const          { return scaler_; }

    void                setSymbol( const char* s )
                                                { symbol_ = s; }
    void                setScaler( const LinScaler& s )
                                                { scaler_ = s; }
    void                setPropType( PropertyRef::StdType t )
                                                { proptype_ = t; }

    bool                isImperial() const;

    template <class T>
    T                   getSIValue( T inp ) const
                        { return ( T ) scaler_.scale(inp); }
    template <class T>
    T                   getUserValueFromSI( T inp ) const
                        { return ( T ) scaler_.unScale(inp); }
    template <class T>
    T                   internalValue(T inp) const;
    template <class T>
    T                   userValue(T inp) const;

    static const UnitOfMeasure* getGuessed(const char*);
    Repos::Source       source() const                  { return source_; }
    void                setSource( Repos::Source s )    { source_ = s; }

    static const UnitOfMeasure* surveyDefZUnit();
    static const UnitOfMeasure* surveyDefZStorageUnit();
    static const UnitOfMeasure* surveyDefTimeUnit();
    static const UnitOfMeasure* surveyDefDepthUnit();
    static const UnitOfMeasure* surveyDefDepthStorageUnit();
    static const UnitOfMeasure* surveyDefVelUnit();
    static uiString     surveyDefZUnitAnnot(bool symbol,bool withparens);
    static uiString     surveyDefTimeUnitAnnot(bool symbol,bool withparens);
    static uiString     surveyDefDepthUnitAnnot(bool symbol,bool withparens);
    static uiString     surveyDefVelUnitAnnot(bool symbol,bool withparens);
    static uiString     zUnitAnnot(bool time,bool symbol,bool withparens);

    static IOPar&       currentDefaults();
    static void         saveCurrentDefaults();

protected:

    BufferString        symbol_;
    LinScaler           scaler_;
    PropertyRef::StdType proptype_;
    Repos::Source       source_;

};


template <class T> void convValue(T& val,
                const UnitOfMeasure* oldunit, const UnitOfMeasure* newunit);

template <class T> inline T getConvertedValue(T val,
                const UnitOfMeasure* oldunit, const UnitOfMeasure* newunit);


mExpClass(General) UnitOfMeasureRepository
{
public:

    const UnitOfMeasure* get(PropertyRef::StdType,const char* nm) const;
    const UnitOfMeasure* get(const char* nm) const;
    static const char*  guessedStdName(const char*);

    const ObjectSet<const UnitOfMeasure>& all() const   { return entries; }
    void                getRelevant(PropertyRef::StdType,
                                    ObjectSet<const UnitOfMeasure>&) const;
    const UnitOfMeasure* getCurDefaultFor(const char* key) const;
    const UnitOfMeasure* getInternalFor(PropertyRef::StdType) const;
    const UnitOfMeasure* getDefault(const char* key,PropertyRef::StdType) const;

    bool                add(const UnitOfMeasure&);
    bool                write(Repos::Source) const;

private:

                        UnitOfMeasureRepository();

    ManagedObjectSet<const UnitOfMeasure> entries;

    void                addUnitsFromFile(const char*,Repos::Source);
    const UnitOfMeasure* findBest(const ObjectSet<const UnitOfMeasure>&,
                                  const char* nm) const;

    friend mGlobal(General) UnitOfMeasureRepository& UoMR();

};



template <class T> inline T UnitOfMeasure::internalValue( T inp ) const
{
    if ( SI().zInFeet() )
    {
        if ( symbol_.contains("ft") )
            return inp;
        else if ( symbol_.contains("m") )
        {
            const UnitOfMeasure* feetunit = UoMR().get( "ft" );
            return feetunit ? feetunit->getUserValueFromSI( inp ) : inp;
        }
    }

    return getSIValue( inp );
}


template <class T> inline T UnitOfMeasure::userValue( T inp ) const
{
    if ( SI().zInFeet() )
    {
        if ( symbol_.contains("ft") )
            return inp;
        else if ( symbol_.contains("m") )
        {
            const UnitOfMeasure* feetunit = UoMR().get( "ft" );
            return feetunit ? feetunit->getSIValue( inp ) : inp;
        }
    }

    return getUserValueFromSI( inp );
}


template <class T> void convValue( T& val,
                const UnitOfMeasure* oldunit, const UnitOfMeasure* newunit )
{ val = getConvertedValue( val, oldunit, newunit ); }


template <class T> inline T getConvertedValue( T val,
                const UnitOfMeasure* oldunit, const UnitOfMeasure* newunit )
{
    if ( oldunit == newunit || mIsUdf(val) )
        return val;

    if ( oldunit )
       val = oldunit->internalValue( val );
    if ( newunit )
        val = newunit->userValue( val );

    return val;
}