array_dynamic_no_mem_check.hpp

Go to the documentation of this file.

 
/*****************************************************************************
** Ifdefs
*****************************************************************************/
 
#ifndef ECL_CONTAINERS_ARRAY_DYNAMIC_NO_MEM_CHECK_HPP_
#define ECL_CONTAINERS_ARRAY_DYNAMIC_NO_MEM_CHECK_HPP_
 
/*****************************************************************************
** Includes
*****************************************************************************/
 
#include <algorithm>
#include <ecl/config/macros.hpp>
#include <ecl/utilities/blueprints.hpp>
#include "../definitions.hpp"
#include "../initialiser.hpp"
#include "../stencil.hpp"
#include "array_no_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
 
/*****************************************************************************
** BluePrintFactory
*****************************************************************************/
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), buffer(NULL) {}
        explicit Array(const unsigned int reserve_size) : buffer_size(reserve_size), buffer(NULL) {
                        buffer = new Type[reserve_size];
        };
        Array(const Array<Type,DynamicStorage>& array) :
                Factory(),
                buffer_size(0),
                buffer(NULL)
                {
                if ( array.size() != 0 ) {
                                resize(array.size());
                                std::copy(array.begin(),array.end(),begin());
                }
        }
        template<typename T>
        Array(const blueprints::ArrayBluePrint< T > &blueprint) : buffer_size(0), buffer(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);
        }
        ~Array() {
            if ( buffer != NULL ) {
                delete[] buffer;
            }
        }
        /*********************
        ** 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());
                                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) {
            if ( i>=buffer_size ) {
                throw StandardException(LOC,OutOfRangeError);
            }
            return buffer[i];
        }
        const_reference at(size_type i) const {
            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 ( buffer != NULL ) {
                delete[] buffer;
            }
            buffer = new Type[n];
            buffer_size = n;
        }
        void clear() {
            if ( buffer != NULL ) {
                delete[] buffer;
                buffer = NULL;
            }
            buffer_size = 0;
        }
 
        /*********************
        ** Streaming
        **********************/
        template <typename OutputStream, typename ElementType>
        friend OutputStream& operator<<(OutputStream &ostream , const Array<ElementType,DynamicStorage> &array);
 
    private:
        unsigned int buffer_size;
        Type *buffer;
 
};
 
/*****************************************************************************
** 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_NO_MEM_CHECK_HPP_ */