---

alloc_smart_pointer.hh

/*
*  Name:      alloc_smart_pointer.hh
*  Author:    Rafael Jesus Alcantara Perez
*  Summary:   Smart pointer with allocator support
*  Date:      $Date: 2003/04/14 00:18:31 $
*  Revision:  $Revision: 1.1 $
*
*  Copyright (C) 2000-2002  Rafael Jesus Alcantara Perez <rafa@dedalo-ing.com>
*
*  This program is free software; you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation; either version 2 of the License, or
*  (at your option) any later version.
*
*  This program 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 General Public License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with this program; if not, write to the Free Software
*  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
*  MA 02111-1307, USA.
*/

#ifndef _MPCL_MEMORY_ALLOC_SMART_POINTER__
#define _MPCL_MEMORY_ALLOC_SMART_POINTER__

#include <memory>
#include "base_smart_pointer.hh"


namespace mpcl
{

  namespace memory
  {

    template < typename TItem                                               ,
               template <typename TItemA> class TAllocator = std::allocator >
    class TAllocSmartPointer                                     :
      public            TBaseSmartPointer                        ,
      protected virtual TAllocator<TBaseSmartPointer::cell_type> ,
      protected virtual TAllocator<TItem>
    {

      public:

        typedef
          const TItem*
          const_pointer;

        typedef
          const TItem&
          const_reference;

        typedef
          TAllocator<TItem>
          item_allocator;

        typedef
          TItem*
          pointer;

        typedef
          TItem&
          reference;

        typedef
          size_t
          size_type;

        typedef
          TItem
          value_type;


      protected:

        //
        //  C O N S T R U C T O R S
        //

        void freeCell (void)
        {
          TAllocator<TItem>::destroy        ((pointer) ptSharedCell->pvItem);
          TAllocator<TItem>::deallocate     ((pointer) ptSharedCell->pvItem, 1);
          TAllocator<cell_type>::destroy    (ptSharedCell);
          TAllocator<cell_type>::deallocate (ptSharedCell, 1);
        }

        void reserveCell (const_pointer pktITEM)
        {
          if ( pktITEM )
          {
            ptSharedCell = TAllocator<cell_type>::allocate (1);
            TAllocator<cell_type>::construct (ptSharedCell, (const void*) pktITEM);
          }
        }


      public:

        //
        //  C O N S T R U C T O R S
        //

        TAllocSmartPointer (void)  :
          TBaseSmartPointer     () ,
          TAllocator<cell_type> () ,
          TAllocator<TItem>     () {}

        TAllocSmartPointer (const TAllocSmartPointer& rkqtITEM) :
          TBaseSmartPointer     ()                              ,
          TAllocator<cell_type> ()                              ,
          TAllocator<TItem>     ()
        {
          attachTo (rkqtITEM);
        }

  // <FIXME id="smart-pointers" comment="this method can assign other type of objects">
        template <typename TDerivedItem>
        explicit TAllocSmartPointer ( const TAllocSmartPointer<TDerivedItem, TAllocator>& rkqtITEM_DERIVED) :
          TBaseSmartPointer     ()                                                                          ,
          TAllocator<cell_type> ()                                                                          ,
          TAllocator<TItem>     ()
        {

          //
          //  Declares two variables for checking assign ability.
          //
          register pointer         ptItem;
          register TDerivedItem*   ptDerivedItem (NULL);

          //
          //  Checks for possible syntax errors about using classes with no relation with
          //  this  instance to assign  to this  instance.  At  last,  it attaches to the
          //  derived pointer.
          //
          ptItem = ptDerivedItem;
          attachTo (rkqtITEM_DERIVED);

        }  // TAllocSmartPointer()
  // </FIXME>

        explicit TAllocSmartPointer (const_pointer pktITEM) :
          TBaseSmartPointer     ()                          ,
          TAllocator<cell_type> ()                          ,
          TAllocator<TItem>     ()
        {
          reserveCell (pktITEM);
        }

        ~TAllocSmartPointer (void)
        {
          release();
        }

        TAllocSmartPointer& operator = (const_pointer pktITEM)
        {
          release();
          reserveCell (pktITEM);
          return *this;
        }

        TAllocSmartPointer& operator = (const TAllocSmartPointer& rkqtITEM)
        {
          if ( rkqtITEM.ptSharedCell != ptSharedCell )
          {
            release();
            attachTo (rkqtITEM);
          }
          return *this;
        }

        void release (void)
        {

          if ( ptSharedCell )
          {
            //
            //  ptSharedCell->pvItem must be different from NULL.
            //  Decrements the reference counter.
            //
            --(ptSharedCell->luiReferenceCount);
            if ( !ptSharedCell->luiReferenceCount )
            {
              //
              //  Warning:  There is no check when  deleting  ptSharedCell->pvItem (for
              //            NULL value) cause  there is no way to assign a NULL pointer
              //            value.
              //
              freeCell();
            }

            //
            //  Anyway, clears the pointer to the shared cell.
            //
            ptSharedCell = NULL;
          }

        }  // release()


      public:

        //
        //  S E L E C T O R S
        //

        template <typename TPointer>
        TPointer constCast (void) const throw()
        {
          TPointer   tPointer = NULL;

          if ( ptSharedCell )
          {
            tPointer = const_cast<TPointer> ((pointer) ptSharedCell->pvItem);
          }
          return tPointer;
        }

        template <typename TPointer>
        TPointer dynamicCast (void) const
          throw (TConstraintException)
        {
          TPointer   tPointer = NULL;

          if ( !ptSharedCell )
          {
  // <FIXME id="smart-pointers" comment="this exception must not be thrown">
            throw TConstraintException ("null pointer", __FILE__, __LINE__);
  // </FIXME>
          }
          else
          {
            tPointer = dynamic_cast<TPointer> ((pointer) ptSharedCell->pvItem);
            if ( !tPointer )
            {
              throw TConstraintException ("can not dynamic-cast pointer", __FILE__, __LINE__);
            }
          }
          return tPointer;
        }

        pointer get (void) const throw()
        {
          register pointer   ptResultItem = NULL;

          if ( ptSharedCell )
          {
            ptResultItem = (pointer) ptSharedCell->pvItem;
          }
          return ptResultItem;
        }

        bool operator == (const TAllocSmartPointer& rkqtITEM) const throw()
        {
          return equal (rkqtITEM);
        }

        bool operator != (const TAllocSmartPointer& rkqtITEM) const throw()
        {
          return !operator == (rkqtITEM);
        }

        bool operator ! (void) const throw()
        {
          return ( !ptSharedCell );
        }

        pointer operator -> (void) const
          throw (TConstraintException)
        {
          if ( !ptSharedCell )
          {
            throw TConstraintException ("null pointer", __FILE__, __LINE__);
          }
          return (pointer) ptSharedCell->pvItem;
        }

        reference operator * (void) const
          throw (TConstraintException)
        {
          if ( !ptSharedCell )
          {
            throw TConstraintException ("null pointer", __FILE__, __LINE__);
          }
          return *((pointer) ptSharedCell->pvItem);
        }

    };  // class TAllocSmartPointer

  }  // namespace memory

}  // namespace mpcl


#endif  // not _MPCL_MEMORY_ALLOC_SMART_POINTER__

---