Utils.h

// -*- indent-tabs-mode: nil -*-

#ifndef __ARC_UTILS_H__
#define __ARC_UTILS_H__

#include <cstdlib>
// NOTE: On Solaris errno is not working properly if cerrno is included first
#include <cerrno>
#include <string>

namespace Arc {


  std::string GetEnv(const std::string& var);

  std::string GetEnv(const std::string& var, bool &found);

  bool SetEnv(const std::string& var, const std::string& value, bool overwrite = true);

  void UnsetEnv(const std::string& var);

  // These are functions to be used used exclusively for solving
  // problem with specific libraries which depend too much on
  // environment variables.

  void EnvLockAcquire(void);

  void EnvLockRelease(void);

  void EnvLockWrap(bool all = false);

  void EnvLockUnwrap(bool all = false);

  void EnvLockUnwrapComplete(void);


  class EnvLockWrapper {
   private:
    bool all_;
   public:

    EnvLockWrapper(bool all = false):all_(all) { EnvLockWrap(all_); };
    ~EnvLockWrapper(void) { EnvLockUnwrap(all_); };
  };


  class InterruptGuard {
  public:
    InterruptGuard();
    ~InterruptGuard();
  private:
    void (*saved_sigint_handler)(int);
  };

  std::string StrError(int errnum = errno);


  template<typename T>
  class AutoPointer {
  private:
    T *object;
    void operator=(const AutoPointer<T>&) {}
    AutoPointer(const AutoPointer&) : object(NULL) {}
  public:
    AutoPointer(void)
      : object(NULL) {}
    AutoPointer(T *o)
      : object(o) {}
    ~AutoPointer(void) {
      if (object) delete object;
    }
    void operator=(T* o) {
      if (object) delete object;
      object = o; 
    }
    T& operator*(void) const {
      return *object;
    }
    T* operator->(void) const {
      return object;
    }
    operator bool(void) const {
      return (object != NULL);
    }
    bool operator!(void) const {
      return (object == NULL);
    }
    T* Ptr(void) const {
      return object;
    }
    T* Release(void) {
      T* tmp = object;
      object = NULL;
      return tmp;
    }
  };


  template<typename T>
  class CountedPointer {
  private:
    template<typename P>
    class Base {
    private:
      Base(Base<P>&);
    public:
      int cnt;
      P *ptr;
      bool released;
      Base(P *p)
        : cnt(0),
          ptr(p),
          released(false) {
        add();
      }
      ~Base(void) {
        if (ptr && !released)
          delete ptr;
      }
      Base<P>* add(void) {
        ++cnt;
        return this;
      }
      bool rem(void) {
        if (--cnt == 0) {
          if(!released) delete this;
          return true;
        }
        return false;
      }
    };
    Base<T> *object;
  public:
    CountedPointer(T *p = NULL)
      : object(new Base<T>(p)) {}
    CountedPointer(const CountedPointer<T>& p)
      : object(p.object->add()) {}
    ~CountedPointer(void) {
      object->rem();
    }
    CountedPointer<T>& operator=(T *p) {
      if (p != object->ptr) {
        object->rem();
        object = new Base<T>(p);
      }
      return *this;
    }
    CountedPointer<T>& operator=(const CountedPointer<T>& p) {
      if (p.object->ptr != object->ptr) {
        object->rem();
        object = p.object->add();
      }
      return *this;
    }
    T& operator*(void) const {
      return *(object->ptr);
    }
    T* operator->(void) const {
      return (object->ptr);
    }
    operator bool(void) const {
      return ((object->ptr) != NULL);
    }
    bool operator!(void) const {
      return ((object->ptr) == NULL);
    }
    bool operator==(const CountedPointer& p) const {
      return ((object->ptr) == (p.object->ptr));
    }
    bool operator!=(const CountedPointer& p) const {
      return ((object->ptr) != (p.object->ptr));
    }
    bool operator<(const CountedPointer& p) const {
      return ((object->ptr) < (p.object->ptr));
    }
    T* Ptr(void) const {
      return (object->ptr);
    }
    T* Release(void) {
      T* tmp = object->ptr;
      object->released = true;
      return tmp;
    }
  };

  bool PersistentLibraryInit(const std::string& name);

} // namespace Arc

# endif // __ARC_UTILS_H__