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 Wasp {
 
 
 
// 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);
    };
 
    static bool GetEnableErrMsg() { return Enabled; }
 
    // 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);
 
COMMON_API std::vector<std::string> &SplitString(const std::string &s, char delim, std::vector<std::string> &elems);
COMMON_API std::vector<size_t> &SplitString(const std::string &s, char delim, std::vector<size_t> &elems);
COMMON_API std::vector<int> &SplitString(const std::string &s, char delim, std::vector<int> &elems);
COMMON_API std::vector<float> &SplitString(const std::string &s, char delim, std::vector<float> &elems);
COMMON_API 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);
 
// ran1 function declaration (from numerical recipes in C)
COMMON_API double ran1(long *);
};    // namespace Wasp
 
//
// 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
 
#if defined(__CYGWIN__)
    #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