/* Copyright 2005 Chris Thomasson */


#if ! defined(__cplusplus)
  #include "refcount.h"
#elif ! defined(REFCOUNT_HPP_INCLUDED)
#define REFCOUNT_HPP_INCLUDED
#if defined(_MSC_VER)
  #pragma warning(disable : 4505 4514)
#endif
#include "refcount-sys.hpp"




namespace vzsync {
  static void libinit();
  
  
namespace ptr {
  template<typename T> class global;
  template<typename T> class local;


  namespace prv {
    template<typename T> class base;
    template<typename T> class weak_base;


    template<typename T>
    class base : public sys::refcount::ptr_base<T> {
    public:
      typedef global<T> global_t;
      typedef local<T> local_t;

    public:
      base() throw() {}
      base(T *state, int count) 
       : sys::refcount::ptr_base<T>(state, count) {}
      ~base() throw() {}
    };


    template<typename T>
    class weak_base : public base<T> {
    public:
      weak_base() throw() {}
      weak_base(T *state, int count) : base<T>(state, count) {}
      ~weak_base() throw() {}

    public:
      inline T const* operator ->() const { return base<T>::load_ptr(); }
      inline T* operator ->() { return base<T>::load_ptr(); }
      inline T const& operator *() const { return base<T>::load_ref(); }
      inline T& operator *() { return base<T>::load_ref(); }
    };
  }


  template<typename T>
  class global : public prv::base<T> {
  public:
    global() throw() {}
    global(T *state, int count = 1) : prv::base<T>(state, count) {}
    ~global() throw() {}

  public:
    global(global const &rhs) throw() {
      global_copy_global(rhs, 1);
    }

    global(typename prv::base<T>::local_t const &rhs) throw() {
      global_copy_local(rhs, 1);
    }

  public:
    global const& operator =(global const &rhs) throw() {
      global_set_global(rhs, 1);
      return *this;
    }

    global const& operator =(typename prv::base<T>::local_t const &rhs) throw() {
      global_set_local(rhs, 1);
      return *this;
    }
  };


  template<typename T>
  class local : public prv::weak_base<T> {
  public:
    local() throw() {}
    local(T *state, int count = 1) : prv::weak_base<T>(state, count) {}
    ~local() throw() {}

  public:
    local(local const &rhs) throw() {
      local_copy_local(rhs, 1);
    }

    local(typename prv::base<T>::global_t const &rhs) throw() {
      local_copy_global(rhs, 1);
    }

  public:
    local const& operator =(local const &rhs) throw() {
      local_set_local(rhs, 1);
      return *this;
    }

    local const& operator =(typename prv::base<T>::global_t const &rhs) throw() {
      local_set_global(rhs, 1);
      return *this;
    }
  };
}


  void libinit() { sys::refcount::libinit(); }


} // namespace vzsync::ptr




#endif