array_mem_check.hpp

Go to the documentation of this file.

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

#ifndef ECL_CONTAINERS_ARRAY_MEM_CHECK_HPP_
#define ECL_CONTAINERS_ARRAY_MEM_CHECK_HPP_
#ifdef ECL_MEM_CHECK_ARRAYS

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

#include <algorithm> // std::copy
#include <cstddef>  // size_t
#include <iterator>
#include "../definitions.hpp"
#include "../initialiser.hpp"
#include "../stencil.hpp"
#include <ecl/config/macros.hpp>
#include <ecl/concepts/macros.hpp>
#include <ecl/concepts/blueprints.hpp>
#include <ecl/concepts/streams.hpp>
#include <ecl/errors/compile_time_assert.hpp>
#include <ecl/exceptions/standard_exception.hpp>

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

namespace ecl {

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

namespace blueprints {

template <typename Type, size_t N> class ArrayFactory;
template <typename Derived> class ArrayBluePrint;
template <typename Type, size_t Size> class ConstantArray;

} // namespace blueprints

namespace formatters {

template <typename Type, size_t N> class ArrayFormatter;

} // namespace formatters

/*****************************************************************************
** Interface [Array][Fixed]
*****************************************************************************/
template<typename Type, std::size_t Size = DynamicStorage>
class ECL_PUBLIC Array : public blueprints::ArrayFactory<Type,Size> {
    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 blueprints::ArrayFactory<value_type,Size> Factory; 
        typedef formatters::ArrayFormatter<Type,Size> Formatter; 
        /*********************
        ** Constructors
        **********************/
        Array() { initialiseMagicSections(); };
        template<typename T>
        Array(const blueprints::ArrayBluePrint< T > &blueprint) {
            ecl_compile_time_concept_check(BluePrintConcept<T>);
            blueprint.implementApply(*this);
            initialiseMagicSections();
        }

        virtual ~Array() {}; // The user should manually check these in the classes that hold them.

        /*********************
        ** Assignment
        **********************/
        containers::BoundedListInitialiser<Type,Type*,Size> operator<<(const Type &value) {
            return containers::BoundedListInitialiser<value_type,iterator,Size>(value,elements);
        }

        /*********************
        ** Iterators
        **********************/
        iterator begin() { return elements; }
        const_iterator begin() const { return elements; }
        iterator end() { return elements+Size; }
        const_iterator end() const { return elements+Size; }
        reverse_iterator rbegin() { return reverse_iterator(end()); }
        const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
        reverse_iterator rend() { return reverse_iterator(begin()); }
        const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }

        /*********************
        ** Front/Back
        **********************/
        reference front() { return elements[0]; }
        const_reference front() const { return elements[0]; }
        reference back() { return elements[Size-1]; }
        const_reference back() const { return elements[Size-1]; }

        /*********************
        ** Accessors
        **********************/
        Stencil< Array<Type,Size> > stencil(const unsigned int& start_index, const unsigned int& n) ecl_assert_throw_decl(StandardException) {
                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,Size> >(*this, begin()+start_index, begin()+start_index+n);
        }
        reference operator[](size_type i) ecl_assert_throw_decl(StandardException) {
            ecl_assert_throw( i<Size, StandardException(LOC,OutOfRangeError));
            return elements[i];
        }
        const_reference operator[](size_type i) const ecl_assert_throw_decl(StandardException) {
            ecl_assert_throw( i<Size, StandardException(LOC,OutOfRangeError));
            return elements[i];
        }
        reference at(size_type i) throw(StandardException) {
            if ( i>=Size ) {
                throw StandardException(LOC,OutOfRangeError);
            }
            return elements[i];
        }
        const_reference at(size_type i) const throw(StandardException) {
            if ( i>=Size ) {
                throw StandardException(LOC,OutOfRangeError);
            }
            return elements[i];
        }

        /*********************
        ** Utilities
        **********************/
        static size_type size() { return Size; }

        /*********************
        ** Streaming
        **********************/
        template <typename OutputStream, typename ElementType, size_t ArraySize>
        friend OutputStream& operator<<(OutputStream &ostream , const Array<ElementType,ArraySize> &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;
        }
        char underrun[4];
        value_type elements[Size];
        char overrun[4];
};

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

        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, size_t Size>
bool Array<Type,Size>::bufferOverRun() {

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

template<typename Type, size_t Size>
bool Array<Type,Size>::bufferUnderRun() {
        for ( unsigned int i = 0; i < bufferUnderrunLength(); ++i ) {
                if ( underrun[i] != magicChar() ) {
                        return true;
                }
        }
        return false;
}
template<typename Type, size_t Size>
bool Array<Type,Size>::bufferOverFlow() {
        return ( bufferOverRun() || bufferUnderRun() );
}


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

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

        ecl_compile_time_concept_check(StreamConcept<OutputStream>);

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

    return ostream;
}

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

namespace blueprints {

template <typename Derived>
class ArrayBluePrint {
    public:
        template <typename BaseType>
        BaseType implementInstantiate() {
            return static_cast<Derived*>(this)->instantiate();
        }
        template <typename BaseType>
        void implementApply(BaseType& array) const {
            static_cast<const Derived*>(this)->apply(array);
        }

        virtual ~ArrayBluePrint() {}
};
template <typename Type, size_t Size>
class ConstantArray : public ArrayBluePrint< ConstantArray<Type, Size> > {
    public:
        typedef ecl::Array<Type,Size> base_type;
        ConstantArray(const Type& value = 0) : val(value) {}

        virtual ~ConstantArray() {};

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

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

    private:
        const Type& val;
};

template<typename Type, size_t Size>
class ArrayFactory {
    public:
        static ConstantArray<Type,Size> Constant(const Type& value) {
            return ConstantArray<Type,Size>(value);
        }

        virtual ~ArrayFactory() {};
};

} // namespace blueprints
} // namespace ecl

#endif /* ECL_MEM_CHECK_ARRAYS */
#endif /* ECL_CONTAINERS_ARRAY_MEM_CHECK_HPP_ */