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
 RCS:           $Id$
________________________________________________________________________
 
-*/
 
#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;
}