Common.h

/*
 * Common.h - type declarations, (debug) macro's, assertion classes.
 *
 * This file is part of the Rulbus Device Class Library (RDCL).
 *
 * Copyright (C) 2003-2004, Leiden University.
 *
 * This library is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * The library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with mngdriver; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * $Id: Common.h 2 2004-10-12 11:54:15Z moene $
 */

#ifndef __COMMON_H
#define __COMMON_H
#define __IN_COMMON_H

#include <math>         // for std::fabs
#include <limits>       // for std::numeric_limits<>
#include <string>       // for std::String

#ifdef DOXYGEN
   #define DEBUG DFLAG_ALL
#endif

#define DFLAG_NONE              0x0000  
#define DFLAG_ALL               0xFFFF  
#define DFLAG_PRODUCTION        (DFLAG_ALL & ~DFLAG_ENSURE)  

#define DFLAG_GENERAL           0x0001  
#define DFLAG_INTERFACE         0x0002  
#define DFLAG_BUSVIOLATION      0x0004  
#define DFLAG_REQUIRE           0x0010  
#define DFLAG_ENSURE            0x0020  
#define DFLAG_NEVER_GET_HERE    0x0040  

#if !defined( DEBUG )
#define DEBUG DFLAG_NONE
#endif

#define dim(a) (sizeof(a)/sizeof((a)[0]))

#define DECLARE_TYPE( mydecl, mytype )  \
typedef mydecl         mytype;          \
typedef mytype *       mytype ## Ptr;   \
typedef const mytype * mytype ## Cptr;  \
typedef mytype &       mytype ## Ref;   \
typedef const mytype & mytype ## Cref;

#define DECLARE_CLASS( tag )            \
   class   tag;                         \
   typedef tag *       tag ## Ptr;      \
   typedef const tag * tag ## Cptr;     \
   typedef tag &       tag ## Ref;      \
   typedef const tag & tag ## Cref;

#if 0

   #define PROXY_CAST   static_cast
#else

   #define PROXY_CAST   dynamic_cast
#endif



namespace Rulbus
{


   //
   // compiler types:
   //

   DECLARE_TYPE(        signed char, int8   );  // signed 8-bit integral type
   DECLARE_TYPE(      unsigned char, uInt8  );  // signed 8-bit integral type
   DECLARE_TYPE(   signed short int, int16  );  // signed 16-bit integral type
   DECLARE_TYPE( unsigned short int, uInt16 );  // unsigned 16-bit integral type
   DECLARE_TYPE(         signed int, int32  );  // signed 32-bit integral type
   DECLARE_TYPE(       unsigned int, uInt32 );  // unsigned 32-bit integral type
   DECLARE_TYPE(              float, float32 ); // 32-bit real type (Real32)
   DECLARE_TYPE(             double, float64 ); // 64-bit real type (Real64)

   //
   // library types:
   //

   DECLARE_TYPE(              uInt8, Byte   );  // Byte type
   DECLARE_TYPE(             uInt16, Word   );  // Word type
   DECLARE_TYPE(             uInt32, Quad   );  // Double word type
   DECLARE_TYPE(               char, Char   );  // character type
   DECLARE_TYPE(                int, Int    );  // integral type
   DECLARE_TYPE(              int16, Int16  );  // 16-bit signed integral type
   DECLARE_TYPE(              int32, Int32  );  // 32-bit signed integral type
   DECLARE_TYPE(             double, Real   );  // real type
   DECLARE_TYPE(            float32, Real32 );  // 32-bit real type
   DECLARE_TYPE(            float64, Real64 );  // 64-bit real type

   DECLARE_TYPE(        std::string, String       );    // String type
   DECLARE_TYPE(     std::exception, StdException );    // StdException type

   DECLARE_TYPE(             String, Name   );  // Name type
   DECLARE_TYPE(                Int, Addr   );  // Addr type
   DECLARE_TYPE(                Int, Rack   );  // Rack type

   DECLARE_TYPE(               Real, Volt   );  // Voltage type [V]
   DECLARE_TYPE(             Real32, Volt32 );  // 32-bit Voltage type [V]
   DECLARE_TYPE(               Real, Time   );  // Time type [s]
   DECLARE_TYPE(               Real, Freq   );  // Frequency type [Hz]
   DECLARE_TYPE(               Real, Length );  // Length type [m]

   template <typename aType>
   struct isEqual
   {
      isEqual( aType a ): m_a(a) { }

      bool operator()( aType b )
      {
         return std::fabs( b - m_a ) < std::numeric_limits<aType>::epsilon();
      }

      aType m_a;                        
   };

   typedef isEqual<Volt> isEqualVolt;       
   typedef isEqual<Time> isEqualTime;       
   typedef isEqual<Freq> isEqualFreq;       


} // namespace Rulbus

#include "Shims.h"              // for to_cstr(), used in Exception.h
#include "Assertion.h"          // for design-by-contract exceptions, assertions
#include "Exception.h"          // for our exceptions

#undef __IN_COMMON_H
#endif  // __COMMON_H

/*
 * end of file
 */

---