unitconv.h

Go to the documentation of this file.

/**
 * \file mi32/unitconv.h
 * \brief Include file for unit type selection functions
 *
 * \if NODOC
 * $Id: unitconv.h_v 1.35 2003/10/01 22:13:29 dwilliss Exp $
 *
 * $Log: unitconv.h_v $
 * Revision 1.35  2003/10/01 22:13:29  dwilliss
 * doxygen
 *
 * Revision 1.34  2003/09/22 20:44:58  mju
 * Remove last deprecated unit_type (dist).
 *
 * Revision 1.33  2003/09/15 13:49:56  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.32  2003/09/05 17:08:04  mju
 * Remove stuff replaced by UOM system.
 *
 * Revision 1.31  2003/08/14 14:30:11  mju
 * Make UNIT_TYPE an enum.
 * Deprecate old unit type values.
 *
 * Revision 1.30  2003/06/03 20:08:22  scowan
 * Added associate with.
 *
 * Revision 1.29  2001/06/08 16:55:21  mju
 * Add #defines for UNIT_Time_...
 *
 * Revision 1.28  2001/03/07 15:15:57  scowan
 * Fixed lack of include file problem.
 *
 * Revision 1.27  2001/03/06 15:15:51  mju
 * Add another UNITCONV ctor and IniRead/Write methods.
 *
 * Revision 1.26  2001/02/13 17:47:48  mju
 * Use const in ConvertUnit...
 *
 * Revision 1.25  2000/12/04 18:17:44  mju
 * Ignore internal fns in genitor.
 * Add standard header comments.
 * \endif
**/

#ifndef INC_MI32_UNITCONV_H
#define INC_MI32_UNITCONV_H

#ifndef  INC_MI32_STDDEFNS_H
   #include <mi32/stddefns.h>
#endif

#ifndef  INC_MI32_INIDEFNS_H
   #include <mi32/inidefns.h>
#endif

#ifndef  INC_MI32_UOM_H
#include <mi32/uom.h>
#endif

#ifndef  INC_STRING_H
#include <string.h>     // Includes defn for memset()
#define  INC_STRING_H
#endif

#ifdef GEOMDLL
   #define GEOMLIBEXPORT MI_DLLEXPORT
#else
   #define GEOMLIBEXPORT MI_DLLIMPORT
#endif


//! Unit conversion parameters.
struct UNITCONV {
   // This structure is used extensively within other structure and in DLLs.
   // Therefore, members may not be added or removed, nor may non-inline or virtual methods be added.

      double fr_offset;
      double to_offset;
      double scale;                       //!< Scale factor
      UINT8 type;                         //!< UNIT_TYPE_...
      UINT8 to;                           //!< Units to convert to, specific to type
      UINT8 from;                         //!< Units to convert from, specific to type
      UINT8 do_string;

   public:

      //! Default constructor.
      UNITCONV (
         ) { memset(this,0,sizeof(UNITCONV)); scale = 1.0; }

      //! Construct with specified scale
      explicit UNITCONV (
         double inscale
         ) { memset(this,0,sizeof(UNITCONV)); scale = inscale; }

      //! Construct with specified unit type and units.
      inline explicit UNITCONV (
         int UnitType,                       //!< Unit type (UNIT_TYPE_...)
         int FromCode = 0,                   //!< Units to convert from specific to type
         int ToCode = 0                      //!< Units to convert to specific to type
         );

      //! Read unit code from INI file and set conversion.
      //! This will set the units to convert TO, unit to convert from will be previous 'from' value.
      inline void IniRead (
         INIHANDLE IniHandle,
         const char *IniGroup,
         const char *IniName,
         int UnitType = -1,
         int UnitCode = 0
         );

      //! Write unit code to INI file.
      void IniWrite (
         INIHANDLE IniHandle,
         const char *IniGroup,
         const char *IniName
         ) const { ::IniWrite(IniHandle,IniGroup,IniName,this->to); return; }
      
   };


/*----------------------------------------------------------------------------*/
/*    Date formatting flags                                                   */
/*----------------------------------------------------------------------------*/

#define  DATECONV_NoCent      0x80

#define  DATECONV_ORDERMASK   0x03
#define  DATECONV_YMD         0x00
#define  DATECONV_YDM         0x01
#define  DATECONV_MDY         0x02
#define  DATECONV_DMY         0x03

#define  DATECONV_MONTHMASK   0x0C
#define  DATECONV_MonthNum    0x00
#define  DATECONV_MonthAbbr   0x04
#define  DATECONV_MonthName   0x08

#define  DATECONV_SEPMASK     0x70
#define  DATECONV_SepNone     0x00
#define  DATECONV_SepSpace    0x10
#define  DATECONV_SepDash     0x20
#define  DATECONV_SepDot      0x30
#define  DATECONV_SepSlash    0x40
#define  DATECONV_SepComma    0x50  //!<  23 January, 1996 

/*----------------------------------------------------------------------------*/
/*    Functions and Macros                                                    */
/*----------------------------------------------------------------------------*/

#if defined(__cplusplus)
extern "C" {
#endif

//!:Associate with "Unit Conversions"
//!\addtogroup UnitConv Unit Conversion
//!@{

//! Perform unit conversion on numeric value.
//! @return Converted value
GEOMLIBEXPORT double ConvertUnit (
   double val,                         //!< Value to convert
   const UNITCONV *c
   );

//! Perform inverse unit conversion on numeric value.
//! @return Converted unit
GEOMLIBEXPORT double ConvertUnitInv (
   double val,                         //!< Value to convert
   const UNITCONV *conv
   );

//! Special unit conversion for string data types (string to number).
//! @return The date as a double in YYYYMMDD format
//! Currently only implements conversion for UNIT_TYPE_DATE.
//! the "to" field of the conv can be any of the following.
//!
//!   \li\b DATECONV_YMD         Year Month Day order
//!   \li\b DATECONV_YDM         Year Day Month order
//!   \li\b DATECONV_MDY         Month Day Year order
//!   \li\b DATECONV_DMY         Day Month Year order
//!
//! Other DATECONV flags can be ORd in too, but will be ignored.
//! It copes with any type of month representation and seperator.
GEOMLIBEXPORT double ConvertUnitStrInv (
   char *str,
   const UNITCONV *conv
   );

//! Special unit conversion for string data types (number to string).
//! @return str
//! Currently only implements conversion for UNIT_TYPE_DATE.
//! the "to" field of the conv can be any of the following ORd together
//!
//!   \li\b DATECONV_NoCent      2 digit year instead of 4 digit
//!   \li\b DATECONV_YMD         Year Month Day order
//!   \li\b DATECONV_YDM         Year Day Month order
//!   \li\b DATECONV_MDY         Month Day Year order
//!   \li\b DATECONV_DMY         Day Month Year order
//!   \li\b DATECONV_MonthNum    Numeric month values
//!   \li\b DATECONV_MonthAbbr   Use 3 letter month abbreviation
//!   \li\b DATECONV_MonthName   Use full month names
//!   \li\b DATECONV_SepNone     No seperator
//!   \li\b DATECONV_SepSpace    Use space for seperator
//!   \li\b DATECONV_SepDash     Use dash for seperator
//!   \li\b DATECONV_SepDot      Use dot for seperator
//!   \li\b DATECONV_SepSlash    Use slash for seperator
//!   \li\b DATECONV_SepComma    Use comma for seperator
GEOMLIBEXPORT char * ConvertUnitStr (
   char *str,
   int len,
   double val,
   const UNITCONV *conv
   );

//! Setup unit conversion structure between units of given type.
//! @return Pointer to specified unit conversion structure
GEOMLIBEXPORT UNITCONV *GetUnitConversion (
   int type,                           //!< Unit type (UNIT_TYPE_...)
   int fromcode,                       //!< Unit code to convert from
   int tocode,                         //!< Unit code to convert to
   UNITCONV *conv                      //!< Unit conversion structure to fill in
   );

//! Setup "identity" unit conversion for given type.
//! @return Pointer to specified unit conversion structure
GEOMLIBEXPORT UNITCONV *GetUnitConversionIdentity (
   int type,                           //!< Unit type (UNIT_TYPE_...)
   UNITCONV *conv                      //!< Unit conversion structure to fill in
   );

#if defined(__cplusplus)
}
#endif

//! Get name for given unit type/number.
//! @return Localized unit name.
GEOMLIBEXPORT const MISTRING& GetUnitName (
   int type,                           //!< Unit type (UNIT_TYPE_...)
   int num                             //!< Unit number within type
   );

//! Get "symbol" for given unit type/number.
//! @return Localized unit "symbol".
GEOMLIBEXPORT const MISTRING& GetUnitSymbol (
   int type,                           //!< Unit type (UNIT_TYPE_...)
   int num                             //!< Unit number within type
   );

#ifndef GENERATING_DOXYGEN_OUTPUT
// Inlines

inline UNITCONV::UNITCONV (
   int UnitType,                       //!< Unit type (UNIT_TYPE_...)
   int FromCode,                       //!< Units to convert from specific to type
   int ToCode                          //!< Units to convert to specific to type
   ) {
   GetUnitConversion(UnitType,FromCode,ToCode,this);
   }

inline void UNITCONV::IniRead (
   INIHANDLE IniHandle,
   const char *IniGroup,
   const char *IniName,
   int UnitType,
   int UnitCode
   ) {
   if (UnitType == -1) UnitType = this->type;
   ::IniRead(IniHandle,IniGroup,IniName,UnitCode);
   GetUnitConversion(UnitType,this->from,UnitCode,this);
   return;
   }

#endif // GENERATING_DOXYGEN_OUTPUT

//!@}

#endif

---