Shared.hpp

// Copyright © 2015 GEOSYSTEMS SRL
// All Rights Reserved.

#ifndef FIRE_SHARED_SHARED_HPP_INCLUDED
#define FIRE_SHARED_SHARED_HPP_INCLUDED

#include <boost/shared_ptr.hpp>

#include <exception>

#include <stdexcept>

namespace fire {
namespace shared {

template < class T >
class Shared {
 public:
  Shared(): _ptr() {
  }

  explicit Shared(T* ptr): _ptr(ptr) {
  }

  Shared(Shared const & c) {
        this->operator =(c);
  }

  inline Shared& operator=(Shared const & c) {
        _ptr = c._ptr;
        return *this;
  }

  inline bool operator!() const {
        return (NULL == _ptr);
  }

  inline bool operator==(Shared const & r) const {
        return (_ptr.get() == r._ptr.get());
  }

  inline bool operator==(int const &) const {
        return this->operator !();
  }

  inline bool operator!=(Shared const & r) const {
        return !(this->operator==(r));
  }

  inline bool operator!=(int const & r) const {
        return !(this->operator==(r));
  }

  inline T& operator*() {
        return this->operator T &();
  }

  inline const T& operator*() const {
        return this->operator const T &();
  }

  // operatori di cast, pericoloso abilitarli per tutti i tipi shared
  inline operator T &() {
      return *_ptr;
  }

  inline operator const T &() const {
      return *_ptr;
  }

 protected:
  boost::shared_ptr< T > _ptr;

  virtual inline T* _getPtr() {
      T* ret = _ptr.get();
      if (NULL == ret)
          throw std::runtime_error("Invalid pointer");

      return ret;
  }

  virtual inline const T* _getPtr() const {
    const T* ret = _ptr.get();
    if (NULL == ret)
        throw std::runtime_error("Invalid pointer");

    return ret;
  }
};

template<class T>
    inline bool operator==(int const & nullPtr, Shared< T > const & r) {
        return r.operator==(nullPtr);
    }

template<class T>
    inline bool operator!=(int const & nullPtr, Shared< T > const & r) {
        return r.operator!=(nullPtr);
    }

}  // namespace shared
}  // namespace fire

#endif