array_dynamic_mem_check.hpp

Go to the documentation of this file.

/*****************************************************************************
** Ifdefs
*****************************************************************************/

#ifndef ECL_CONTAINERS_ARRAY_DYNAMIC_MEM_CHECK_HPP_
#define ECL_CONTAINERS_ARRAY_DYNAMIC_MEM_CHECK_HPP_

/*****************************************************************************
** Includes
*****************************************************************************/

#include <algorithm>
#include <cstdlib>
#include <cstdio>
#include <ecl/config/macros.hpp>
#include <ecl/utilities/blueprints.hpp>
#include "../definitions.hpp"
#include "../initialiser.hpp"
#include "../stencil.hpp"
#include "array_mem_check.hpp"

/*****************************************************************************
** Namespaces
*****************************************************************************/

namespace ecl {

/*****************************************************************************
** Forward Declarations
*****************************************************************************/

template <typename Type> class Array<Type,DynamicStorage>;

namespace blueprints {

template <typename Type> class ConstantDynamicArray;

} // namespace blueprints

namespace formatters {

template <typename Type, size_t N> class ArrayFormatter;

} // namespace formatters

template<typename Type>
class ECL_PUBLIC BluePrintFactory< Array<Type,DynamicStorage> > {
    public:
        static blueprints::ConstantDynamicArray<Type> Constant(size_t size, const Type &value) {
            return blueprints::ConstantDynamicArray<Type>(size,value);
        }
        virtual ~BluePrintFactory() {};
};

/*****************************************************************************
** Interface [Array][Dynamic]
*****************************************************************************/
template<typename Type>
class ECL_PUBLIC Array<Type,DynamicStorage> : public BluePrintFactory< Array<Type,DynamicStorage> >  {
    public:
        /*********************
        ** Typedefs
        **********************/
        typedef Type           value_type; 
        typedef Type*          iterator;   
        typedef const Type*    const_iterator;  
        typedef Type&          reference;  
        typedef const Type&    const_reference; 
        typedef std::size_t    size_type;  
        typedef std::ptrdiff_t difference_type;
        typedef std::reverse_iterator<iterator> reverse_iterator; 
        typedef std::reverse_iterator<const_iterator> const_reverse_iterator;  
        typedef formatters::ArrayFormatter<Type,DynamicStorage> Formatter; 
        typedef BluePrintFactory< Array<Type,DynamicStorage> > Factory;

        /*********************
        ** Constructors
        **********************/
        explicit Array() : buffer_size(0), underrun(NULL), buffer(NULL), overrun(NULL) {}
        explicit Array(const unsigned int reserve_size) :
                        buffer_size(reserve_size),
                        underrun(NULL),
                        buffer(NULL),
                        overrun(NULL)
                        {
                underrun = (char*) malloc(buffer_size*sizeof(Type)+bufferUnderrunLength()+bufferOverrunLength());
                ecl_assert_throw(underrun != NULL, StandardException(LOC,MemoryError,"Failed to allocate memory to the dynamic array."));
                buffer = (Type*) (underrun+bufferUnderrunLength());
                overrun = (char*) underrun+bufferUnderrunLength()+buffer_size*sizeof(Type);
                // Leave it uninitialised, just like eigen containers...faster
//              for ( unsigned int i = 0; i < buffer_size; ++i ) {
//                      buffer[i] = Type();
//              }
                        initialiseMagicSections();
        };
        Array(const Array<Type,DynamicStorage>& array) : buffer_size(0), underrun(NULL), buffer(NULL), overrun(NULL) {
                if ( array.size() != 0 ) {
                                resize(array.size()); // not really optimal as we do a fill in resize and then copy here, but its debug version anyway.
                                std::copy(array.begin(),array.end(),begin());
                }
        }
        template<typename T>
        Array(const blueprints::ArrayBluePrint< T > &blueprint) : buffer_size(0), underrun(NULL), buffer(NULL), overrun(NULL) {
            // Note we're using a partially specialised parent interface here otherwise the
            // constructor that reserves sizes as well as the comma initialiser won't
            // conveniently convert types correctly
            // (e.g. Array<double> array(4); array = 1,2,3,4; will fail)
            ecl_compile_time_concept_check(BluePrintConcept<T>);
            blueprint.implementApply(*this);
            initialiseMagicSections();
        }
        ~Array() {

            if ( underrun != NULL ) {
                free(underrun);
            }
            underrun = NULL;
            buffer = NULL;
            overrun = NULL;
        }
        /*********************
        ** Assignment
        **********************/
        containers::BoundedListInitialiser<value_type,iterator,DynamicStorage> operator<<(const Type &value) {
            return containers::BoundedListInitialiser<value_type,iterator,DynamicStorage>(value,buffer,buffer_size);
        }

        void operator=(const Array<Type,DynamicStorage>& array) {
                if ( array.size() == 0 ) {
                        clear();
                } else {
                                resize(array.size()); // not really optimal as we do a fill in resize and then copy here, but its debug version anyway.
                                std::copy(array.begin(),array.end(),begin());
                }
        }

        /*********************
        ** Iterators
        **********************/
        iterator begin() {
            ecl_assert_throw( buffer != NULL, StandardException(LOC,OutOfRangeError) );
            return buffer;
            }
        const_iterator begin() const {
            ecl_assert_throw( buffer != NULL, StandardException(LOC,OutOfRangeError) );
            return buffer;
        }
        iterator end() {
            ecl_assert_throw( buffer != NULL, StandardException(LOC,OutOfRangeError) );
            return buffer+buffer_size;
        }
        const_iterator end() const {
            ecl_assert_throw( buffer != NULL, StandardException(LOC,OutOfRangeError) );
            return buffer+buffer_size;
        }
        reverse_iterator rbegin() {
            ecl_assert_throw( buffer != NULL, StandardException(LOC,OutOfRangeError) );
            return reverse_iterator(end());
        }
        const_reverse_iterator rbegin() const {
            ecl_assert_throw( buffer != NULL, StandardException(LOC,OutOfRangeError) );
            return const_reverse_iterator(end());
        }
        reverse_iterator rend() {
            ecl_assert_throw( buffer != NULL, StandardException(LOC,OutOfRangeError) );
            return reverse_iterator(begin());
        }
        const_reverse_iterator rend() const {
            ecl_assert_throw( buffer != NULL, StandardException(LOC,OutOfRangeError) );
            return const_reverse_iterator(begin());
        }

        /*********************
        ** Front/Back
        **********************/
        reference front() {
            ecl_assert_throw( buffer != NULL, StandardException(LOC,OutOfRangeError) );
            return buffer[0];
        }
        const_reference front() const {
            ecl_assert_throw( buffer != NULL, StandardException(LOC,OutOfRangeError) );
            return buffer[0];
        }
        reference back() {
            ecl_assert_throw( buffer != NULL, StandardException(LOC,OutOfRangeError) );
            return buffer[buffer_size-1];
        }
        const_reference back() const {
            ecl_assert_throw( buffer != NULL, StandardException(LOC,OutOfRangeError) );
            return buffer[buffer_size-1];
        }

        /*********************
        ** Accessors
        **********************/
        Stencil< Array<Type,DynamicStorage> > stencil(const unsigned int& start_index, const unsigned int& n) {
                ecl_assert_throw(start_index < size(), StandardException(LOC, OutOfRangeError, "Start index provided is larger than the underlying array size."));
                ecl_assert_throw(start_index+n <= size(), StandardException(LOC, OutOfRangeError, "Finish index provided is larger than the underlying array size."));
                return Stencil< Array<Type,DynamicStorage> >(*this, begin()+start_index, begin()+start_index+n);
        }
        reference operator[](size_type i) {
            ecl_assert_throw( i<buffer_size, StandardException(LOC,OutOfRangeError));
            return buffer[i];
        }
        const_reference operator[](size_type i) const {
            ecl_assert_throw( i<buffer_size, StandardException(LOC,OutOfRangeError));
            return buffer[i];
        }
        reference at(size_type i) throw(StandardException) {
            if ( i>=buffer_size ) {
                throw StandardException(LOC,OutOfRangeError);
            }
            return buffer[i];
        }
        const_reference at(size_type i) const throw(StandardException) {
            if ( i>=buffer_size ) {
                throw StandardException(LOC,OutOfRangeError);
            }
            return buffer[i];
        }

        /*********************
        ** Utilities
        **********************/
        size_type size() const { return buffer_size; }

        void resize( size_t n )  {
                if ( underrun != NULL ) {
                        free(underrun);
                }
            buffer_size = n;
                underrun = (char*) malloc(buffer_size*sizeof(Type)+bufferUnderrunLength()+bufferOverrunLength());
                ecl_assert_throw(underrun != NULL, StandardException(LOC,MemoryError,"Failed to allocate memory to the dynamic array."));
                buffer = (Type*) (underrun+bufferUnderrunLength());
                overrun = (char*) underrun+bufferUnderrunLength()+buffer_size*sizeof(Type);
                // Leave it uninitialised, just like eigen containers...faster
//              for ( unsigned int i = 0; i < buffer_size; ++i ) {
//                      buffer[i] = Type();
//              }
            initialiseMagicSections();
        }
        void clear() {
                if ( underrun != NULL ) {
                        free(underrun);
                        underrun = NULL;
                        buffer = NULL;
                        overrun = NULL;
                }
            buffer_size = 0;
        }

        /*********************
        ** Streaming
        **********************/
        template <typename OutputStream, typename ElementType>
        friend OutputStream& operator<<(OutputStream &ostream , const Array<ElementType,DynamicStorage> &array);

        /******************************************
                ** Buffer under/overrun checks
                *******************************************/
        bool bufferUnderRun();
        bool bufferOverRun();
        bool bufferOverFlow();

    private:
        void initialiseMagicSections();

         static const unsigned int& bufferOverrunLength() {
            static const unsigned int buffer_overrun_length = 4;
            return buffer_overrun_length;
        }
        static const unsigned int& bufferUnderrunLength() {
            static const unsigned int buffer_underrun_length = 4;
            return buffer_underrun_length;
        }
        static const char& magicChar() {
            static const char magic_char = 0xCC;
            return magic_char;
        }
        unsigned int buffer_size;
        char *underrun;
        Type *buffer;
        char *overrun;
};

/*****************************************************************************
** Implementation [Array][MemCheck]
*****************************************************************************/
template<typename Type>
void Array<Type,DynamicStorage>::initialiseMagicSections() {

        // Should check that buffer != NULL here, but this isn't user API so just have to guarantee it internally.
        for ( unsigned int i = 0; i < bufferUnderrunLength(); ++i ) {
                *(underrun+i) = magicChar();
        }
        for ( unsigned int i = 0; i < bufferOverrunLength(); ++i ) {
                *(overrun+i) = magicChar();
        }
}
template<typename Type>
bool Array<Type,DynamicStorage>::bufferUnderRun() {
        if ( underrun != NULL ) {
                for ( unsigned int i = 0; i < bufferUnderrunLength(); ++i ) {
                        if ( *(underrun+i) != magicChar() ) {
                                return true;
                        }
                }
        }
        return false;
}
template<typename Type>
bool Array<Type,DynamicStorage>::bufferOverRun() {

        if ( overrun != NULL ) {
                for ( unsigned int i = 0; i < bufferOverrunLength(); ++i ) {
                        if ( *(overrun+i) != magicChar() ) {
                                return true;
                        }
                }
        }
        return false;
}

template<typename Type>
bool Array<Type,DynamicStorage>::bufferOverFlow() {
        return ( bufferOverRun() || bufferUnderRun() );
}


/*****************************************************************************
** Implementation [Array]
*****************************************************************************/

template <typename OutputStream, typename ElementType>
OutputStream& operator<<(OutputStream &ostream , const Array<ElementType,DynamicStorage> &array) {

    ostream << "[ ";
    for(size_t i = 0; i < array.buffer_size; ++i )
    {
        ostream << array[i] << " ";
    }
    ostream << "]";
    ostream.flush();

    return ostream;
}

/*****************************************************************************
** BluePrints
*****************************************************************************/

namespace blueprints {

/*****************************************************************************
** Interface [ConstantDynamicArray]
*****************************************************************************/

template <typename Type>
class ConstantDynamicArray: public ArrayBluePrint< ConstantDynamicArray<Type> >  {
    public:
        typedef ecl::Array<Type,ecl::DynamicStorage> base_type;
        ConstantDynamicArray() {};

        ConstantDynamicArray(size_t size, const Type &value ) :
            reserve_size(size),
            val(value)
            {}

        virtual ~ConstantDynamicArray() {};

        base_type instantiate() {
            ecl::Array<Type> array(reserve_size);
            std::fill_n(array.begin(),reserve_size,val);
            return array;
        }

        void apply(base_type& array) const {
            array.resize(reserve_size);
            std::fill_n(array.begin(),reserve_size,val);
        }

    private:
        size_t reserve_size;
        Type val;
};

} // namespace blueprints
} // namespace ecl


#endif /* ECL_CONTAINERS_ARRAY_DYNAMIC_MEM_CHECK_HPP_ */