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>
#include <list>

namespace Arc {

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

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

  std::list<std::string> GetEnv();

  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 (*deleter)(T*);
    static void DefaultDeleter(T* o) { delete o; }
    void operator=(const AutoPointer<T>&);
#if __cplusplus >= 201103L
  private:
    AutoPointer(AutoPointer<T> const&);
#else
  // Workaround for older gcc which does not implement construction
  // of new elements in std::list according to specification.
  public: 
    AutoPointer(AutoPointer<T> const& o)
      : object(NULL), deleter(&DefaultDeleter) {
      operator=(const_cast<AutoPointer<T>&>(o));
    }
#endif
  public:
    AutoPointer(void (*d)(T*) = &DefaultDeleter)
      : object(NULL), deleter(d) {}
    AutoPointer(T *o, void (*d)(T*) = &DefaultDeleter)
      : object(o), deleter(d) {}
    AutoPointer(AutoPointer<T>& o)
      : object(o.Release()), deleter(o.deleter) {}
    ~AutoPointer(void) {
      if (object) if(deleter) (*deleter)(object);
      object = NULL;
    }
    AutoPointer<T>& operator=(T* o) {
      if (object) if(deleter) (*deleter)(object);
      object = o; 
      return *this;
    }
    AutoPointer<T>& operator=(AutoPointer<T>& o) {
      if (object) if(deleter) (*deleter)(object);
      object = o.object; 
      o.object = NULL;
      return *this;
    }
    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& operator[](int pos) {
      return object[pos];
    }
    T const& operator[](int pos) const {
      return object[pos];
    }
    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__