sharedheap_def.h

Go to the documentation of this file.

#ifndef AFF_SHAREDHEAP_H_VERSION 
#error "include this only through sharedheap.h"
#endif

// include guard
#ifndef AFF_SHAREDHEAP_DEF_H_VERSION

#define AFF_SHAREDHEAP_DEF_H_VERSION \
  "AFF_SHAREDHEAP_DEF_H   V1.4"

namespace aff {

#ifdef AFF_PREBUILT
namespace prebuilt {
#endif

#ifdef AFF_PREBUILT
#ifndef AFF_COMPILING_LIBRARY
#error "definition read in prebuilt mode and not during library compilation"
#endif
#endif

/*======================================================================*/

namespace util {

  template <typename T>
    inline
    SHeap<T>::SHeap(const Tsize& size)
    : Mheap(0), Msize(size), Mnref(1), Mextern(false)
    { 
      if (size>0) {
        try { Mheap=new T[size]; }
        catch (std::bad_alloc) {
          throw AllocException(size, sizeof(T));
        }
      } else { 
        Msize=0;
      }
    }

  /*----------------------------------------------------------------------*/

  template <typename T>
    inline
    SHeap<T>::SHeap(T* pointer, const Tsize& size)
    : Mheap(pointer), Msize(size), Mnref(1), Mextern(true) { }

  /*----------------------------------------------------------------------*/

  template <typename T>
    inline
    SHeap<T>::~SHeap()
    {
      if ((Mheap!=0) && (Msize>0) && (!Mextern))
      { 
        delete[] Mheap; 
      }
    }

} // namespace util

/*======================================================================*/

  template <typename T>
    inline
    ConstSharedHeap<T>::ConstSharedHeap()
    : Mheapstruct(new Theapstruct(1)) { }

  /*----------------------------------------------------------------------*/

  template <typename T>
    inline
    ConstSharedHeap<T>::ConstSharedHeap(const Tsize& size)
    : Mheapstruct(new Theapstruct(size)) { }

  /*----------------------------------------------------------------------*/

  template <typename T>
    inline
    ConstSharedHeap<T>::ConstSharedHeap(T* pointer, const Tsize& size)
    : Mheapstruct(new Theapstruct(pointer, size)) { }

  /*----------------------------------------------------------------------*/

  template <typename T>
    inline
    ConstSharedHeap<T>::ConstSharedHeap(const Tcontainer& sharedheap)
    : Mheapstruct(sharedheap.Mheapstruct) 
    { ++(Mheapstruct->Mnref); }

  /*----------------------------------------------------------------------*/

  template <typename T>
    inline
    ConstSharedHeap<T>::~ConstSharedHeap()
    {
      if (--(Mheapstruct->Mnref) < 1)
      {
        delete Mheapstruct;
      }
    }

  /*----------------------------------------------------------------------*/

  template <typename T>
    inline
    ConstSharedHeap<T>&
    ConstSharedHeap<T>::operator=(const ConstSharedHeap<T>& sharedheap)
    {
      if (Mheapstruct != sharedheap.Mheapstruct)
      {
        if (--(Mheapstruct->Mnref) < 1)
        {
          delete Mheapstruct;
        }
        Mheapstruct=sharedheap.Mheapstruct;
        ++(Mheapstruct->Mnref);
      }
      return(*this);
    }

#ifdef AFF_PREBUILT
} // namespace prebuilt
#endif

} // namespace aff

#endif // AFF_SHAREDHEAP_DEF_H_VERSION (includeguard)

/* ----- END OF sharedheap_def.h ----- */