MyBase.h

Go to the documentation of this file.

//
//      $Id$
//
//************************************************************************
//                              *
//           Copyright (C)  2004            *
//     University Corporation for Atmospheric Research      *
//           All Rights Reserved            *
//                              *
//************************************************************************/
//
//  File:       
//
//  Author:     John Clyne
//          National Center for Atmospheric Research
//          PO 3000, Boulder, Colorado
//
//  Date:       Wed Sep 29 15:40:23 MDT 2004
//
//  Description:    A collection of general purpose utilities - things that
//                  probably should be in the STL but aren't.
//

#ifndef _MyBase_h_
#define _MyBase_h_

#include <cmath>
#include <cstdarg>
#include <string>
#include <cstring>
#include <vector>
#include <vapor/common.h>

#ifdef  NEW_DEBUG
#include <new>
void * operator new (size_t sz);
void * operator new[] (size_t sz);
#endif


#ifdef WIN32
//Silence an annoying and unnecessary compiler warning
#pragma warning(disable : 4251)
#endif
using namespace std;

namespace VetsUtil {



//default values used for variables outside valid grid
const float ABOVE_GRID = 0.f;
const float BELOW_GRID = 0.f;

//
// The MyBase base class provides a simple error reporting mechanism 
// that can be used by derrived classes. N.B. the error messages/codes
// are stored in static class members.
//
class COMMON_API MyBase {
public:

 typedef void (*ErrMsgCB_T) (const char *msg, int err_code);
 typedef void (*DiagMsgCB_T) (const char *msg);

 MyBase();
 const string &getClassName() const {return (_className); };


 // 
 //
 static void    SetErrMsg(const char *format, ...);

 // 
 //
 static void    SetErrMsg(int errcode, const char *format, ...);

 //
 static const char  *GetErrMsg() {return(ErrMsg);}

 // 
 //
 static void    SetErrCode(int err_code) { ErrCode = err_code; }

 // 
 //
 static int GetErrCode() {return(ErrCode); }

 //
 static void SetErrMsgCB(ErrMsgCB_T cb) { ErrMsgCB = cb; };

 //
 static ErrMsgCB_T GetErrMsgCB() { return(ErrMsgCB); };

 //
 static void SetErrMsgFilePtr(FILE *fp) { ErrMsgFilePtr = fp; };

 //
 static const FILE  *SetErrMsgFilePtr() { return(ErrMsgFilePtr); };

 // 
 //
 static void    SetDiagMsg(const char *format, ...);

 //
 static const char  *GetDiagMsg() {return(DiagMsg);}


 //
 static void SetDiagMsgCB(DiagMsgCB_T cb) { DiagMsgCB = cb; };

 //
 static DiagMsgCB_T GetDiagMsgCB() { return(DiagMsgCB); };

 //
 static void SetDiagMsgFilePtr(FILE *fp) { DiagMsgFilePtr = fp; };

 //

 static bool EnableErrMsg(bool enable) {
    bool prev = Enabled; Enabled = enable; return (prev);
 };

 // N.B. the error codes/messages are stored in static class members!!!
 static char    *ErrMsg;
 static int ErrCode;
 static int ErrMsgSize;
 static FILE    *ErrMsgFilePtr;
 static ErrMsgCB_T ErrMsgCB;

 static char    *DiagMsg;
 static int DiagMsgSize;
 static FILE    *DiagMsgFilePtr;
 static DiagMsgCB_T DiagMsgCB;
 static bool Enabled;

 

protected:
    void    SetClassName(const string &name) { _className = name; };

private:
    static void _SetErrMsg(char **msg,int *sz,const char *format, va_list args);
    string _className;  // name of class

};

 COMMON_API inline int    IsOdd(int x) { return(x % 2); };

 //
 COMMON_API int IsPowerOfTwo(unsigned int x);

 COMMON_API inline int  Min(int a, int b) { return(a<b ? a : b); };
 COMMON_API inline int  Max(int a, int b) { return(a>b ? a : b); };

 COMMON_API inline size_t   Min(size_t a, size_t b) { return(a<b ? a : b); };
 COMMON_API inline size_t   Max(size_t a, size_t b) { return(a>b ? a : b); };

 COMMON_API inline float    Min(float a, float b) { return(a<b ? a : b); };
 COMMON_API inline float    Max(float a, float b) { return(a>b ? a : b); };

 COMMON_API inline double   Min(double a, double b) { return(a<b ? a : b); };
 COMMON_API inline double   Max(double a, double b) { return(a>b ? a : b); };


 COMMON_API inline double   LogBaseN(double x, double n) { return(log(x) / log(n)); };

 //Find integer log, base 2:
 COMMON_API int ILog2(int n);

 //
 //
 COMMON_API int StrCmpNoCase(const string &s, const string &t);


 //
 COMMON_API void    StrRmWhiteSpace(string &s);

 //
 //
 COMMON_API void    StrToWordVec(const string &s, vector <string> &v);


 std::vector<std::string> &SplitString(
    const std::string &s, char delim, std::vector<std::string> &elems
 ); 
 std::vector<size_t> &SplitString(
    const std::string &s, char delim, std::vector<size_t> &elems
 ); 
 std::vector<int> &SplitString(
    const std::string &s, char delim, std::vector<int> &elems
 ); 
 std::vector<float> &SplitString(
    const std::string &s, char delim, std::vector<float> &elems
 ); 
 std::vector<double> &SplitString(
    const std::string &s, char delim, std::vector<double> &elems
 ); 



 //
 COMMON_API unsigned long long GetBits64(
    unsigned long long targ,
    int pos,
    int n
 );

 //
 COMMON_API unsigned long long SetBits64(
    unsigned long long targ,
    int pos,
    int n,
    unsigned long long src
 );

#ifdef WIN32
 COMMON_API inline int rint(float X) {
     return ((X)>0)?((int)(X+0.5)):((int)(X-0.5));
 }
#endif
 // ran1 function declaration (from numerical recipes in C)
COMMON_API double ran1(long *);
};


// 
// Handle OS differences in 64-bit IO operators
//


// 64-bit fseek
//

#ifdef  FSEEK64
#undef FSEEK64
#endif

#if defined(WIN32)
//Note: win32 won't seek beyond 32 bits
#define FSEEK64 fseek
#endif

#if defined(Linux) || defined(AIX)
#define FSEEK64 fseeko64
#endif

#if defined(Darwin)
#define FSEEK64 fseeko
#endif

#ifndef FSEEK64
#define FSEEK64 fseek64
#endif

// 64-bit fopen
//

#ifdef  FOPEN64
#undef FOPEN64
#endif

#if defined(WIN32) || defined(Darwin)
#define FOPEN64 fopen
#endif

#ifndef FOPEN64
#define FOPEN64 fopen64
#endif

// 64-bit stat
//

#ifdef  STAT64
#undef STAT64
#endif

#ifdef  STAT64_T
#undef STAT64_T
#endif

#if defined(WIN32) 
#define STAT64_T    _stat
#define STAT64  _stat
#endif

#if defined(Darwin)
#define STAT64_T stat
#define STAT64  stat
#endif

#ifndef STAT64
#define STAT64_T stat64
#define STAT64 stat64
#endif


#ifndef TIME64_T
#ifdef WIN32
#define TIME64_T __int64
#else
#define TIME64_T int64_t
#endif
#endif


#endif //MYBASE_H