Program Listing for File ArraySequence.h

↰ Return to documentation for file (ADS/sequence/ArraySequence.h)

/*--------------------------------------------------------------------------*/
/*-------------------------- File ArraySequence.h --------------------------*/
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
/*----------------------------- DEFINITIONS --------------------------------*/
/*--------------------------------------------------------------------------*/

#ifndef __ADS_ArraySequence
 #define __ADS_ArraySequence
                      /* self-identification: #endif constant */

/*--------------------------------------------------------------------------*/
/*------------------------------ INCLUDES ----------------------------------*/
/*--------------------------------------------------------------------------*/

#include "ADS/Contract.h"

#include <cstddef>
#include <initializer_list>
#include <iterator>
#include <memory>
#include <utility>

/*--------------------------------------------------------------------------*/
/*--------------------------- NAMESPACE ------------------------------------*/
/*--------------------------------------------------------------------------*/

namespace ADS {

/*--------------------------------------------------------------------------*/
/*------------------------- CLASS ArraySequence ----------------------------*/
/*--------------------------------------------------------------------------*/

template< class T >
class ArraySequence {

/*--------------------------------------------------------------------------*/
 public:

 using Item = T;
 using Pos = long;

 ArraySequence( void );

 ArraySequence( std::initializer_list< T > items );

 template< std::input_iterator I , std::sentinel_for< I > S >
 ArraySequence( I first , S last );

 ArraySequence( const ArraySequence & other );

 ArraySequence( ArraySequence && other ) noexcept;

 ArraySequence & operator=( ArraySequence other ) noexcept;

/*--------------------------------------------------------------------------*/
/*-------------------------- THE SEQUENCE ----------------------------------*/
/*--------------------------------------------------------------------------*/

 [[nodiscard]] bool empty( void ) const;

 [[nodiscard]] bool finished( Pos p ) const;

 [[nodiscard]] Pos head( void ) const;

 [[nodiscard]] Pos tail( void ) const;

 [[nodiscard]] Pos next( Pos p ) const;

 [[nodiscard]] Pos prev( Pos p ) const;

 Pos insert( Pos p , const T & v );

 Pos remove( Pos p );

 [[nodiscard]] const T & read( Pos p ) const;

 void write( Pos p , const T & v );

/*--------------------------------------------------------------------------*/
/*---------------------------- BEYOND THE BOOK -----------------------------*/
/*--------------------------------------------------------------------------*/

 [[nodiscard]] Pos size( void ) const;

 [[nodiscard]] Pos capacity( void ) const;

 [[nodiscard]] bool operator==( const ArraySequence & o ) const;

/*------------------------- THE STANDARD INTERFACE -------------------------*/

 // the items are contiguous, so that the iterators are pointers and every
 // algorithm of the standard library and of Boost applies; a change made
 // through them bypasses the audits of write()

 using value_type = T;
 using size_type = std::size_t;
 using difference_type = std::ptrdiff_t;
 using reference = T &;
 using const_reference = const T &;
 using pointer = T *;
 using const_pointer = const T *;
 using iterator = T *;
 using const_iterator = const T *;
 using reverse_iterator = std::reverse_iterator< iterator >;
 using const_reverse_iterator = std::reverse_iterator< const_iterator >;

 [[nodiscard]] iterator begin( void ) { return( f_A.get() ); }
 [[nodiscard]] iterator end( void ) { return( f_A.get() + f_size ); }
 [[nodiscard]] const_iterator begin( void ) const { return( f_A.get() ); }
 [[nodiscard]] const_iterator end( void ) const {
  return( f_A.get() + f_size );
  }
 [[nodiscard]] const_iterator cbegin( void ) const { return( begin() ); }
 [[nodiscard]] const_iterator cend( void ) const { return( end() ); }
 [[nodiscard]] reverse_iterator rbegin( void ) {
  return( reverse_iterator( end() ) );
  }
 [[nodiscard]] reverse_iterator rend( void ) {
  return( reverse_iterator( begin() ) );
  }
 [[nodiscard]] const_reverse_iterator rbegin( void ) const {
  return( const_reverse_iterator( end() ) );
  }
 [[nodiscard]] const_reverse_iterator rend( void ) const {
  return( const_reverse_iterator( begin() ) );
  }

 [[nodiscard]] T * data( void ) { return( f_A.get() ); }
 [[nodiscard]] const T * data( void ) const { return( f_A.get() ); }

 [[nodiscard]] T & operator[]( Pos i );
 [[nodiscard]] const T & operator[]( Pos i ) const;

 void push_back( const T & v );

/*--------------------------------------------------------------------------*/
 private:

 [[nodiscard]] bool fits( void ) const;

 [[nodiscard]] bool same( const ArraySequence & o , Pos i , Pos j ,
                          Pos k ) const;

 void resize( Pos c );

 std::unique_ptr< T[] > f_A;
 Pos f_size;
 Pos f_capacity;

 };  // end( class ArraySequence )

/*--------------------------------------------------------------------------*/

}  // end( namespace ADS )

/*--------------------------------------------------------------------------*/
/*-------------------------- IMPLEMENTATION --------------------------------*/
/*--------------------------------------------------------------------------*/

#include "ADS/sequence/impl/ArraySequence.tpp"

/*--------------------------------------------------------------------------*/

#endif  /* ArraySequence.h included */

/*--------------------------------------------------------------------------*/
/*------------------------ End File ArraySequence.h ------------------------*/
/*--------------------------------------------------------------------------*/