synchronized_heap_host.h

#pragma once

#ifndef SYNCHRONIZED_HEAP_HOST_H
#define SYNCHRONIZED_HEAP_HOST_H




#include "synchronized_heap_base.h"
#include "platform.h"

#include <boost/shared_ptr.hpp>
#include <boost/shared_array.hpp>




namespace Synchronized {




/*==============================================================================
    Heap< PLATFORM_HOST > specialization
==============================================================================*/


template<>
struct Heap< PLATFORM_HOST > {

    template< typename t_Type >
    struct Pointer;


    inline Heap();


    template< typename t_Type >
    inline Pointer< t_Type > Allocate() const;

    template< typename t_Type >
    inline Pointer< t_Type[] > Allocate( size_t const count ) const;


    inline void Synchronize() const;


    template< typename t_Type >
    struct Pointer : public boost::shared_ptr< t_Type const > {

        typedef typename boost::shared_ptr< t_Type const >::element_type element_type;


        inline Pointer();
        inline Pointer( Pointer const& other );


        inline void Assign( element_type const& data ) const;


    private:

        inline Pointer( t_Type* pointer );


        friend struct Heap;
    };


    template< typename t_Type >
    struct Pointer< t_Type[] > : public boost::shared_array< t_Type const > {    // **TODO: in boost 1.53+, shared_ptr< t_Type[] > can substitute for shared_array< t_Type >

        typedef typename boost::shared_ptr< t_Type const >::element_type element_type;


        inline Pointer();
        inline Pointer( Pointer const& other );


        inline void Assign( size_t const index, element_type const& data ) const;


    private:

        inline Pointer( t_Type* array );


        friend struct Heap;
    };
};




/*==============================================================================
    Heap< PLATFORM_HOST >::Pointer methods
==============================================================================*/


template< typename t_Type >
Heap< PLATFORM_HOST >::Pointer< t_Type >::Pointer() {
}


template< typename t_Type >
Heap< PLATFORM_HOST >::Pointer< t_Type >::Pointer( Pointer const& other ) : boost::shared_ptr< t_Type const >( other ) {
}


template< typename t_Type >
void Heap< PLATFORM_HOST >::Pointer< t_Type >::Assign( element_type const& data ) const {

    *const_cast< t_Type* >( boost::shared_ptr< t_Type const >::get() ) = data;
}


template< typename t_Type >
Heap< PLATFORM_HOST >::Pointer< t_Type >::Pointer( t_Type* pointer ) : boost::shared_ptr< t_Type const >( pointer ) {
}


template< typename t_Type >
Heap< PLATFORM_HOST >::Pointer< t_Type[] >::Pointer() {
}


template< typename t_Type >
Heap< PLATFORM_HOST >::Pointer< t_Type[] >::Pointer( Pointer const& other ) : boost::shared_array< t_Type const >( other ) {
}


template< typename t_Type >
void Heap< PLATFORM_HOST >::Pointer< t_Type[] >::Assign( size_t const index, element_type const& data ) const {

    *const_cast< t_Type* >( boost::shared_array< t_Type const >::get() + index ) = data;
}


template< typename t_Type >
Heap< PLATFORM_HOST >::Pointer< t_Type[] >::Pointer( t_Type* array ) : boost::shared_array< t_Type const >( array ) {
}




/*==============================================================================
    Heap< PLATFORM_HOST > methods
==============================================================================*/


Heap< PLATFORM_HOST >::Heap() {
}


template< typename t_Type >
Heap< PLATFORM_HOST >::Pointer< t_Type > Heap< PLATFORM_HOST >::Allocate() const {

    return Pointer< t_Type >( new t_Type );
}


template< typename t_Type >
Heap< PLATFORM_HOST >::Pointer< t_Type[] > Heap< PLATFORM_HOST >::Allocate( size_t const size ) const {

    return Pointer< t_Type[] >( new t_Type[ size ] );
}


void Heap< PLATFORM_HOST >::Synchronize() const {
}




}    // namespace Synchronized




#endif    // SYNCHRONIZED_HEAP_HOST_H