array_no_mem_check.hpp
Go to the documentation of this file.
1 
8 /*****************************************************************************
9 ** Ifdefs
10 *****************************************************************************/
11 
12 #ifndef ECL_CONTAINERS_ARRAY_NO_MEM_CHECK_HPP_
13 #define ECL_CONTAINERS_ARRAY_NO_MEM_CHECK_HPP_
14 #ifndef ECL_MEM_CHECK_ARRAYS
15 
16 /*****************************************************************************
17 ** Includes
18 *****************************************************************************/
19 
20 #include <algorithm> // std::copy
21 #include <cstddef> // size_t
22 #include <iterator>
23 #include "../definitions.hpp"
24 #include "../initialiser.hpp"
25 #include "../stencil.hpp"
26 #include <ecl/config/macros.hpp>
27 #include <ecl/concepts/macros.hpp>
29 #include <ecl/concepts/streams.hpp>
32 
33 /*****************************************************************************
34 ** Namespaces
35 *****************************************************************************/
36 
37 namespace ecl {
38 
39 /*****************************************************************************
40 ** Forward Declarations
41 *****************************************************************************/
42 
43 namespace blueprints {
44 
45 template <typename Type, size_t N> class ArrayFactory;
46 template <typename Derived> class ArrayBluePrint;
47 template <typename Type, size_t Size> class ConstantArray;
48 
49 } // namespace blueprints
50 
51 namespace formatters {
52 
53 template <typename Type, size_t N> class ArrayFormatter;
54 
55 } // namespace formatters
56 
57 /*****************************************************************************
58 ** Interface [Array][Fixed]
59 *****************************************************************************/
105 template<typename Type, std::size_t Size = DynamicStorage>
106 class ECL_PUBLIC Array : public blueprints::ArrayFactory<Type,Size> {
107  public:
108  /*********************
109  ** Typedefs
110  **********************/
111  typedef Type value_type;
112  typedef Type* iterator;
113  typedef const Type* const_iterator;
114  typedef Type& reference;
115  typedef const Type& const_reference;
116  typedef std::size_t size_type;
117  typedef std::ptrdiff_t difference_type;
118  typedef std::reverse_iterator<iterator> reverse_iterator;
119  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
123  /*********************
124  ** Constructors
125  **********************/
130  Array() {};
153  template<typename T>
156  blueprint.implementApply(*this);
157  }
158 
159  virtual ~Array() {};
160 
161  /*********************
162  ** Assignment
163  **********************/
179  }
180 
181  /*********************
182  ** Iterators
183  **********************/
188  iterator begin() { return elements; }
193  const_iterator begin() const { return elements; }
198  iterator end() { return elements+Size; }
203  const_iterator end() const { return elements+Size; }
208  reverse_iterator rbegin() { return reverse_iterator(end()); }
213  const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
218  reverse_iterator rend() { return reverse_iterator(begin()); }
223  const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
224 
225  /*********************
226  ** Front/Back
227  **********************/
232  reference front() { return elements[0]; }
237  const_reference front() const { return elements[0]; }
242  reference back() { return elements[Size-1]; }
247  const_reference back() const { return elements[Size-1]; }
248 
249  /*********************
250  ** Accessors
251  **********************/
263  Stencil< Array<Type,Size> > stencil(const unsigned int& start_index, const unsigned int& n) {
264  ecl_assert_throw(start_index < Size, StandardException(LOC, OutOfRangeError, "Start index provided is larger than the underlying array size."));
265  ecl_assert_throw(start_index+n <= Size, StandardException(LOC, OutOfRangeError, "Finish index provided is larger than the underlying array size."));
266  return Stencil< Array<Type,Size> >(*this, begin()+start_index, begin()+start_index+n);
267  }
268 
278  reference operator[](size_type i) {
280  return elements[i];
281  }
293  const_reference operator[](size_type i) const {
295  return elements[i];
296  }
307  reference at(size_type i) {
308  if ( i>=Size ) {
310  }
311  return elements[i];
312  }
325  const_reference at(size_type i) const {
326  if ( i>=Size ) {
328  }
329  return elements[i];
330  }
331 
332  /*********************
333  ** Utilities
334  **********************/
340  static size_type size() { return Size; }
341 
342  /*********************
343  ** Streaming
344  **********************/
352  template <typename OutputStream, typename ElementType, size_t ArraySize>
353  friend OutputStream& operator<<(OutputStream &ostream , const Array<ElementType,ArraySize> &array);
354 
355  private:
356  value_type elements[Size];
357 };
358 
359 /*****************************************************************************
360 ** Implementation [Array][Insertion Operators]
361 *****************************************************************************/
362 
363 template <typename OutputStream, typename ElementType, size_t ArraySize>
364 OutputStream& operator<<(OutputStream &ostream , const Array<ElementType,ArraySize> &array) {
365 
367 
368  ostream << "[ ";
369  for(size_t i = 0; i < ArraySize; ++i )
370  {
371  ostream << array[i] << " ";
372  }
373  ostream << "]";
374  ostream.flush();
375 
376  return ostream;
377 }
378 
379 
380 /*****************************************************************************
381 ** BluePrints
382 *****************************************************************************/
383 
384 namespace blueprints {
385 
410 template <typename Derived>
411 class ArrayBluePrint {
412  public:
425  template <typename BaseType>
426  BaseType implementInstantiate() {
427  return static_cast<Derived*>(this)->instantiate();
428  }
442  template <typename BaseType>
443  void implementApply(BaseType& array) const {
444  static_cast<const Derived*>(this)->apply(array);
445  }
446 
447  virtual ~ArrayBluePrint() {}
448 };
457 template <typename Type, size_t Size>
458 class ConstantArray : public ArrayBluePrint< ConstantArray<Type, Size> > {
459  public:
472  ConstantArray(const Type& value = 0) : val(value) {}
473 
474  virtual ~ConstantArray() {};
475 
486  base_type instantiate() {
487  ecl::Array<Type,Size> array;
488  std::fill_n(array.begin(),Size,val);
489  return array;
490  }
491 
496  void apply(base_type& array) const {
497  std::fill_n(array.begin(),Size,val);
498  }
499 
500  private:
501  const Type& val;
502 };
503 
512 template<typename Type, size_t Size>
513 class ArrayFactory {
514  public:
521  static ConstantArray<Type,Size> Constant(const Type& value) {
522  return ConstantArray<Type,Size>(value);
523  }
524 
525  virtual ~ArrayFactory() {};
526 };
527 
528 } // namespace blueprints
529 } // namespace ecl
530 
531 #endif /* !ECL_MEM_CHECK_ARRAYS */
532 #endif /* ECL_CONTAINERS_ARRAY_NO_MEM_CHECK_HPP_ */
Fixed size container with a few bells and whistles.
const Type * const_iterator
const_reference front() const
Blueprint for instantiating/configuring an array filled with a constant.
Embedded control libraries.
Parent class for array blueprints.
BluePrint factory for the Array class.
OutputStream & operator<<(OutputStream &ostream, Format< std::string > &formatter)
ConstantArray(const Type &value=0)
Constructor that properly configures/initialises the blueprint.
blueprints::ArrayFactory< value_type, Size > Factory
Generates blueprints for this class.
reverse_iterator rbegin()
const_reference back() const
ecl::Array< Type, Size > base_type
Abstract representation of the class to be instantiated/configured.
#define LOC
reverse_iterator rend()
std::reverse_iterator< iterator > reverse_iterator
reference at(size_type i)
const_reference at(size_type i) const
std::ptrdiff_t difference_type
const_reference operator[](size_type i) const
#define ecl_assert_throw(expression, exception)
OutOfRangeError
const Type & const_reference
base_type instantiate()
Instantiate a copy of the object that is blueprinted.
Stencil< Array< Type, Size > > stencil(const unsigned int &start_index, const unsigned int &n)
Open a window (stencil) onto the array.
const_iterator begin() const
Pseudo formatter for integral type arrays.
std::reverse_iterator< const_iterator > const_reverse_iterator
Convenience initialiser with bounds checking for fixed size containers.
Definition: initialiser.hpp:49
static size_type size()
void apply(base_type &array) const
A safe windowing class that opens onto array-like containers.
#define ecl_compile_time_concept_check(Model)
static ConstantArray< Type, Size > Constant(const Type &value)
const_reverse_iterator rend() const
reference operator[](size_type i)
reference back()
Array(const blueprints::ArrayBluePrint< T > &blueprint)
Blueprint constructor.
reference front()
std::size_t size_type
formatters::ArrayFormatter< Type, Size > Formatter
Formatter for this class.
void implementApply(BaseType &array) const
const_iterator end() const
#define ECL_PUBLIC
const_reverse_iterator rbegin() const


ecl_containers
Author(s): Daniel Stonier
autogenerated on Mon Feb 28 2022 22:18:43