util.h

Go to the documentation of this file.

// File: $Id$
// Author: John Wu <John.Wu at acm.org> Lawrence Berkeley National Laboratory
// Copyright 2000-2011 the Regents of the University of California
#ifndef IBIS_UTIL_H
#define IBIS_UTIL_H




#if defined(_WIN32) && defined(_MSC_VER) && defined(_DEBUG)
#define _CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>
#else
#include <stdlib.h>
#endif
#include "const.h"

#include <cctype>       // std::isspace
#include <cstring>      // std::strcpy
#include <stdio.h>      // sprintf, remove
//#if HAVE_SYS_STAT_H
#include <sys/stat.h>   // stat, mkdir, chmod
//#endif
//#if HAVE_FCNTL_H
#include <fcntl.h>      // open, close
//#endif
#include <map>          // std::map
#include <string>       // std::string
#include <limits>       // std::numeric_limits
#include <sstream>      // std::ostringstream used by ibis::util::logger

#include <float.h>
#include <math.h>       // fabs, floor, ceil, log10, ...
#if !defined(unix) && defined(_WIN32)
#include <windows.h>
#include <io.h>
#include <fcntl.h>      // _O_..
int truncate(const char*, uint32_t);
#include <direct.h>     // _rmdir
#include <sys/stat.h>   // _stat, mkdir, chmod
#define rmdir _rmdir
//#elif HAVE_UNISTD_H
#else
#include <unistd.h>     // read, lseek, truncate, rmdir
#endif

// minimum size for invoking mmap operation, default to 1 MB
#ifndef FASTBIT_MIN_MAP_SIZE
#define FASTBIT_MIN_MAP_SIZE 1048576
#endif

#if ! (defined(HAVE_MMAP) || defined(_MSC_VER))
#  if defined(_XOPEN_SOURCE)
#    define HAVE_MMAP _XOPEN_SOURCE - 0 >= 500
#  elif defined(_POSIX_C_SOURCE)
#    define HAVE_MMAP _POSIX_C_SOURCE - 0 >= 0
#  else
#    define HAVE_MMAP defined(unix)||defined(linux)||defined(__APPLE__)||defined(__CYGWIN__)
#  endif
#endif

#if (HAVE_MMAP+0>0) || (defined(_WIN32) && defined(_MSC_VER))
#define HAVE_FILE_MAP 1
#endif

#ifndef DBL_EPSILON
#define DBL_EPSILON 2.2204460492503131e-16
#else
// some wrongly define it to be 1.1e-16
#undef  DBL_EPSILON
#define DBL_EPSILON 2.2204460492503131e-16
#endif

#ifndef FASTBIT_FLOAT_NULL
#define FASTBIT_FLOAT_NULL std::numeric_limits<float>::quiet_NaN()
#endif
#ifndef FASTBIT_DOUBLE_NULL
#define FASTBIT_DOUBLE_NULL std::numeric_limits<double>::quiet_NaN()
#endif

#if !defined(HAVE_GCC_ATOMIC32) && defined(WITHOUT_FASTBIT_CONFIG_H)
#if __GNUC__+0 >= 4 && !defined(__CYGWIN__) && !defined(__PATHCC__) && !defined(__APPLE__)
#define HAVE_GCC_ATOMIC32 2
#endif
#endif
#if !defined(HAVE_GCC_ATOMIC64) && defined(WITHOUT_FASTBIT_CONFIG_H)
#if defined(__IA64__) || defined(__x86_64__) || defined(__ppc64__)
#if __GNUC__+0 >= 4 && !defined(__CYGWIN__) && !defined(__PATHCC__) && !defined(__APPLE__)
#define HAVE_GCC_ATOMIC64 2
#endif
#endif
#endif

#if defined(_MSC_VER) && defined(_WIN32)
#ifndef HAVE_WIN_ATOMIC32
#if defined(NTDDI_VERSION) && defined(NTDDI_WIN2K)
#if NTDDI_VERSION >= NTDDI_WIN2K
#define HAVE_WIN_ATOMIC32
#endif
#elif defined(WINVER)
#if WINVER >= 0x0500
#define HAVE_WIN_ATOMIC32
#endif
#endif
#endif
#ifndef HAVE_WIN_ATOMIC64
#if defined(NTDDI_VERSION) && defined(NTDDI_WINVISTA)
#if NTDDI_VERSION >= NTDDI_WINVISTA
#define HAVE_WIN_ATOMIC64
#endif
#elif defined(WINVER)
#if WINVER >= 0x0600
#define HAVE_WIN_ATOMIC64
#endif
#endif
#endif
#endif

// mapping the names of the low level IO functions defined in <unistd.h>
#if defined(_MSC_VER) && defined(_WIN32)
#define UnixOpen  ::_open
#define UnixClose ::_close
#define UnixRead  ::_read
#define UnixWrite ::_write
#define UnixSeek  ::_lseek
#define UnixFlush  ::_commit
#define UnixSnprintf ::_snprintf
#define UnixStat  ::_stat
#define UnixFStat ::_fstat
#define Stat_T    struct _stat
#else
#define UnixOpen  ::open
#define UnixClose ::close
#define UnixRead  ::read
#define UnixWrite ::write
#define UnixSeek  ::lseek
#define UnixFlush ::fsync
#define UnixSnprintf ::snprintf
#define UnixStat  ::stat
#define UnixFStat ::fstat
#define Stat_T    struct stat
#endif

// define the option for opening a file in read only mode
#if defined(O_RDONLY)
#if defined(O_LARGEFILE)
#if defined(O_BINARY)
#define OPEN_READONLY O_RDONLY | O_BINARY | O_LARGEFILE
#else
#define OPEN_READONLY O_RDONLY | O_LARGEFILE
#endif
#elif defined(O_BINARY)
#define OPEN_READONLY O_RDONLY | O_BINARY
#else
#define OPEN_READONLY O_RDONLY
#endif
#elif defined(_O_RDONLY)
#if defined(_O_LARGEFILE)
#define OPEN_READONLY _O_RDONLY | _O_LARGEFILE | _O_BINARY
#else
#define OPEN_READONLY _O_RDONLY | _O_BINARY
#endif
#endif
// define the option for opening a new file for writing
#if defined(O_WRONLY)
#if defined(O_LARGEFILE)
#if defined(O_BINARY)
#define OPEN_WRITENEW O_WRONLY | O_BINARY | O_CREAT | O_TRUNC | O_LARGEFILE
#else
#define OPEN_WRITENEW O_WRONLY | O_CREAT | O_TRUNC | O_LARGEFILE
#endif
#elif defined(O_BINARY)
#define OPEN_WRITENEW O_WRONLY | O_BINARY | O_CREAT | O_TRUNC
#else
#define OPEN_WRITENEW O_WRONLY | O_CREAT | O_TRUNC
#endif
#elif defined(_O_WRONLY)
#if defined(_O_LARGEFILE)
#define OPEN_WRITENEW _O_WRONLY|_O_CREAT|_O_TRUNC|_O_LARGEFILE|_O_BINARY
#else
#define OPEN_WRITENEW _O_WRONLY|_O_CREAT|_O_TRUNC|_O_BINARY
#endif
#endif
// define the option for opening an existing file for writing
#if defined(O_WRONLY)
#if defined(O_LARGEFILE)
#if defined(O_BINARY)
#define OPEN_WRITEADD O_WRONLY | O_BINARY | O_CREAT | O_LARGEFILE
#else
#define OPEN_WRITEADD O_WRONLY | O_CREAT| O_LARGEFILE
#endif
#elif defined(O_BINARY)
#define OPEN_WRITEADD O_WRONLY | O_BINARY | O_CREAT
#else
#define OPEN_WRITEADD O_WRONLY | O_CREAT
#endif
#elif defined(_O_WRONLY)
#if defined(_O_LARGEFILE)
#define OPEN_WRITEADD _O_WRONLY | _O_CREAT | _O_LARGEFILE | _O_BINARY
#else
#define OPEN_WRITEADD _O_WRONLY | _O_CREAT | _O_BINARY
#endif
#endif
// define the option for opening a file for reading and writing
#if defined(O_RDWR)
#if defined(O_LARGEFILE)
#if defined(O_BINARY)
#define OPEN_READWRITE O_RDWR | O_BINARY | O_CREAT | O_LARGEFILE
#else
#define OPEN_READWRITE O_RDWR | O_CREAT | O_LARGEFILE
#endif
#elif defined(O_BINARY)
#define OPEN_READWRITE O_RDWR | O_BINARY | O_CREAT
#else
#define OPEN_READWRITE O_RDWR | O_CREAT
#endif
#elif defined(_O_RDWR)
#if defined(_O_LARGEFILE)
#define OPEN_READWRITE _O_RDWR | _O_CREAT | _O_LARGEFILE | _O_BINARY
#else
#define OPEN_READWRITE _O_RDWR | _O_CREAT | _O_BINARY
#endif
#endif
// define the option for opening an existing file for appending only
#if defined(O_WRONLY)
#if defined(O_LARGEFILE)
#if defined(O_BINARY)
#define OPEN_APPENDONLY O_WRONLY | O_BINARY | O_CREAT | O_APPEND | O_LARGEFILE
#else
#define OPEN_APPENDONLY O_WRONLY | O_CREAT | O_APPEND | O_LARGEFILE
#endif
#elif defined(O_BINARY)
#define OPEN_APPENDONLY O_WRONLY | O_BINARY | O_CREAT | O_APPEND
#else
#define OPEN_APPENDONLY O_WRONLY | O_CREAT | O_APPEND
#endif
#elif defined(_O_WRONLY)
#if defined(_O_LARGEFILE)
#define OPEN_APPENDONLY _O_WRONLY | _O_CREAT | _O_APPEND | _O_LARGEFILE | _O_BINARY
#else
#define OPEN_APPENDONLY _O_WRONLY | _O_CREAT | _O_APPEND | _O_BINARY
#endif
#endif
// the default file mode (associate with _O_CREAT)
#if defined(_MSC_VER) && defined(_WIN32)
#define OPEN_FILEMODE _S_IREAD | _S_IWRITE
#elif defined(S_IRGRP) && defined(S_IWGRP) && defined(S_IROTH)
#define OPEN_FILEMODE S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH
#else
#define OPEN_FILEMODE S_IRUSR | S_IWUSR
#endif

#if defined(_WIN32) && defined(_MSC_VER)
// needed for numeric_limits<>::max, min function calls
#ifdef max
#undef max
#endif
#ifdef min
#undef min
#endif
#endif

// The function isfinite is a macro defined in math.h according to
// opengroup.org.  As of 2011, only MS visual studio does not have a
// definition for isfinite, but it has _finite in float,h.
#ifndef isfinite
inline int isfinite(double x) {
#if defined(_MSC_VER) && defined(_WIN32)
    return _finite(x);
#else
    return finite(x);
#endif
}
#endif

#define LOGGER(v) \
if (false == (v)) ; else ibis::util::logger(0)() 
#define IBIS_BLOCK_GUARD \
    ibis::util::guard guard##__LINE__ = ibis::util::makeGuard

namespace std { // extend namespace std slightly
    // specialization of less<> to work with char*
    template <> struct less< char* > {
        bool operator()(const char*x, const char*y) const {
            return strcmp(x, y) < 0;
        }
    };

    // specialization of less<> on const char* (case sensitive comparison)
    template <> struct less< const char* > {
        bool operator()(const char* x, const char* y) const {
            return strcmp(x, y) < 0;
        }
    };

    template <> struct less< ibis::rid_t > {
        bool operator()(const ibis::rid_t& x, const ibis::rid_t& y) const {
            return (x < y);
        }
    };

    template <> struct less< const ibis::rid_t* > {
        bool operator()(const ibis::rid_t* x, const ibis::rid_t* y) const {
            return (*x < *y);
        }
    };
} // namespace std

namespace ibis {
    class resource;     
    class bitvector;    
    class column;       
    class fileManager;  
    class horometer;    
    class index;        
    class roster;       
    class bitvector64;  

    class dictionary;   
    class bundle;       
    class colValues;    

    class fromClause;   
    class whereClause;  
    class selectClause; 


    extern FASTBIT_CXX_DLLSPEC partList datasets;
    ibis::part* findDataset(const char*);

    typedef std::vector<colValues*> colList; 

    FASTBIT_CXX_DLLSPEC ibis::resource& gParameters();

    class FASTBIT_CXX_DLLSPEC nameList {
    public:
        nameList() : cstr(0), buff(0) {};
        nameList(const char* str) : cstr(0), buff(0) {select(str);}
        ~nameList() {if (cstr) clear();}

        bool empty() const {return cstr == 0;}
        const char* operator*() const {return cstr;};
        uint32_t size() const {return cvec.size();};

        void select(const char* str);
        void add(const char* str);
        uint32_t find(const char* key) const;

        const char* operator[](uint32_t i) const {return cvec[i];}
        typedef std::vector< const char* >::const_iterator const_iterator;
        const_iterator begin() const {return cvec.begin();}
        const_iterator end() const {return cvec.end();}

        void clear()
        {cvec.clear(); delete [] cstr; delete [] buff; buff=0; cstr=0;}

    private:
        typedef std::vector< const char * > compStore;
        char* cstr;     // copy of the names as a single string
        char* buff;     // same as cstr, but delimiter is \0
        compStore cvec; // contains pointers to buff, for easier access

        nameList(const nameList&);
        nameList& operator=(const nameList&);
    }; // class nameList

    typedef std::map< const char*, part*, lessi > partAssoc;

    class bad_alloc : public std::bad_alloc {
    public:
        bad_alloc(const char *m="unknown") throw() : mesg_(m) {};
        virtual ~bad_alloc() throw() {}
        virtual const char* what() const throw() {return mesg_;}

    private:
        const char *mesg_;
    }; // bad_alloc

    namespace util {
        extern const char* charTable;
        extern const short unsigned charIndex[];
        extern const char* delimiters;
        extern FASTBIT_CXX_DLLSPEC pthread_mutex_t envLock;

        inline char* trim(char* str);
        char* strnewdup(const char* s);
        char* strnewdup(const char* s, const uint32_t n);
        inline void removeTail(char* str, char tail);
        char* getString(const char* buf);
        const char* getToken(char*& str, const char* tok_chrs);
        int readInt(int64_t& val, const char *&str,
                    const char* del=ibis::util::delimiters);
        int readUInt(uint64_t& val, const char *&str,
                     const char* del=ibis::util::delimiters);
        int readDouble(double& val, const char *&str,
                       const char* del=ibis::util::delimiters);
        FASTBIT_CXX_DLLSPEC int readString(std::string& str, const char*& buf,
                                           const char *delim=0);

        void removeDir(const char* name, bool leaveDir=false);
        int makeDir(const char* dir);
        FASTBIT_CXX_DLLSPEC off_t getFileSize(const char* name);
        int copy(const char* to, const char* from);

        inline void setVerboseLevel(int v) {ibis::gVerbose=v;}
        FASTBIT_CXX_DLLSPEC const char* userName();
        uint32_t serialNumber();
        void uniformFraction(const long unsigned idx,
                             long unsigned &denominator,
                             long unsigned &numerator);
        inline double rand(); 

        FASTBIT_CXX_DLLSPEC uint32_t checksum(const char* str, uint32_t sz);
        inline uint32_t checksum(uint32_t a, uint32_t b);
        inline std::string shortName(const std::string& longname);

        void int2string(std::string &str, unsigned val);
        void int2string(std::string &str, unsigned v1, unsigned v2);
        void int2string(std::string &str, unsigned v1,
                        unsigned v2, unsigned v3);
        void int2string(std::string &str, const std::vector<unsigned>& val);
        void encode64(uint64_t, std::string&);
        int  decode64(uint64_t&, const std::string&);
        int  decode16(uint64_t&, const char*);
        std::string groupby1000(uint64_t);

        double incrDouble(const double&);
        double decrDouble(const double&);
        void   eq2range(const double&, double&, double&);
        inline double coarsen(const double in, unsigned prec=2);
        double compactValue(double left, double right,
                            double start=0.0);

        double compactValue2(double left, double right,
                             double start=0.0);

        void setNaN(double& val);
        void setNaN(float& val);

        template <typename Tin, typename Tout>
        void round_down(const Tin& inval, Tout& outval) {
            outval = ((double)std::numeric_limits<Tout>::min() > inval ?
                      std::numeric_limits<Tout>::min() :
                      (double)std::numeric_limits<Tout>::max() <= inval ?
                      std::numeric_limits<Tout>::max() :
                      static_cast<Tout>(inval));
        }
        template <typename Tin, typename Tout>
        void round_up(const Tin& inval, Tout& outval) {
            outval = ((double)std::numeric_limits<Tout>::min() >= inval ?
                      std::numeric_limits<Tout>::min() :
                      (double) std::numeric_limits<Tout>::max() < inval ?
                      std::numeric_limits<Tout>::max() :
                      static_cast<Tout>(inval) +
                      ((inval-static_cast<Tin>(static_cast<Tout>(inval))) > 0));
        }
        template <typename Tin>
        void round_up(const Tin& inval, float&);
        template <typename Tin>
        void round_up(const Tin& inval, double& outval) {
            outval = static_cast<double>(inval);
        }

        FASTBIT_CXX_DLLSPEC void
        logMessage(const char* event, const char* fmt, ...);
        FASTBIT_CXX_DLLSPEC FILE* getLogFile();
        int writeLogFileHeader(FILE *fptr, const char* fname);
        FASTBIT_CXX_DLLSPEC void closeLogFile();
        FASTBIT_CXX_DLLSPEC int setLogFileName(const char* filename);
        FASTBIT_CXX_DLLSPEC const char* getLogFileName();

        FASTBIT_CXX_DLLSPEC bool strMatch(const char* str, const char* pat);

        const ibis::bitvector64& outerProduct(const ibis::bitvector& a,
                                              const ibis::bitvector& b,
                                              ibis::bitvector64& c);
        const ibis::bitvector64& outerProductUpper(const ibis::bitvector& a,
                                                   const ibis::bitvector& b,
                                                   ibis::bitvector64& c);

        long intersect(const std::vector<ibis::bitvector> &bits1,
                       const std::vector<ibis::bitvector> &bits2,
                       std::vector<ibis::bitvector> &res);
        long intersect(const std::vector<ibis::bitvector> &bits1,
                       const std::vector<ibis::bitvector> &bits2,
                       const std::vector<ibis::bitvector> &bits3,
                       std::vector<ibis::bitvector> &res);
        void clean(std::vector<ibis::bitvector*> &bv) throw();
        void clean(ibis::partList &pl) throw();
        // void clearDatasets(void);
        void updateDatasets(void);

        inline const char* getVersionString() {
            return FASTBIT_STRING;
        }
        inline int getVersionNumber() {
#ifdef FASTBIT_IBIS_INT_VERSION
            return FASTBIT_IBIS_INT_VERSION;
#else
            return 01010000;
#endif
        }

        void getLocalTime(char *str);
        void getGMTime(char *str);
        void secondsToString(const time_t, char *str);


#if defined(WIN32) && ! defined(__CYGWIN__)
        char* getpass_r(const char *prompt, char *buffer, uint32_t buflen);
        char* getpass(const char* prompt);
#else
        inline char *itoa(int value, char *str, int /* radix */) {
            sprintf(str,"%d",value);
            return str;
        }
#endif

        class FASTBIT_CXX_DLLSPEC logger {
        public:
            logger(int blanks=0);
            ~logger();
            std::ostream& operator()(void) {return mybuffer;}

        protected:
            std::ostringstream mybuffer;

        private:
            logger(const logger&);
            logger& operator=(const logger&);
        }; // logger

        class ioLock {
        public:
            ioLock() {
#if defined(PTW32_STATIC_LIB)
                if (mutex == PTHREAD_MUTEX_INITIALIZER) {
                    int ierr = pthread_mutex_init(&mutex, 0);
                    if (ierr != 0)
                        throw "ioLock failed to initialize the necessary mutex";
                }
#endif
                if (0 != pthread_mutex_lock(&mutex))
                    throw "ioLock failed to obtain a lock";
            }
            ~ioLock() {
                (void) pthread_mutex_unlock(&mutex);
            }
        private:
            // every instantiation of this class locks on the same mutex
            static pthread_mutex_t mutex;

            ioLock(const ioLock&) {}; // can not copy
            ioLock& operator=(const ioLock&);
        };

        class mutexLock {
        public:
            mutexLock(pthread_mutex_t* lk, const char* m)
                : mesg(m), lock(lk) {
                LOGGER(ibis::gVerbose > 10)
                    << "util::mutexLock -- acquiring lock (" << lock
                    << ") for " << mesg;
                if (0 != pthread_mutex_lock(lock)) {
                    throw "mutexLock failed to obtain a lock";
                }
            }
            ~mutexLock() {
                LOGGER(ibis::gVerbose > 10)
                    << "util::mutexLock -- releasing lock (" << lock
                    << ") for " << mesg;
                (void) pthread_mutex_unlock(lock);
            }

        private:
            const char *mesg;
            pthread_mutex_t *lock;

            mutexLock() : mesg(0), lock(0) {}; // no default constructor
            mutexLock(const mutexLock&); // can not copy
            mutexLock& operator=(const mutexLock&);
        }; // mutexLock

        class quietLock {
        public:
            quietLock(pthread_mutex_t *lk) : lock(lk) {
                if (0 != pthread_mutex_lock(lock))
                    throw "quietLock failed to obtain a mutex lock";
            }
            ~quietLock() {
                (void) pthread_mutex_unlock(lock);
            }

        private:
            pthread_mutex_t *lock;

            quietLock(); // no default constructor
            quietLock(const quietLock&); // can not copy
            quietLock& operator=(const quietLock&);
        }; // quietLock

        class readLock {
        public:
            readLock(pthread_rwlock_t* lk, const char* m)
                : mesg(m), lock(lk) {
                if (0 != pthread_rwlock_rdlock(lock)) {
                    throw "readLock failed to obtain a lock";
                }
            }
            ~readLock() {
                (void) pthread_rwlock_unlock(lock);
            }

        private:
            const char *mesg;
            pthread_rwlock_t *lock;

            readLock() : mesg(0), lock(0) {}; // no default constructor
            readLock(const readLock&); // can not copy
            readLock& operator=(const readLock&);
        }; // readLock

        class writeLock {
        public:
            writeLock(pthread_rwlock_t* lk, const char* m)
                : mesg(m), lock(lk) {
                if (0 != pthread_rwlock_wrlock(lock)) {
                    throw "writeLock failed to obtain a lock";
                }
            }
            ~writeLock() {
                int ierr = pthread_rwlock_unlock(lock);
                if (ierr != 0) {
                    throw "writeLock failed to release the lock";
                }
            }

        private:
            const char *mesg;
            pthread_rwlock_t *lock;

            writeLock() : mesg(0), lock(0) {}; // no default constructor
            writeLock(const writeLock&); // can not copy
            writeLock& operator=(const writeLock&);
        }; // writeLock

        class FASTBIT_CXX_DLLSPEC counter {
        public:
            ~counter() {
#if defined(HAVE_GCC_ATOMIC32)
#elif defined(HAVE_WIN_ATOMIC32)
#else
                (void)pthread_mutex_destroy(&lock_);
#endif
            }
            counter() : count_(0) {
#if defined(HAVE_GCC_ATOMIC32)
#elif defined(HAVE_WIN_ATOMIC32)
#else
                if (0 != pthread_mutex_init(&lock_, 0))
                    throw ibis::bad_alloc
                        ("util::counter failed to initialize mutex lock");
#endif
            }

            uint32_t operator()() {
#if defined(HAVE_GCC_ATOMIC32)
                return __sync_fetch_and_add(&count_, 1);
#elif defined(HAVE_WIN_ATOMIC32)
                return InterlockedIncrement((volatile long *)&count_)-1;
#else
                ibis::util::quietLock lck(&lock_);
                uint32_t ret = count_;
                ++ count_;
                return ret;
#endif
            }
            void reset() {
#if defined(HAVE_GCC_ATOMIC32)
                (void) __sync_fetch_and_sub(&count_, count_);
#elif defined(HAVE_WIN_ATOMIC32)
                (void) InterlockedExchange((volatile long *)&count_, 0);
#else
                ibis::util::quietLock lck(&lock_);
                count_ = 0;
#endif
            }
            uint32_t value() const {
                return count_;
            }

        private:
#if defined(HAVE_GCC_ATOMIC32)
#elif defined(HAVE_WIN_ATOMIC32)
#else
            mutable pthread_mutex_t lock_; 
#endif
            volatile uint32_t count_; 

            counter(const counter&);
            counter& operator=(const counter&);
        }; // counter

        class FASTBIT_CXX_DLLSPEC sharedInt32 {
        public:
            sharedInt32() : val_(0) {
#if defined(HAVE_GCC_ATOMIC32)
#elif defined(HAVE_WIN_ATOMIC32)
#else
                if (pthread_mutex_init(&mytex, 0) != 0)
                    throw "pthread_mutex_init failed for sharedInt";
#endif
            }

            ~sharedInt32() {
#if defined(HAVE_GCC_ATOMIC32)
#elif defined(HAVE_WIN_ATOMIC32)
#else
                (void)pthread_mutex_destroy(&mytex);
#endif
            }

            uint32_t operator()() const {return val_;}

            uint32_t operator++() {
#if defined(HAVE_GCC_ATOMIC32)
                return __sync_add_and_fetch(&val_, 1);
#elif defined(HAVE_WIN_ATOMIC32)
                return InterlockedIncrement((volatile long *)&val_);
#else
                ibis::util::quietLock lock(&mytex);
                ++ val_;
                return val_;
#endif
            }

            uint32_t operator--() {
#if defined(HAVE_GCC_ATOMIC32)
                return __sync_add_and_fetch(&val_, -1);
#elif defined(HAVE_WIN_ATOMIC32)
                return InterlockedDecrement((volatile long *)&val_);
#else
                ibis::util::quietLock lock(&mytex);
                -- val_;
                return val_;
#endif
            }

            void operator+=(const uint32_t rhs) {
#if defined(HAVE_GCC_ATOMIC32)
                (void) __sync_add_and_fetch(&val_, rhs);
#elif defined(HAVE_WIN_ATOMIC32)
                (void) InterlockedExchangeAdd((volatile long *)&val_, rhs);
#else
                ibis::util::quietLock lock(&mytex);
                val_ += rhs;
#endif
            }

            void operator-=(const uint32_t rhs) {
#if defined(HAVE_GCC_ATOMIC32)
                (void) __sync_sub_and_fetch(&val_, rhs);
#elif defined(HAVE_WIN_ATOMIC32)
                (void) InterlockedExchangeAdd((volatile long *)&val_,
                                              -(long)rhs);
#else
                ibis::util::quietLock lock(&mytex);
                val_ -= rhs;
#endif
            }

            void swap(sharedInt32 &rhs) {
                uint32_t tmp = rhs.val_;
                rhs.val_ = val_;
                val_ = tmp;
            }

        private:
            uint32_t volatile val_; 
#if defined(HAVE_GCC_ATOMIC32)
#elif defined(HAVE_WIN_ATOMIC32)
#else
            pthread_mutex_t mytex; 
#endif

            sharedInt32(const sharedInt32&); // no copy constructor
            sharedInt32& operator=(const sharedInt32&); // no assignment
        }; // sharedInt32

        class sharedInt64 {
        public:
            sharedInt64() : val_(0) {
#if defined(HAVE_GCC_ATOMIC64)
#elif defined(HAVE_WIN_ATOMIC64)
#else
                if (pthread_mutex_init(&mytex, 0) != 0)
                    throw "pthread_mutex_init failed for sharedInt";
#endif
            }

            ~sharedInt64() {
#if defined(HAVE_GCC_ATOMIC64)
#elif defined(HAVE_WIN_ATOMIC64)
#else
                (void)pthread_mutex_destroy(&mytex);
#endif
            }

            uint64_t operator()() const {return val_;}

            uint64_t operator++() {
#if defined(HAVE_GCC_ATOMIC64)
                return __sync_add_and_fetch(&val_, 1);
#elif defined(HAVE_WIN_ATOMIC64)
                return InterlockedIncrement64((volatile LONGLONG *)&val_);
#else
                ibis::util::quietLock lock(&mytex);
                ++ val_;
                return val_;
#endif
            }

            uint64_t operator--() {
#if defined(HAVE_GCC_ATOMIC64)
                return __sync_add_and_fetch(&val_, -1);
#elif defined(HAVE_WIN_ATOMIC64)
                return InterlockedDecrement64((volatile LONGLONG *)&val_);
#else
                ibis::util::quietLock lock(&mytex);
                -- val_;
                return val_;
#endif
            }

            void operator+=(const uint64_t rhs) {
#if defined(HAVE_GCC_ATOMIC64)
                (void) __sync_add_and_fetch(&val_, rhs);
#elif defined(HAVE_WIN_ATOMIC64)
                (void) InterlockedExchangeAdd64((volatile LONGLONG *)&val_,
                                                rhs);
#else
                ibis::util::quietLock lock(&mytex);
                val_ += rhs;
#endif
            }

            void operator-=(const uint64_t rhs) {
#if defined(HAVE_GCC_ATOMIC64)
                (void) __sync_sub_and_fetch(&val_, rhs);
#elif defined(HAVE_WIN_ATOMIC64)
                (void) InterlockedExchangeAdd64((volatile LONGLONG *)&val_,
                                                -(long)rhs);
#else
                ibis::util::quietLock lock(&mytex);
                val_ -= rhs;
#endif
            }

            void swap(sharedInt64 &rhs) {
                uint64_t tmp = rhs.val_;
                rhs.val_ = val_;
                val_ = tmp;
            }

        private:
            uint64_t volatile val_; 
#if defined(HAVE_GCC_ATOMIC64)
#elif defined(HAVE_WIN_ATOMIC64)
#else
            pthread_mutex_t mytex; 
#endif

            sharedInt64(const sharedInt64&); // no copy constructor
            sharedInt64& operator=(const sharedInt64&); // no assignment
        }; // sharedInt64

        class timer {
        public:
            explicit timer(const char* msg, int lvl=1);
            ~timer();

        private:
            ibis::horometer *chrono_; 
            std::string mesg_; 

            timer(); // no default constructor
            timer(const timer&); // no copying
            timer& operator=(const timer&); // no assignment
        }; // timer

        template <class T> class refHolder {
        public:
            refHolder(T& r) : ref_(r) {}
            operator T& () const {return ref_;}

        private:
            T& ref_;

            refHolder();
        }; // refHolder

        template <class T>
        inline refHolder<T> ref(T& r) {return refHolder<T>(r);}

        class guardBase {
        public:
            void dismiss() const {done_ = true;}

        protected:
            mutable volatile bool done_;

            ~guardBase() {};
            guardBase() : done_(false) {}; 


            guardBase(const guardBase& rhs) : done_(rhs.done_) {
                rhs.dismiss();
            }

            template <typename T>
            static void cleanup(T& task) throw () {
                try {
                    if (!task.done_)
                        task.execute();
                }
                catch (const std::exception& e) {
                    LOGGER(ibis::gVerbose > 1)
                        << " ... caught a std::exception (" << e.what()
                        << ") in util::gard";
                }
                catch (const char* s) {
                    LOGGER(ibis::gVerbose > 1)
                        << " ... caught a string exception (" << s
                        << ") in util::guard";
                }
                catch (...) {
                    LOGGER(ibis::gVerbose > 1)
                        << " ... caught a unknown exception in util::guard";
                }
                task.done_ = true;
            }
        }; // guardBase

        typedef const guardBase& guard;

        template <typename F>
        class guardImpl0 : public guardBase {
        public:
            static guardImpl0<F> makeGuard(F f) {
                return guardImpl0<F>(f);
            }

            ~guardImpl0() {cleanup(*this);}

        protected:
            friend class guardBase; // to call function execute
            void execute() {fun_();}

            explicit guardImpl0(F f) : fun_(f) {}

        private:
            F fun_;

            guardImpl0();
            guardImpl0& operator=(const guardImpl0&);
        }; // guardImpl0

        template <typename F>
        inline guardImpl0<F> makeGuard(F f) {
            return guardImpl0<F>::makeGuard(f);
        }

        template <typename F, typename A>
        class guardImpl1 : public guardBase {
        public:
            static guardImpl1<F, A> makeGuard(F f, A a) {
                return guardImpl1<F, A>(f, a);
            }

            ~guardImpl1() {cleanup(*this);}

        protected:
            friend class guardBase; // to call function execute
            void execute() {fun_(arg_);}

            explicit guardImpl1(F f, A a) : fun_(f), arg_(a) {}

        private:
            F fun_;
            A arg_;

            guardImpl1();
            guardImpl1& operator=(const guardImpl1&);
        }; // guardImpl1

        template <typename F, typename A>
        inline guardImpl1<F, A> makeGuard(F f, A a) {
            return guardImpl1<F, A>::makeGuard(f, a);
        }

        template <typename F, typename A1, typename A2>
        class guardImpl2 : public guardBase {
        public:
            static guardImpl2<F, A1, A2> makeGuard(F f, A1 a1, A2 a2) {
                return guardImpl2<F, A1, A2>(f, a1, a2);
            }

            ~guardImpl2() {cleanup(*this);}

        protected:
            friend class guardBase; // to call function execute
            void execute() {fun_(arg1_, arg2_);}

            explicit guardImpl2(F f, A1 a1, A2 a2)
                : fun_(f), arg1_(a1), arg2_(a2) {}

        private:
            F fun_;
            A1 arg1_;
            A2 arg2_;

            guardImpl2();
            //guardImpl2(const guardImpl2&);
            guardImpl2& operator=(const guardImpl2&);
        }; // guardImpl2

        template <typename F, typename A1, typename A2>
        inline guardImpl2<F, A1, A2> makeGuard(F f, A1 a1, A2 a2) {
            return guardImpl2<F, A1, A2>::makeGuard(f, a1, a2);
        }

        template <class C, typename F>
        class guardObj0 : public guardBase {
        public:
            static guardObj0<C, F> makeGuard(C& o, F f) {
                return guardObj0<C, F>(o, f);
            }

            ~guardObj0() {cleanup(*this);}

        protected:
            friend class guardBase; // to call function execute
            void execute() {(obj_.*fun_)();}

            guardObj0(C& o, F f) : obj_(o), fun_(f) {}

        private:
            C& obj_; 
            F fun_;  

            guardObj0();
            guardObj0& operator=(const guardObj0&);
        }; // guardObj0

        template <class C, typename F>
        inline guardObj0<C, F> objectGuard(C o, F f) {
            return guardObj0<C, F>::makeGuard(o, f);
        }
    } // namespace util
} // namespace ibis

#if defined(WIN32) && ! defined(__CYGWIN__)
char* getpass(const char* prompt);
#endif

inline double ibis::util::rand() {
    static uint32_t seed = 1;
    static const uint32_t alpha = 69069;
    static const double scale = ::pow(0.5, 32);
    seed = static_cast<uint32_t>(seed * alpha);
    return(scale * seed);
} // ibis::util::rand

inline uint32_t ibis::util::checksum(uint32_t a, uint32_t b) {
    uint32_t a0 = (a >> 16);
    uint32_t a1 = (a & 0xFFFF);
    uint32_t b0 = (b >> 16);
    uint32_t b1 = (b & 0xFFFF);
    return ((((a0<<2)+a1*3+(b0<<1)+b1) << 16) | ((a0+a1+b0+b1) & 0xFFFF));
} // ibis::util::checksum

inline double ibis::util::incrDouble(const double& in) {
#if defined(HAVE_NEXTAFTER)
    return nextafter(in, DBL_MAX);
#elif defined(_MSC_VER) && defined(_WIN32)
    return _nextafter(in, DBL_MAX);
#else
    double tmp = fabs(in) * DBL_EPSILON;
    if (tmp > 0.0) tmp += in;
    else tmp = in + DBL_MIN;
    return tmp;
#endif
}

inline double ibis::util::decrDouble(const double& in) {
#if defined(HAVE_NEXTAFTER)
    return nextafter(in, -DBL_MAX);
#elif defined(_MSC_VER) && defined(_WIN32)
    return _nextafter(in, -DBL_MAX);
#else
    double tmp = fabs(in) * DBL_EPSILON;
    if (tmp > 0.0) tmp = in - tmp;
    else tmp = in - DBL_MIN;
    return tmp;
#endif
}

inline void ibis::util::eq2range(const double& in,
                                 double& left, double& right) {
#if defined(HAVE_NEXTAFTER)
    right = nextafter(in, DBL_MAX);
#elif defined(_MSC_VER) && defined(_WIN32)
    right = _nextafter(in, DBL_MAX);
#else
    double tmp = fabs(in) * DBL_EPSILON;
    if (tmp > 0.0) {right = in + tmp;}
    else {right = in + DBL_MIN;}
#endif
    left = in;
} // ibis::util::eq2range

template <typename Tin>
inline void ibis::util::round_up(const Tin& inval, float& outval) {
    // perform the initial rounding
    outval = static_cast<float>(inval);
    if (static_cast<Tin>(outval) < inval) {
        // if the rounded value is less than the input value, compute the
        // next value
#if defined(HAVE_NEXTAFTER)
        outval = nextafterf(static_cast<float>(inval), FLT_MAX);
#else
        float tmp = fabsf(outval) * FLT_EPSILON;
        if (tmp > 0.0) outval += tmp;
        else outval += FLT_MIN;
#endif
    }
} // ibis::util::round_up

// remove all the trailing char 'tail'
inline void ibis::util::removeTail(char* str, char tail) {
    if (str != 0 && *str != 0) {
        char *tmp = str;
        while (*tmp != 0) ++ tmp;
        -- tmp;
        while (tmp > str && *tmp == tail) {
            *tmp = static_cast<char>(0);
            -- tmp;
        }
    }
} // ibis::util::removeTail

// remove the leading and trailing space of the incoming string
inline char* ibis::util::trim(char* str) {
    char* head = 0;
    if (str == 0) return head;
    if (*str == 0) return head;

    head = str;
    while (*head) {
        if (std::isspace(*head))
            ++ head;
        else
            break;
    }
    if (*head == 0)
        return head;

    for (str = head; *str != 0; ++ str);
    -- str;
    while (str >= head && std::isspace(*str)) {
        *str = static_cast<char>(0);
        -- str;
    }
    return head;
} // ibis::util::trim

inline double ibis::util::coarsen(const double in, unsigned prec) {
    double ret;
    if (prec > 15) {
        ret = in;
    }
    else if (in == 0.0) {
        ret = in;
    }
    else {
        ret = fabs(in);
        if (ret < DBL_MIN) { // denormalized number --> 0
            ret = 0.0;
        }
        else if (ret < DBL_MAX) { // normal numbers
            ret = log10(ret);
            if (prec > 0)
                -- prec;
            const int ixp = static_cast<int>(floor(ret)) -
                static_cast<int>(prec);
            ret = floor(0.5 + pow(1e1, ret-ixp));
            if (ixp > 0)
                ret *= pow(1e1, ixp);
            else if (ixp < 0)
                ret /= pow(1e1, -ixp);
            if (in < 0.0)
                ret = -ret;
        }
        else {
            ret = in;
        }
    }
    return ret;
} // ibis::util::coarsen

inline std::string ibis::util::shortName(const std::string& de) {
    std::string tn;
    uint32_t tmp = ibis::util::checksum(de.c_str(), de.size());
    ibis::util::int2string(tn, tmp);
    std::swap(tn[0], tn[5]);
    if (! isalpha(tn[0]))
        tn[0] = 'A' + (tn[0] % 26);
    return tn;
} // ibis::util::shortName

inline std::ostream& operator<<(std::ostream& out, const ibis::rid_t& rid) {
    out << '(' << rid.num.run << ", " << rid.num.event << ')';
    return out;
}

inline std::istream& operator>>(std::istream& is, ibis::rid_t& rid) {
    char c = 0;
    is >> c;
    if (c == '(') { // (runNumber, EventNumber)
        is >> rid.num.run >> c;
        if (c == ',')
            is >> rid.num.event >> c;
        else
            rid.num.event = 0;
        if (c != ')')
            is.clear(std::ios::badbit); // forget the erro
    }
    else { // runNumber, EventNumber
        is.putback(c);
        is >> rid.num.run >> c;
        if (c != ',') // assume space separator
            is.putback(c);
        is >> rid.num.event;
    }
    return is;
}
#endif // IBIS_UTIL_H