mi32/uom.h

Go to the documentation of this file.

#ifndef  INC_MI32_UOM_H
#define  INC_MI32_UOM_H

#ifndef  INC_MI32_MILIST_H
   #include <mi32/milist.h>
#endif

#ifdef GEOMDLL
   #define LIBEXPORT MI_DLLEXPORT
   #define CLASSLIBEXPORT MI_DLLCLASSEXPORT
#else
   #define LIBEXPORT MI_DLLIMPORT
   #define CLASSLIBEXPORT MI_DLLCLASSIMPORT
#endif

#ifndef GENERATING_DOXYGEN_OUTPUT
class MISTRING;
class IDENTIFIER;
class IDENTIFIERLIST;
#endif // GENERATING_DOXYGEN_OUTPUT

namespace UOM {

#ifndef GENERATING_DOXYGEN_OUTPUT
class SYSTEM;
class MEASURE;
class UNIT;
class CONVERTER;
class MEASURE_PRIV;
class UNIT_PRIV;
class CONVERTER_PRIV;
typedef MILIST<UNIT> UNITLIST;
#endif // GENERATING_DOXYGEN_OUTPUT

//-------------------------------------------------------------------------------------------------------------------
class CLASSLIBEXPORT MEASURE {
   public:

      enum TYPE {
         TYPE_Area =                   1,    
         TYPE_Length =                 2,    
         TYPE_Distance =               TYPE_Length,
         TYPE_PlaneAngle =             3,    
         TYPE_Time =                   4,    
         TYPE_Temperature =            5,    
         TYPE_Volume =                 6,    
         TYPE_Mass =                   7,    
         TYPE_Current =                8,    
         TYPE_Amount =                 9,    
         TYPE_LuminousIntensity =      10,   
         TYPE_SolidAngle =             11,   
         TYPE_Velocity =               12,   
         TYPE_Acceleration =           13,   
         TYPE_VolumetricFlowRate =     14,   
         TYPE_MassFlowRate =           15,   
         TYPE_WaveNumber =             16,   
         TYPE_Density =                17,   
         TYPE_SpecificVolume =         18,   
         TYPE_CurrentDensity =         19,   
         TYPE_MagneticFieldStrength =  20,   
         TYPE_Concentration =          21,   
         TYPE_Luminance =              22,   
         TYPE_Frequency =              23,   
         TYPE_Force =                  24,   
         TYPE_Pressure =               25,   
         TYPE_Energy =                 26,   
         TYPE_Power =                  27,   
         TYPE_ElectricCharge =         28,   
         TYPE_ElectricPotential =      29,   
         TYPE_Capacitance =            30,   
         TYPE_ElectricResistance =     31,   
         TYPE_ElectricConductance =    31,   
         TYPE_MagneticFlux =           33,   
         TYPE_MagneticFluxDensity =    34,   
         TYPE_Inductance =             35,   
         TYPE_LuminousFlux =           36,   
         TYPE_RadionuclideActivity =   37,   
         TYPE_AbsorbedDose =           38,   
         TYPE_DoseEquivalent =         39,   
         TYPE_DynamicViscosity =       40,   
         TYPE_MomentOfForce =          41,   
         TYPE_SurfaceTension =         42,   
         TYPE_Irradiance =             43,   
         TYPE_Entropy =                44,   
         TYPE_SpecificHeatCapacity =   45,   
         TYPE_SpecificEnergy =         46,   
         TYPE_ThermalConductivity =    47,   
         TYPE_EnergyDensity =          48,   
         TYPE_ElectricFieldStrength =  49,   
         TYPE_ElectricChargeDensity =  50,   
         TYPE_ElectricFluxDensity =    51,   
         TYPE_Permitivity =            52,   
         TYPE_Permeability =           53,   
         TYPE_MolarEnergy =            54,   
         TYPE_MolarEntropy =           55,   
         TYPE_Exposure =               56,   
         TYPE_AbsorbedDoseRate =       57,   
         TYPE_AngularVelocity =        58,   
         TYPE_AngularAcceleration =    59,   
         TYPE_RadiantIntensity =       60,   
         TYPE_Radiance =               61,   
         TYPE_Scale =                  62,   
         TYPE_Image =                  63,   
         TYPE_Duration =               64,   
         TYPE_Age =                    65,   

         TYPE_LASTNONDATE =            65,   

         TYPE_Date =                   99,   
         TYPE_None =                   255
         };

      MEASURE (
         );

      MEASURE (
         const MEASURE& rhs
         );

      #ifndef GENERATING_DOXYGEN_OUTPUT
      MEASURE (
         MEASURE_PRIV *pPriv
         );
      #endif // GENERATING_DOXYGEN_OUTPUT

      ~MEASURE (
         );

      MEASURE& operator= (
         const MEASURE& rhs
         );

      bool FindUnit (
         int micode,                      
         UNIT& unitret                    
         ) const;

      bool FindUnit (
         const IDENTIFIER& identifier,    
         UNIT& unitret                    
         ) const;

      bool FindUnit (
         const MISTRING& name,            
         UNIT& unitret                    
         ) const;
         
      const UNIT& GetBaseUnit (
         ) const;

      const IDENTIFIERLIST& GetIdList (
         ) const;

      const MISTRING& GetName (
         ) const;

      TYPE GetType (
         ) const;

      const UNITLIST& GetUnitList (
         ) const;

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      MEASURE_PRIV *m_pPriv;
      #endif // GENERATING_DOXYGEN_OUTPUT

   };


inline bool operator== (
   const MEASURE& lhs,
   const MEASURE& rhs
   ) { return (lhs.GetType() == rhs.GetType()); }

inline bool operator!= (
   const MEASURE& lhs,
   const MEASURE& rhs
   ) { return (lhs.GetType() != rhs.GetType()); }

/*
#if defined(WIN32) && !defined(GEOMDLL) && !defined(NODLLLINKAGE)
#pragma warning(disable:4231)
extern template class CLASSLIBEXPORT MILIST<MEASURE>;    //! Template instantiation
#pragma warning(default:4231)
#endif
*/
typedef MILIST<MEASURE> MEASURELIST;

//-------------------------------------------------------------------------------------------------------------------

#define  UNIT_None                     0

#define  UNIT_Scale_Unity              0
#define  UNIT_Scale_Percent            1
#define  UNIT_Scale_PartsPerMillion    3

#define  UNIT_Area_SquareMeter         0
#define  UNIT_Area_SquareMeters        0
#define  UNIT_Area_SquareKilometer     3
#define  UNIT_Area_SquareKilometers    3
#define  UNIT_Area_SquareMillimeter    2
#define  UNIT_Area_SquareMillimeters   2

#define  UNIT_Length_Meter          0
#define  UNIT_Length_Kilometer      3
#define  UNIT_Length_Decimeter      10
#define  UNIT_Length_Centimeter     1
#define  UNIT_Length_Millimeter     2
#define  UNIT_Length_Micrometer     8
#define  UNIT_Length_Nanometer      9
#define  UNIT_Length_Foot           4
#define  UNIT_Length_TenthFoot      64
#define  UNIT_Length_HundredthFoot  65
#define  UNIT_Length_Inch           6
#define  UNIT_Length_Mile           7
#define  UNIT_Length_Foot_US        16

#define  UNIT_Distance_Meters          UNIT_Length_Meter
#define  UNIT_Distance_Kilometers      UNIT_Length_Kilometer
#define  UNIT_Distance_Centimeters     UNIT_Length_Centimeter
#define  UNIT_Distance_Millimeters     UNIT_Length_Millimeter
#define  UNIT_Distance_Micrometers     UNIT_Length_Micrometer
#define  UNIT_Distance_Nanometers      UNIT_Length_Nanometer
#define  UNIT_Distance_Feet            UNIT_Length_Foot
#define  UNIT_Distance_Inches          UNIT_Length_Inch

#define  UNIT_PlaneAngle_Degree              0
#define  UNIT_PlaneAngle_Degrees             0
#define  UNIT_PlaneAngle_Radian              1
#define  UNIT_PlaneAngle_Radians             1
#define  UNIT_PlaneAngle_Grad                3
#define  UNIT_PlaneAngle_ArcSecond           4
#define  UNIT_PlaneAngle_ArcMinute           5
#define  UNIT_PlaneAngle_Gon                 6
#define  UNIT_PlaneAngle_CentisimalMinute    8
#define  UNIT_PlaneAngle_CentisimalSecond    9
#define  UNIT_PlaneAngle_Hour                10

#define  UNIT_Time_Second              0
#define  UNIT_Time_Seconds             0
#define  UNIT_Time_Minute              1
#define  UNIT_Time_Hour                2
#define  UNIT_Time_Millisecond         6
#define  UNIT_Time_Milliseconds        6
#define  UNIT_Time_Microsecond         7
#define  UNIT_Time_Microseconds        7

#define  UNIT_Volume_CubicMeter        0
#define  UNIT_Volume_CubicMeters       0

#define  UNIT_Velocity_MetersPerSecond    0
#define  UNIT_Velocity_FeetPerSecond      2
#define  UNIT_Velocity_KilometersPerHour  4
#define  UNIT_Velocity_MilesPerHour       5
#define  UNIT_Velocity_Knots              6

//---------------------------------------------------------------------------------------------------------------------

enum SYSTEMID {
   SYSTEMID_Unspecified =     0,
   SYSTEMID_Metric =          1,    
   SYSTEMID_English =         2,    
   };

//---------------------------------------------------------------------------------------------------------------------

enum IDNUM {
   IDNUM_Unspecified =              0,

   IDNUM_Scale_Unity =              (MEASURE::TYPE_Scale << 8) | UNIT_Scale_Unity,
   IDNUM_Scale_Percent =            (MEASURE::TYPE_Scale << 8) | UNIT_Scale_Percent,
   IDNUM_Scale_PartsPerMillion =    (MEASURE::TYPE_Scale << 8) | UNIT_Scale_PartsPerMillion,

   IDNUM_Length_Kilometer =         (MEASURE::TYPE_Length << 8) | UNIT_Length_Kilometer,
   IDNUM_Length_Decimeter =         (MEASURE::TYPE_Length << 8) | UNIT_Length_Decimeter,
   IDNUM_Length_Meter =          (MEASURE::TYPE_Length << 8) | UNIT_Length_Meter,
   IDNUM_Length_Centimeter =        (MEASURE::TYPE_Length << 8) | UNIT_Length_Centimeter,
   IDNUM_Length_Millimeter =        (MEASURE::TYPE_Length << 8) | UNIT_Length_Millimeter,
   IDNUM_Length_Micrometer =        (MEASURE::TYPE_Length << 8) | UNIT_Length_Micrometer,
   IDNUM_Length_Nanometer =         (MEASURE::TYPE_Length << 8) | UNIT_Length_Nanometer,
   IDNUM_Length_Mile =              (MEASURE::TYPE_Length << 8) | UNIT_Length_Mile,
   IDNUM_Length_Foot =              (MEASURE::TYPE_Length << 8) | UNIT_Length_Foot,
   IDNUM_Length_TenthFoot =         (MEASURE::TYPE_Length << 8) | UNIT_Length_TenthFoot,
   IDNUM_Length_HundredthFoot =     (MEASURE::TYPE_Length << 8) | UNIT_Length_HundredthFoot,
   IDNUM_Length_Inch =              (MEASURE::TYPE_Length << 8) | UNIT_Length_Inch,

   IDNUM_PlaneAngle_Degree =        (MEASURE::TYPE_PlaneAngle << 8) | UNIT_PlaneAngle_Degree,
   IDNUM_PlaneAngle_Radian =        (MEASURE::TYPE_PlaneAngle << 8) | UNIT_PlaneAngle_Radian,
   IDNUM_PlaneAngle_ArcMinute =     (MEASURE::TYPE_PlaneAngle << 8) | UNIT_PlaneAngle_ArcMinute,
   IDNUM_PlaneAngle_ArcSecond =     (MEASURE::TYPE_PlaneAngle << 8) | UNIT_PlaneAngle_ArcSecond,

   IDNUM_Area_SquareMeter =         (MEASURE::TYPE_Area << 8) | UNIT_Area_SquareMeter,
   IDNUM_Area_SquareKilometer =     (MEASURE::TYPE_Area << 8) | UNIT_Area_SquareKilometer,
   IDNUM_Area_SquareMillimeter =    (MEASURE::TYPE_Area << 8) | UNIT_Area_SquareMillimeter,

   IDNUM_Time_Second =              (MEASURE::TYPE_Time << 8) | UNIT_Time_Second,
   IDNUM_Time_Millisecond =         (MEASURE::TYPE_Time << 8) | UNIT_Time_Millisecond,
   IDNUM_Time_Microsecond =         (MEASURE::TYPE_Time << 8) | UNIT_Time_Microsecond,

   IDNUM_Velocity_MetersPerSecond = (MEASURE::TYPE_Velocity << 8) | UNIT_Velocity_MetersPerSecond,
   IDNUM_Velocity_FeetPerSecond =   (MEASURE::TYPE_Velocity << 8) | UNIT_Velocity_FeetPerSecond,
   IDNUM_Velocity_KilometersPerHour =  (MEASURE::TYPE_Velocity << 8) | UNIT_Velocity_KilometersPerHour,
   IDNUM_Velocity_MilesPerHour =    (MEASURE::TYPE_Velocity << 8) | UNIT_Velocity_MilesPerHour,
   IDNUM_Velocity_Knots =           (MEASURE::TYPE_Velocity << 8) | UNIT_Velocity_Knots,
   };

//-------------------------------------------------------------------------------------------------------------------

class CLASSLIBEXPORT UNIT {
   public:

      enum NAMEUSAGE {
         NAMEUSAGE_Singular,
         NAMEUSAGE_Plural
         };

      UNIT (
         );

      UNIT (
         const UNIT& rhs
         );

      UNIT (
         IDNUM idnum
         );

      #ifndef GENERATING_DOXYGEN_OUTPUT
      UNIT (
         UNIT_PRIV *pPriv
         );
      #endif // GENERATING_DOXYGEN_OUTPUT

      ~UNIT (
         );

      UNIT& operator= (
         const UNIT& rhs
         );

      UNIT& operator= (
         IDNUM idnum
         );

      double ConvertFromBase (
         double inval
         ) const;

      void ConvertFromBase (
         double inval,
         MISTRING& outstr
         ) const;

      double ConvertToBase (
         double inval
         ) const;

      double ConvertToBase (
         const MISTRING& instr
         ) const;

      void Define (
         const MEASURE::TYPE MeasureType,
         double ConversionToBase,
         const MISTRING& Symbol,
         const MISTRING& NameSingular,
         const MISTRING& NamePlural
         );

      // Get composite measure/unit IDNUM.
      IDNUM GetCompositeIdNum (
         ) const;

      double GetFactorA (
         ) const;

      double GetFactorB (
         ) const;

      double GetFactorC (
         ) const;

      const IDENTIFIERLIST& GetIdList (
         ) const;

      int GetIdNum (
         ) const;

      const MEASURE& GetMeasure (
         ) const;

      const MISTRING& GetName (
         NAMEUSAGE nameusage              
         ) const;

      const MISTRING& GetSymbol (
         ) const;

      bool IsEqual (
         const UNIT& rhs
         ) const;

      bool IsString (
         ) const;

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      UNIT_PRIV *m_pPriv;
      friend class MEASURE_PRIV;
      #endif // GENERATING_DOXYGEN_OUTPUT

   };

inline bool operator== (
   const UNIT& lhs,
   const UNIT& rhs
   ) { return (lhs.IsEqual(rhs)); }

inline bool operator!= (
   const UNIT& lhs,
   const UNIT& rhs
   ) { return (!lhs.IsEqual(rhs)); }


//-------------------------------------------------------------------------------------------------------------------

class CLASSLIBEXPORT SYSTEM {
   public:

      static bool FindMeasure (
         const IDENTIFIER& identifier,    
         MEASURE& measure                 
         );

      static bool FindMeasure (
         MEASURE::TYPE type,              
         MEASURE& measure                 
         );

      static bool FindUnit (
         IDNUM idnum,                     
         UNIT& unitret                    
         );

      static bool FindUnit (
         MEASURE::TYPE type,              
         int micode,                      
         UNIT& unitret                    
         );
         
      static bool FindUnit (
         const IDENTIFIER& identifier,    
         UNIT& unitret                    
         );
         
      static bool FindUnit (
         MEASURE::TYPE type,              
         const IDENTIFIER& identifier,    
         UNIT& unitret                    
         );
         
      static bool FindUnit (
         MEASURE::TYPE type,              
         const MISTRING& name,            
         UNIT& unitret                    
         );
         
      static const MEASURELIST& GetMeasureList (
         );

      static ERRVALUE Initialize ();
   };


//-------------------------------------------------------------------------------------------------------------------

class CLASSLIBEXPORT CONVERTER {
   public:

      CONVERTER (
         );

      CONVERTER (
         const CONVERTER& rhs
         );

      CONVERTER (
         const MEASURE& measure
         );

      ~CONVERTER ();

      CONVERTER& operator= (
         const CONVERTER& rhs
         );

      double ConvertForward (
         double value                     
         ) const;

      ERRVALUE ConvertForward (
         const MISTRING& instr,           
         double& outval                   
         ) const;
         
      ERRVALUE ConvertForward (
         double inval,                    
         MISTRING& outstr                 
         ) const;
         
      ERRVALUE ConvertForward (
         const MISTRING& instr,           
         MISTRING& outstr                 
         ) const;
         
      double ConvertInverse (
         double value                     
         ) const;

      ERRVALUE ConvertInverse (
         const MISTRING& instr,           
         double& outval                   
         ) const;
         
      ERRVALUE ConvertInverse (
         double inval,                    
         MISTRING& outstr                 
         ) const;
         
      ERRVALUE ConvertInverse (
         const MISTRING& instr,           
         MISTRING& outstr                 
         ) const;
         
      const MEASURE& GetMeasure (
         ) const;

      double GetScale (
         ) const;

      const UNIT& GetSourceUnit (
         ) const;

      const UNIT& GetTargetUnit (
         ) const;

      void IniReadSource (
         INIHANDLE IniHandle,
         const char *IniGroup,
         const char *IniName,
         int micode = 0                      
         );

      void IniReadTarget (
         INIHANDLE IniHandle,
         const char *IniGroup,
         const char *IniName,
         int micode = 0                      
         );

      void IniWriteSource (
         INIHANDLE IniHandle,
         const char *IniGroup,
         const char *IniName
         ) const;

      void IniWriteTarget (
         INIHANDLE IniHandle,
         const char *IniGroup,
         const char *IniName
         ) const;

      ERRVALUE SetSourceUnit (
         const UNIT& SourceUnit
         );

      ERRVALUE SetTargetUnit (
         const UNIT& TargetUnit
         );

      ERRVALUE SetUnits (
         const UNIT& SourceUnit,
         const UNIT& TargetUnit
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      CONVERTER_PRIV *m_pPriv;
      void GetExclusive();
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//---------------------------------------------------------------------------------------------------------------------
//    Functions

LIBEXPORT double ConvertToScale (
   double ScaleDenominator,      
   UOM::SYSTEMID UnitSystem,     
   const UOM::UNIT& UnitSrc,     
   UOM::UNIT& UnitTgt            
   );

enum FORMATSCALE {
   FORMATSCALE_Ratio =           0x00,    // Format as ratio (eg, 1 cm : 1234 km) [default]
   FORMATSCALE_UnitFraction =    0x01,    // Format as unit fraction (eg 1234 km/cm)
   FORMATSCALE_AddNewline =      0x02,    // Add newline to end if any formatting done
   FORMATSCALE_AddSpacesAlways = 0x04,    // Always add spaces even if unitless (eg 1 : 20000)
   };
#ifndef GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(FORMATSCALE)
#endif

LIBEXPORT MISTRING FormatScale (
   double ScaleDenominator,      
   UOM::SYSTEMID UnitSystem,     
   const UOM::UNIT& UnitSrc,     
   FORMATSCALE format,           
   int MinPrecision = 3          
   );

//---------------------------------------------------------------------------------------------------------------------
}; 


// Legacy definitions
typedef  UOM::MEASURE::TYPE   UNIT_TYPE;

#define  UNIT_TYPE_Constant                  0     
#define  UNIT_TYPE_Area                      UOM::MEASURE::TYPE_Area
#define  UNIT_TYPE_Length                    UOM::MEASURE::TYPE_Length
#define  UNIT_TYPE_Distance                  UOM::MEASURE::TYPE_Distance
#define  UNIT_TYPE_PlaneAngle                UOM::MEASURE::TYPE_PlaneAngle
#define  UNIT_TYPE_Time                      UOM::MEASURE::TYPE_Time
#define  UNIT_TYPE_Volume                    UOM::MEASURE::TYPE_Volume
#define  UNIT_TYPE_Velocity                  UOM::MEASURE::TYPE_Velocity
#define  UNIT_TYPE_Acceleration              UOM::MEASURE::TYPE_Acceleration
#define  UNIT_TYPE_AngularVelocity           UOM::MEASURE::TYPE_AngularVelocity
#define  UNIT_TYPE_Date                      UOM::MEASURE::TYPE_Date
#define  UNIT_TYPE_None                      UOM::MEASURE::TYPE_None


#undef   CLASSLIBEXPORT
#undef   LIBEXPORT

#endif   

---