// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file tools.license for terms.

#ifndef tools_handle
#define tools_handle

#include <string>

namespace tools {

class base_handle {
  static const std::string& s_class() {
    static const std::string s_v("tools::handle");
    return s_v;
  }
public:
  virtual void* object() const = 0;
  virtual base_handle* copy() = 0; //can't be const.
  virtual void disown() = 0;
public:
  base_handle(){
  }
  base_handle(const std::string& a_class):m_class(a_class){
  }
  virtual ~base_handle(){
  }
protected:
  base_handle(base_handle& a_from):m_class(a_from.m_class){
  }
private:
  base_handle& operator=(base_handle& a_from){
    m_class = a_from.m_class;
    return *this;
  }
public:
  const std::string& object_class() const {return m_class;}
private:
  std::string m_class;
};

template <class T>
class handle : public base_handle {
  typedef base_handle parent;
public:
  virtual void* object() const {return m_obj;}
  virtual base_handle* copy() {return new handle<T>(*this);}
  virtual void disown() {m_owner = false;}
public:
  handle(T* a_obj,bool a_owner = true):parent(),m_obj(a_obj),m_owner(a_owner){}
  handle(const std::string& a_class,T* a_obj,bool a_owner = true):parent(a_class),m_obj(a_obj),m_owner(a_owner){}
  virtual ~handle(){if(m_owner) delete m_obj;}
private:
  handle(handle& a_from):parent(a_from){
    m_obj = a_from.m_obj;
    if(a_from.m_owner) {
      // this take ownership.
      m_owner = true;
      a_from.m_owner = false;
    } else {
      m_owner = false;
    }
  }
private:
  // in principle the below are not used.
  //handle(const handle& a_from){}
  //handle& operator=(const handle&){return *this;}
  handle& operator=(handle&){return *this;}
protected:
  T* m_obj;
  bool m_owner;
};

}

#endif