---

base.SmartPtr.h

/*----------------------------------------------------------------------------
  SWORD 2000 - Software With Objects for Rapid Development
  Copyright (C) 2003 Eric NICOLAS
  ----------------------------------------------------------------------------
  SWORD is free software; you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  SWORD is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with SWORD; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  --------------------------------------------------------------------------*/
#ifndef _SWORD_BASE_SMARTPTR_
#define _SWORD_BASE_SMARTPTR_

namespace sword {


  template<class MX>
  struct SWORDDECL SmartPtrData {
    SmartPtrData() : mutex_(), counter_(1) {}
    MX  mutex_;
    int counter_;
  };

  template<class X, class MX>
  struct SmartPtrDataAllocator_Dynamic {
    typedef SmartPtrData<MX> DataType;
    typedef MX MutexType;
    //
    static inline DataType* allocate(X* /*ptr*/) { return new DataType(); }
    static inline void deallocate(DataType* ptr) { delete ptr; }
  };

  template<class X, class MX>
  struct SmartPtrDataAllocator_Embedded {
    typedef SmartPtrData<MX> DataType;
    typedef MX MutexType;
    //
    static inline DataType* allocate(X* ptr) { return ptr->smartPtrData(); }
    static inline void deallocate(DataType* ptr) {}
  };

  template<class X, class AX=SmartPtrDataAllocator_Dynamic<X, ACE_Thread_Mutex> >
  class SWORDDECL SmartPtr {
    typedef typename AX::MutexType MX;
    typedef SmartPtrData<typename AX::MutexType> DataType;
    class Tester {
      void operator delete(void*);
    public:
      Tester() {}
    };

  public:
    // -- CREATION / DESTRUCTION

    SmartPtr() throw();
    SmartPtr(const SmartPtr &sp);
    SmartPtr(int value) throw();
    ~SmartPtr();

    explicit SmartPtr(X *p);

    // -- SMART POINTER UPCAST / DOWNCAST

    template<class Y, class AY>
    inline SmartPtr &operator=(const SmartPtr<Y,AY> &sp)
    {
      if ((void*)ptr_ != (void*)sp.getPtr())
      {
        detach_();
        attach_(sp.getControl(), dynamic_cast<X*>(sp.getPtr()));
      }
      return *this;
    }

    inline SmartPtr &operator=(const SmartPtr &sp)
    {
      if (ptr_ != sp.ptr_)
      {
        detach_();
        attach_(sp.control_, sp.ptr_);
      }
      return *this;
    }

    // -- TESTS AND COMPARISONS

    template<class Y, class AY>
    inline bool operator==(const SmartPtr<Y,AY> &sp) const throw()
    {
      return (void*)getPtr() == (void*)sp.getPtr();
    }
    template<class Y, class AY>
    inline bool operator!=(const SmartPtr<Y,AY> &sp) const throw()
    {
      return (void*)getPtr() != (void*)sp.getPtr();
    }

    /* defined in the base.SmartPtr.inl:

    bool operator==(const SmartPtr &lhs, int rhs) throw();
    bool operator!=(const SmartPtr &lhs, int rhs) throw();
    bool operator==(int lhs, const SmartPtr &rhs) throw();
    bool operator!=(int lhs, const SmartPtr &rhs) throw();
    */

    operator Tester*() const throw();

    template<class Y, class AY>
    inline bool operator<(const SmartPtr<Y,AY> &rhs) const throw()
    {
      return (void*)lhs.getPtr() < (void*)rhs.getPtr();
    }

    // --- POINTER ASSIGNMENT

    SmartPtr &operator=(X *p);
    SmartPtr &operator=(int value);

    // --- ACCESS

    X *getPtr() const throw();
    SmartPtrData<MX>* getControl() const throw();

    X &operator*() const throw();
    X *operator->() const throw();

  private:
    mutable SmartPtrData<MX> *control_;
    X       *ptr_;

    void init_(X *p);
    void detach_();
    void attach_(SmartPtrData<MX>* sp_control, X *sp_ptr);
  };

} // namespace sword

#include "sword.private/base.SmartPtr.inl"

#endif // _SWORD_BASE_SMARTPTR_

---