tools.h

Go to the documentation of this file.

// Copyright (C) 2006 Ivo Nowak and Stefan Vigerske
// All Rights Reserved.
// This code is published under the Common Public License.
//
// Author: Ivo Nowak, Stefan Vigerske

// tools

#ifndef TOOLS_H
#define TOOLS_H

#include <sys/resource.h> // for Timer-class
//#include <time.h>
#include <cassert>

// IO
#include <iomanip>
#include <iostream>
#include <fstream>

// data structures
#include <vector>
#include <map>
#include <list>
#include <set>

using namespace std;

#define rtol 1e-10          // 1e-12 tolerance of real numbers

#ifndef MIN
#define MIN(a,b) ((a) <= (b) ? (a) : (b))
#endif
#ifndef MAX
#define MAX(a,b) ((a) >= (b) ? (a) : (b))
#endif

// simply used as a really large number
#ifdef INFINITY
#undef INFINITY
#endif
#define INFINITY 1e99

// similarly for integers
#define INF 65535

extern map<const void*, int> refcount;

extern void print_all_Pointer(ostream& out);

template <class Type> class Pointer {
  public:
    static int count(const Type* obj_) {
      map<const void*, int>::iterator p(refcount.find((const void*)obj_));
      if (p==refcount.end()) return 0;
      return p->second;
    }

  private:
    Type* obj;

    void inc_count() {
      pair<map<const void*, int>::iterator, bool> p(refcount.insert(pair<const void*, int>(obj, 1)));
      if (!p.second) p.first->second++;  // obj existed before
    }

    int dec_count() {
      map<const void*, int>::iterator p(refcount.find(obj));
#ifndef NO_NULLPOINTER_CHECK
      assert(p!=refcount.end());
#endif
      int ret=--p->second;
      if (!ret) refcount.erase(p);
      return ret;
    }

    bool delete_obj;

  public:


    Pointer()
    : obj(NULL), delete_obj(true)
    { }

    Pointer(Type* obj_, bool del_=true)
    : obj(obj_), delete_obj(del_)
    { if (obj && delete_obj) inc_count();
    }

    Pointer(const Pointer<Type>& p)
    : obj(p.obj), delete_obj(p.delete_obj)
    { if (obj && delete_obj) inc_count();
    }

    ~Pointer() {
      if (obj && delete_obj && (!dec_count())) delete obj;
    }

    Pointer<Type>& operator=(const Pointer<Type>& p) {
      if (obj==p.obj) return *this;
      if (obj && delete_obj && (!dec_count())) delete obj;
      obj=p.obj; delete_obj=p.delete_obj;
      if (obj) inc_count();
      return *this;
    }

    Pointer<Type>& operator=(Type* obj_) {
      if (obj==obj_) return *this;
      if (obj && delete_obj && (!dec_count())) delete obj;
      if (obj=obj_) inc_count();
      delete_obj=true;
      return *this;
    }

    operator Type*() const { return obj; }

//    operator const Type*() const { return (const Type*)obj; }

//    operator bool() const { return (bool)obj; }

    Type& operator*() const {
#ifndef NO_NULLPOINTER_CHECK
      assert(obj);
#endif
      return *obj;
    }

    Type* operator->() const {
#ifndef NO_NULLPOINTER_CHECK
      assert(obj);
#endif
      return obj;
    }

/*    bool operator==(const Type* obj_) const {
      return (obj==obj_);
    }
*/
    bool operator!=(const Type* obj_) const {
      return (obj!=obj_);
    }

    int count() const {
      return Pointer<Type>::count(obj);
    }

};

extern Pointer<ostream> out_out_p;  // defined in tools.cc
#define out_out if (out_out_p) (*out_out_p)

extern Pointer<ostream> out_log_p;  // defined in tools.cc
#define out_log if (out_log_p) (*out_log_p)

extern Pointer<ostream> out_err_p;  // defined in tools.cc
#define out_err if (out_err_p) (*out_err_p)

extern int random(int lb, int ub);

extern double random(double lb, double ub);

//extern int init_random();

class Timer {
  friend ostream& operator<<(ostream& out, Timer& w) {
                print(out, (double)w);
//    w.print(out);
    return out;
  }

  private:
    struct timeval starttime;
    struct timeval endtime;

//              clock_t starttime;
//              clock_t endtime;

  public:
    Timer() {
      start();
    }

    void start();

    Timer& stop();

    operator double() const;

                static void print(ostream& out, double time);
//    void print(ostream& out) const;

};


unsigned int get_mem();

int start_process(const char* name, char*const* const args, int timelimit=0, const char* envvarname=NULL, const char* envvarvalue=NULL);

#endif // TOOLS_H

---