sharedheap.h

Go to the documentation of this file.

// include guard
#ifndef AFF_SHAREDHEAP_H_VERSION

#define AFF_SHAREDHEAP_H_VERSION \
  "AFF_SHAREDHEAP_H   V1.8"

#include<new>
#include<aff/lib/error.h>
#include<aff/lib/types.h>

namespace aff {

#ifdef AFF_PREBUILT
namespace prebuilt {
#endif

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

namespace util {

  template<typename T>
    struct SHeap
    {
      SHeap(const Tsize& size);
      SHeap(T* pointer, const Tsize& size);

      ~SHeap();

      T*     Mheap;   
      Tsize  Msize;   
      Tsize  Mnref;   
      bool   Mextern; 
    }; // struct SHeap

} // namespace util

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

  template <class T>
    class ConstSharedHeap
    {
      public:
        typedef const T Tvalue;
        typedef const T* Tpointer;
        typedef const T& Treference;
        typedef aff::ConstSharedHeap<T> Tcontainer;
        typedef aff::ConstSharedHeap<T> Tcontainer_of_const;
        typedef aff::ConstSharedHeap<T> Tcoc;

      private:
        typedef aff::util::SHeap<T> Theapstruct;

      public:
        ConstSharedHeap();

        ConstSharedHeap(T* pointer, const Tsize& size);

        ConstSharedHeap(const Tcontainer& sharedheap);

        ~ConstSharedHeap();

        ConstSharedHeap<T>& operator=(const Tcontainer& sharedheap);

        inline
        const Tsize& size() const
        { return(Mheapstruct->Msize); }

        const T* array() const
        { return(Mheapstruct->Mheap); }

        inline
        const T& operator[](const Tsubscript& i) const
        { 
#ifdef AFF_INDEXCHECK
          AFF_assert(((i<Tsubscript(Mheapstruct->Msize)) && (i>=0)),
                     "SharedHeap: illegal index position!");
#endif
          return(Mheapstruct->Mheap[i]); 
        }

      /*-----------------------------------------------------------------*/
      /* here starts the PROTECTED section!
       * ----------------------------------
       *
       * These functions are needed by the derived aff::SharedHeap class to
       * access its base class and the data elements contained therein in a
       * defined way.
       */
      protected:
        ConstSharedHeap(const Tsize& size);

        inline
        T& write_access(const Tsubscript& i) const
        { 
#ifdef AFF_INDEXCHECK
          AFF_assert(((i<Tsubscript(Mheapstruct->Msize)) && (i>=0)),
                     "SharedHeap: illegal index position!");
#endif
          return(Mheapstruct->Mheap[i]); 
        }

        T* writable_array()
        { return(Mheapstruct->Mheap); }

      private:
        Theapstruct* Mheapstruct; 

    }; // class ConstSharedHeap<T>

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

  template <class T>
    class SharedHeap: public aff::ConstSharedHeap<T>
    {
      public:
        typedef T Tvalue;
        typedef T* Tpointer;
        typedef T& Treference;
        typedef aff::SharedHeap<T> Tcontainer;
        typedef aff::ConstSharedHeap<T> Tbase;
        typedef Tbase Tcontainer_of_const;
        typedef Tbase Tcoc;

      public:
        SharedHeap(): Tbase() { }

        SharedHeap(const Tsize& size): Tbase(size) { }

        SharedHeap(T* pointer, const Tsize& size):
          Tbase(pointer, size) { }

        SharedHeap(const Tcontainer& sharedheap):
          Tbase(sharedheap) { }

        ~SharedHeap() { }


        using Tbase::size;
        using Tbase::operator[];
        using Tbase::array;

        T& operator[](const Tsubscript& i) const
        { return(this->Tbase::write_access(i)); }

        T* array() const
        { return(this->Tbase::writable_array()); }
        
    }; // class SharedHeap

#ifdef AFF_PREBUILT
} // namespace prebuilt
#endif

} // namespace aff

#ifndef AFF_NO_DEFINITIONS
#include <aff/lib/sharedheap_def.h>
#endif

#endif // AFF_SHAREDHEAP_H_VERSION (includeguard)

/* ----- END OF sharedheap.h ----- */