/* -*- C++ -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library

 *

 * Copyright (C) 2003-2007

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Research Group on Combinatorial Optimization, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

 * provided that this copyright notice appears in all copies. For

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

#ifndef LEMON_REFPTR_H

#define LEMON_REFPTR_H

///\ingroup misc

///\file

///\brief A reference counted pointer implementation.

///

///\todo Undocumented

namespace lemon {

  ///Reference counted pointer

  ///This is a simple implementation of a reference counted pointer.

  ///

  ///\warning Current implementation is far from being thread-safe.

  template<class T>

  class RefPtr 

  {

    mutable RefPtr *prev, *next;

    T *ref;

    void lock() {}

    void unlock() {}

    void attach(RefPtr &r) 

    {

      if(r.ref) {

	prev=&r; next=r.next; ref=r.ref;

	r.next=this;

      }

    }

    void attach(const T *p) 

    {

      prev=0; next=0; ref=p;

    }

    void release() 

    {

      if(ref) {

	bool fr=true;

	if(prev) { fr=false; prev->next=next; }

	if(next) { fr=false; next->prev=prev; }

	if(fr) delete ref;

	ref=0;

      }

    }

  public:

    ///\e

    RefPtr() : ref(0) {}

    ///\e

    RefPtr(const RefPtr &r) {

      lock();

      attach(const_cast<RefPtr&>(r));

      unlock();

    }

    ///\e

    RefPtr(T *p) : prev(0), next(0), ref(p) {}

    ///\e

    ~RefPtr() {

      lock();

      release();

      unlock();

    }

    ///\e

    const RefPtr &operator=(const RefPtr &r) { 

      if(ref!=r.ref) {

	lock();

	release(); attach(const_cast<RefPtr&>(r));

	unlock();

      }

      return *this;

    }

    ///\e

    const RefPtr &operator=(const T* &p) { 

      if(ref!=p) { lock(); release(); attach(p); unlock(); }

      return *this;

    }

    ///\e

    void swap(RefPtr &r) {

      RefPtr *p;

      T *tp;

      lock();

      p=prev; prev=r.prev; r.prev=p;

      p=next; next=r.next; r.next=p;

      tp=ref; ref=r.ref; r.ref=tp;

      unlock();

    }

    ///\e

    void clear() { lock(); release(); unlock(); }

    ///\e

    T * operator->() { return ref; }

    ///\e

    const T * operator->() const { return ref; }

    ///\e

    operator T *() { return ref; }

    ///\e

    operator const T *() const { return ref; }

    ///\e

    bool operator<(const RefPtr &r) const { return this->ref < r.ref; }

    ///\e

    bool operator<=(const RefPtr &r) const { return this->ref <= r.ref; }

    ///\e

    bool operator==(const RefPtr &r) const { return this->ref == r.ref; }

    ///\e

    bool operator>=(const RefPtr &r) const { return this->ref >= r.ref; }

    ///\e

    bool operator>(const RefPtr &r) const { return this->ref > r.ref; }

    ///\e

    bool operator!=(const RefPtr &r) const { return this->ref != r.ref; }

    ///\e

    operator bool() const { return ref; }

    ///\e

    const RefPtr &borrow(const T* &p) { 

      lock();

      if(ref==p) {

	if(prev) prev->next=next;

	if(next) next->prev=prev;

      }

      else release();

      ref=p;

      next=prev=this;

      unlock();

      return *this;

    }

    ///\e

    const RefPtr &borrow() { 

      lock();

      if(prev) prev->next=next;

      if(next) next->prev=prev;

      next=prev=this;

      unlock();

      return *this;

    }

  };  //END OF CLASS REFPTR

} //END OF NAMESPACE LEMON

#endif