$search

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_decl(StandardException) {
            ecl_assert_throw( buffer != NULL, StandardException(LOC,OutOfRangeError) );
            return buffer;
            }
        const_iterator begin() const ecl_assert_throw_decl(StandardException) {
            ecl_assert_throw( buffer != NULL, StandardException(LOC,OutOfRangeError) );
            return buffer;
        }
        iterator end() ecl_assert_throw_decl(StandardException) {
            ecl_assert_throw( buffer != NULL, StandardException(LOC,OutOfRangeError) );
            return buffer+buffer_size;
        }
        const_iterator end() const ecl_assert_throw_decl(StandardException) {
            ecl_assert_throw( buffer != NULL, StandardException(LOC,OutOfRangeError) );
            return buffer+buffer_size;
        }
        reverse_iterator rbegin() ecl_assert_throw_decl(StandardException) {
            ecl_assert_throw( buffer != NULL, StandardException(LOC,OutOfRangeError) );
            return reverse_iterator(end());
        }
        const_reverse_iterator rbegin() const ecl_assert_throw_decl(StandardException) {
            ecl_assert_throw( buffer != NULL, StandardException(LOC,OutOfRangeError) );
            return const_reverse_iterator(end());
        }
        reverse_iterator rend() ecl_assert_throw_decl(StandardException) {
            ecl_assert_throw( buffer != NULL, StandardException(LOC,OutOfRangeError) );
            return reverse_iterator(begin());
        }
        const_reverse_iterator rend() const ecl_assert_throw_decl(StandardException) {
            ecl_assert_throw( buffer != NULL, StandardException(LOC,OutOfRangeError) );
            return const_reverse_iterator(begin());
        }

        /*********************
        ** Front/Back
        **********************/
        reference front() ecl_assert_throw_decl(StandardException) {
            ecl_assert_throw( buffer != NULL, StandardException(LOC,OutOfRangeError) );
            return buffer[0];
        }
        const_reference front() const ecl_assert_throw_decl(StandardException) {
            ecl_assert_throw( buffer != NULL, StandardException(LOC,OutOfRangeError) );
            return buffer[0];
        }
        reference back() ecl_assert_throw_decl(StandardException) {
            ecl_assert_throw( buffer != NULL, StandardException(LOC,OutOfRangeError) );
            return buffer[buffer_size-1];
        }
        const_reference back() const ecl_assert_throw_decl(StandardException) {
            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_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,DynamicStorage> >(*this, begin()+start_index, begin()+start_index+n);
        }
        reference operator[](size_type i) ecl_assert_throw_decl(StandardException) {
            ecl_assert_throw( i<buffer_size, StandardException(LOC,OutOfRangeError));
            return buffer[i];
        }
        const_reference operator[](size_type i) const ecl_assert_throw_decl(StandardException) {
            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 ( 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_ */

---

ecl_containers
Author(s): Daniel Stonier (d.stonier@gmail.com)
autogenerated on Fri Mar 1 15:21:03 2013