Index: /trunk/nv/stl/array.hh =================================================================== --- /trunk/nv/stl/array.hh (revision 433) +++ /trunk/nv/stl/array.hh (revision 434) @@ -15,7 +15,7 @@ #include -#include -#include -#include +#include +#include +#include namespace nv @@ -29,20 +29,16 @@ template< typename T > - using resizable_dynamic_storage = resizable_storage< dynamic_storage< T > >; + using resizable_dynamic_storage = sized_storage< dynamic_storage< T > >; template< typename T, size_t N > - using resizable_static_storage = resizable_storage< static_storage< T, N > >; + using resizable_static_storage = sized_storage< static_storage< T, N > >; template< typename T, size_t N > using array = - detail::add_random_access < - detail::add_iterators < - fixed_container_handler< fixed_static_storage< T, N > > > >; + random_access < fixed_static_storage< T, N > >; template< typename T > using dynamic_array = - detail::add_random_access < - detail::add_iterators < - sized_container_handler< resizable_dynamic_storage< T > > > >; + random_access < resizable_dynamic_storage< T > >; } Index: unk/nv/stl/container/contiguous_storage_policy.hh =================================================================== --- /trunk/nv/stl/container/contiguous_storage_policy.hh (revision 433) +++ (revision ) @@ -1,218 +1,0 @@ -// Copyright (C) 2015 ChaosForge Ltd -// http://chaosforge.org/ -// -// This file is part of Nova libraries. -// For conditions of distribution and use, see copying.txt file in root folder. - -/** -* @file contiguous_storage_policy.hh -* @author Kornel Kisielewicz epyon@chaosforge.org -* @brief contiguous storage policy classes -*/ - -#ifndef NV_STL_CONTAINER_CONTIGUOUS_STORAGE_POLICY -#define NV_STL_CONTAINER_CONTIGUOUS_STORAGE_POLICY - -#include -#include -#include - -namespace nv -{ - - template< typename Storage, size_t N > - class fixed_storage : public Storage - { - public: - typedef size_t size_type; - typedef typename Storage::value_type value_type; - - static constexpr bool is_fixed = true; - - fixed_storage() - { - Storage::reallocate( N, false ); - } - ~fixed_storage() - { - Storage::reallocate( 0, false ); - } - static constexpr size_type max_size() { return N; } - static constexpr size_type capacity() { return N; } - static constexpr size_type size() { return N; } - static constexpr bool empty() { return N == 0; } - static constexpr size_type raw_size() { return sizeof( value_type ) * N; } - - operator array_ref< value_type >() { return array_ref< value_type >( Storage::data(), size() ); } - operator array_view< value_type >() const { return array_view< value_type >( Storage::data(), size() ); } - - // allow move - fixed_storage( fixed_storage&& ) = default; - fixed_storage& operator=( fixed_storage&& ) = default; - - }; - - template< typename Storage > - class resizable_storage : public Storage - { - public: - typedef size_t size_type; - typedef typename Storage::value_type value_type; - - static constexpr bool is_fixed = false; - - ~resizable_storage() - { - if ( m_size > 0 ) Storage::reallocate( 0, false ); - } - static constexpr size_type max_size() { return size_type( 0x80000000 ); } - constexpr size_t capacity() const { return m_size; } - constexpr size_t size() const { return m_size; } - constexpr bool empty() const { return m_size == 0; } - constexpr size_t raw_size() const { return sizeof( value_type ) * m_size; } - - operator array_ref< value_type >() { return array_ref< value_type >( Storage::data(), size() ); } - operator array_view< value_type >() const { return array_view< value_type >( Storage::data(), size() ); } - - constexpr resizable_storage() : m_size( 0 ) {} - protected: - // allow move - inline resizable_storage( resizable_storage&& other ) - : Storage( nv::move( other ) ), m_size( other.m_size ) - { - other.m_size = 0; - } - inline resizable_storage& operator=( resizable_storage&& other ) - { - if ( m_size > 0 ) Storage::reallocate( 0, false ); - m_size = other.m_size; - Storage::operator=( nv::move( other ) ); - other.m_size = 0; - return *this; - } - - // TODO: return type error checking - bool try_resize( size_t new_size, bool copy_needed ) - { - if ( new_size != m_size ) - { - if ( Storage::reallocate( new_size, copy_needed ) ) - { - m_size = new_size; - return true; - } - return false; - } - return true; - } - protected: - size_type m_size; - }; - - template< typename SizeType > - struct default_next_capacity - { - static SizeType get( SizeType requested, SizeType capacity, SizeType max_size ) - { - SizeType minimum = nv::max( capacity, 4 ); - SizeType remaining = max_size - capacity; - if ( remaining < requested ) return 0; - SizeType additional = nv::max( requested, capacity ); - return nv::max( minimum, remaining < additional ? max_size : capacity + additional ); - } - }; - - template< typename Storage, typename NextCapacity = default_next_capacity< size_t > > - class growable_storage : public Storage - { - public: - typedef size_t size_type; - typedef typename Storage::value_type value_type; - - static constexpr bool is_fixed = false; - - ~growable_storage() - { - if ( m_capacity > 0 ) Storage::reallocate( 0, false ); - } - static constexpr size_type max_size() { return size_type( 0x80000000 ); } - constexpr size_t capacity() const { return m_capacity; } - constexpr size_t size() const { return m_size; } - constexpr bool empty() const { return m_size == 0; } - constexpr size_t raw_size() const { return sizeof( value_type ) * m_size; } - - operator array_ref< value_type >() { return array_ref< value_type >( Storage::data(), size() ); } - operator array_view< value_type >() const { return array_view< value_type >( Storage::data(), size() ); } - - constexpr growable_storage() : m_size( 0 ), m_capacity( 0 ) {} - protected: - // allow move - inline growable_storage( growable_storage&& other ) - : Storage( nv::move( other ) ), m_size( other.m_size ), m_capacity( other.m_capacity ) - { - other.m_size = 0; - other.m_capacity = 0; - } - inline growable_storage& operator=( growable_storage&& other ) - { - if ( m_capacity > 0 ) Storage::reallocate( 0, false ); - m_size = other.m_size; - m_capacity = other.m_capacity; - Storage::operator=( nv::move( other ) ); - other.m_size = 0; - other.m_capacity = 0; - return *this; - } - - // TODO: return type error checking - bool try_grow( size_t amount ) - { - size_type new_size = amount + m_size; - if ( new_size > m_capacity ) - { - size_type new_capacity = NextCapacity::get( new_size - m_capacity, m_capacity, max_size() ); - if ( new_capacity > 0 && Storage::reallocate( new_capacity, true ) ) - { - m_capacity = new_capacity; - } - else return false; - } - m_size = new_size; - return true; - } - // TODO: return type error checking - bool try_reserve( size_t new_capacity, bool copy_needed ) - { - if ( new_capacity > m_capacity ) - { - if ( new_capacity > 0 && Storage::reallocate( new_capacity, copy_needed ) ) - { - m_capacity = new_capacity; - } - else return false; - } - return true; - } - // TODO: return type error checking - bool try_resize( size_t new_size, bool copy_needed ) - { - if ( new_size > m_size ) - { - if ( try_reserve( new_size, copy_needed ) ) - { - m_size = new_size; - return true; - } - return false; - } - m_size = new_size; - return true; - } - protected: - size_type m_size; - size_type m_capacity; - }; - -} - -#endif // NV_STL_CONTAINER_CONTIGUOUS_STORAGE_POLICY Index: unk/nv/stl/container/fixed_container_handler.hh =================================================================== --- /trunk/nv/stl/container/fixed_container_handler.hh (revision 433) +++ (revision ) @@ -1,62 +1,0 @@ -// Copyright (C) 2015 ChaosForge Ltd -// http://chaosforge.org/ -// -// This file is part of Nova libraries. -// For conditions of distribution and use, see copying.txt file in root folder. - -/** -* @file fixed_container_handler.hh -* @author Kornel Kisielewicz epyon@chaosforge.org -* @brief fixed contiguous container handler -*/ - -#ifndef NV_STL_CONTAINER_FIXED_CONTAINER_HANDLER_HH -#define NV_STL_CONTAINER_FIXED_CONTAINER_HANDLER_HH - -#include -#include - -namespace nv -{ - - template < - typename Storage, - typename InitializePolicy = policy_initialize_standard - > - class fixed_container_handler : public Storage - { - public: - typedef typename Storage::value_type value_type; - typedef typename Storage::size_type size_type; - - fixed_container_handler() - { - InitializePolicy::initialize( Storage::data(), Storage::data() + Storage::capacity() ); - } - - explicit fixed_container_handler( default_init ) - { - uninitialized_construct( Storage::data(), Storage::data() + Storage::capacity() ); - } - - explicit fixed_container_handler( const value_type& v ) - { - uninitialized_fill( Storage::data(), Storage::data() + Storage::capacity(), v ); - } - - ~fixed_container_handler() - { - InitializePolicy::destroy( Storage::data(), Storage::data() + Storage::capacity() ); - } - - // prevent copying - fixed_container_handler( const fixed_container_handler& ) = delete; - fixed_container_handler& operator=( const fixed_container_handler& ) = delete; - // allow move - fixed_container_handler( fixed_container_handler&& ) = default; - fixed_container_handler& operator=( fixed_container_handler&& ) = default; - }; - -} - -#endif // NV_STL_CONTAINER_FIXED_CONTAINER_HANDLER_HH Index: /trunk/nv/stl/container/fixed_storage.hh =================================================================== --- /trunk/nv/stl/container/fixed_storage.hh (revision 434) +++ /trunk/nv/stl/container/fixed_storage.hh (revision 434) @@ -0,0 +1,76 @@ +// Copyright (C) 2015 ChaosForge Ltd +// http://chaosforge.org/ +// +// This file is part of Nova libraries. +// For conditions of distribution and use, see copying.txt file in root folder. + +/** +* @file fixed_storage.hh +* @author Kornel Kisielewicz epyon@chaosforge.org +* @brief fixed contiguous container handler +*/ + +#ifndef NV_STL_CONTAINER_FIXED_STORAGE_HH +#define NV_STL_CONTAINER_FIXED_STORAGE_HH + +#include +#include + +namespace nv +{ + + template < + typename Storage, + size_t N, + typename InitializePolicy = policy_initialize_standard + > + class fixed_storage : public Storage + { + public: + typedef size_t size_type; + typedef typename Storage::value_type value_type; + + static constexpr bool is_fixed = true; + + fixed_storage() + { + Storage::reallocate( N, false ); + InitializePolicy::initialize( Storage::data(), Storage::data() + N ); + } + + explicit fixed_storage( default_init ) + { + Storage::reallocate( 0, false ); + uninitialized_construct( Storage::data(), Storage::data() + N ); + } + + explicit fixed_storage( const value_type& v ) + { + uninitialized_fill( Storage::data(), Storage::data() + N, v ); + } + + static constexpr size_type max_size() { return N; } + static constexpr size_type capacity() { return N; } + static constexpr size_type size() { return N; } + static constexpr bool empty() { return N == 0; } + static constexpr size_type raw_size() { return sizeof( value_type ) * N; } + + operator array_ref< value_type >() { return array_ref< value_type >( Storage::data(), N ); } + operator array_view< value_type >() const { return array_view< value_type >( Storage::data(), N ); } + + ~fixed_storage() + { + InitializePolicy::destroy( Storage::data(), Storage::data() + N ); + } + + // prevent copying + fixed_storage( const fixed_storage& ) = delete; + fixed_storage& operator=( const fixed_storage& ) = delete; + // allow move + fixed_storage( fixed_storage&& ) = default; + fixed_storage& operator=( fixed_storage&& ) = default; + }; + +} + +#endif // NV_STL_CONTAINER_FIXED_STORAGE_HH Index: unk/nv/stl/container/growing_container_handler.hh =================================================================== --- /trunk/nv/stl/container/growing_container_handler.hh (revision 433) +++ (revision ) @@ -1,121 +1,0 @@ -// Copyright (C) 2015 ChaosForge Ltd -// http://chaosforge.org/ -// -// This file is part of Nova libraries. -// For conditions of distribution and use, see copying.txt file in root folder. - -/** -* @file growing_container_handler.hh -* @author Kornel Kisielewicz epyon@chaosforge.org -* @brief growing contiguous container handler -*/ - -#ifndef NV_STL_CONTAINER_GROWING_CONTAINER_HANDLER_HH -#define NV_STL_CONTAINER_GROWING_CONTAINER_HANDLER_HH - -#include -#include -#include - -namespace nv -{ - - template < - typename Storage, - typename InitializePolicy = policy_initialize_standard - > - class growing_container_handler : public sized_container_handler< Storage, InitializePolicy > - { - public: - typedef typename growing_container_handler< Storage, InitializePolicy > this_type; - typedef typename Storage::value_type value_type; - typedef typename Storage::size_type size_type; - typedef value_type* iterator; - typedef const value_type* const_iterator; - - using sized_container_handler< Storage, InitializePolicy >::sized_container_handler; - - void reserve( size_type new_capacity ) - { - Storage::try_reserve( new_capacity, true ); - } - void push_back( const value_type& e ) - { - if ( Storage::try_grow( 1 ) ) copy_construct_object( Storage::data() + Storage::size() - 1, e ); - } - void push_back( value_type&& e ) - { - if ( Storage::try_grow( 1 ) ) move_construct_object( Storage::data() + Storage::size() - 1, forward( e ) ); - } - template < typename... Args > - void emplace_back( Args&&... args ) - { - if ( Storage::try_grow( 1 ) ) construct_object( Storage::data() + Storage::size() - 1, forward( args )... ); - } - - void pop_back() - { - InitializePolicy::destroy( Storage::data() + Storage::size() - 1 ); - Storage::try_resize( Storage::size() - 1, true ); - } - - // TODO: implement swap_erase - iterator erase( iterator position ) - { - iterator iend = Storage::data() + Storage::size(); - InitializePolicy::destroy( position ); - if ( ( position + 1 ) < iend ) - raw_alias_copy( position + 1, iend, position ); - Storage::try_resize( Storage::size() - 1, true ); - return position; - } - - iterator erase( iterator first, iterator last ) - { - iterator iend = Storage::data() + Storage::size(); - InitializePolicy::destroy( first, last ); - iterator position = raw_alias_copy( last, iend, first ); - Storage::try_resize( Storage::size() - ( last - first ), true ); - return position; - } - - void append( const_iterator first, const_iterator last ) - { - // TODO: distance can't be called on destructive iterators - check - // and use pushback if needed? - size_type d = distance( first, last ); - size_type old_size = Storage::size(); - if ( Storage::try_grow( d ) ) - InitializePolicy::copy( first, last, Storage::data() + old_size ); - } - - // TODO: This can be much optimized in the grow case by copying in three parts - void insert( iterator position, const value_type& value ) - { - iterator iend = Storage::data() + Storage::size(); - if ( Storage::try_grow( 1 ) ) - { - raw_alias_copy( position, iend, position + 1 ); - copy_construct_object( position, value ); - } - } - - // TODO: This can be much optimized in the grow case by copying in three parts - void insert( iterator position, const_iterator first, const_iterator last ) - { - // TODO: distance can't be called on destructive iterators - check - // and use pushback if needed? - iterator iend = Storage::data() + Storage::size(); - size_type d = distance( first, last ); - if ( Storage::try_grow( d ) ) - { - raw_alias_copy( position, iend, position + d ); - InitializePolicy::copy( first, last, position ); - } - } - }; - -} - -#endif // #define NV_STL_CONTAINER_GROWING_CONTAINER_HANDLER_HH - Index: /trunk/nv/stl/container/growing_storage.hh =================================================================== --- /trunk/nv/stl/container/growing_storage.hh (revision 434) +++ /trunk/nv/stl/container/growing_storage.hh (revision 434) @@ -0,0 +1,303 @@ +// Copyright (C) 2015 ChaosForge Ltd +// http://chaosforge.org/ +// +// This file is part of Nova libraries. +// For conditions of distribution and use, see copying.txt file in root folder. + +/** +* @file growing_storage.hh +* @author Kornel Kisielewicz epyon@chaosforge.org +* @brief growing contiguous container handler +*/ + +#ifndef NV_STL_CONTAINER_GROWING_STORAGE_HH +#define NV_STL_CONTAINER_GROWING_STORAGE_HH + +#include +#include +#include + +namespace nv +{ + template< typename SizeType > + struct default_next_capacity + { + static SizeType get( SizeType requested, SizeType capacity, SizeType max_size ) + { + SizeType minimum = nv::max( capacity, 4 ); + SizeType remaining = max_size - capacity; + if ( remaining < requested ) return 0; + SizeType additional = nv::max( requested, capacity ); + return nv::max( minimum, remaining < additional ? max_size : capacity + additional ); + } + }; + + template < + typename Storage, + typename InitializePolicy = policy_initialize_standard, + typename NextCapacity = default_next_capacity< size_t > + > + class growing_storage : public Storage + { + public: + typedef typename Storage::value_type value_type; + typedef size_t size_type; + typedef value_type* iterator; + typedef const value_type* const_iterator; + + static constexpr bool is_fixed = false; + + static constexpr size_type max_size() { return size_type( 0x80000000 ); } + constexpr size_t capacity() const { return m_capacity; } + constexpr size_t size() const { return m_size; } + constexpr bool empty() const { return m_size == 0; } + constexpr size_t raw_size() const { return sizeof( value_type ) * m_size; } + + operator array_ref< value_type >() { return array_ref< value_type >( Storage::data(), size() ); } + operator array_view< value_type >() const { return array_view< value_type >( Storage::data(), size() ); } + + inline growing_storage() : m_size( 0 ), m_capacity( 0 ) {} + inline explicit growing_storage( size_type new_size ) : m_size( 0 ), m_capacity( 0 ) { resize( new_size ); } + inline explicit growing_storage( default_init ) : m_size( 0 ), m_capacity( 0 ) { resize( default_init() ); } + inline growing_storage( size_type new_size, const value_type& v ) : m_size( 0 ), m_capacity( 0 ) { resize( new_size, v ); } + + // prevent copying + growing_storage( const growing_storage& ) = delete; + growing_storage& operator=( const growing_storage& ) = delete; + + // allow move + growing_storage( growing_storage&& other ) + : Storage( nv::move( other ) ), m_size( other.m_size ), m_capacity( other.m_capacity ) + { + other.m_size = 0; + other.m_capacity = 0; + } + + inline growing_storage& operator=( growing_storage&& other ) + { + if ( m_capacity > 0 ) Storage::reallocate( 0, false ); + m_size = other.m_size; + m_capacity = other.m_capacity; + Storage::operator=( nv::move( other ) ); + other.m_size = 0; + other.m_capacity = 0; + return *this; + } + + void reserve( size_type new_capacity ) + { + try_reserve( new_capacity, true ); + } + + void push_back( const value_type& e ) + { + if ( try_grow( 1 ) ) copy_construct_object( Storage::data() + m_size - 1, e ); + } + void push_back( value_type&& e ) + { + if ( try_grow( 1 ) ) move_construct_object( Storage::data() + m_size - 1, forward( e ) ); + } + template < typename... Args > + void emplace_back( Args&&... args ) + { + if ( try_grow( 1 ) ) construct_object( Storage::data() + m_size - 1, forward( args )... ); + } + + void pop_back() + { + if ( m_size == 0 ) return; + InitializePolicy::destroy( Storage::data() + m_size - 1 ); + m_size--; + } + + // TODO: implement swap_erase + iterator erase( iterator position ) + { + if ( m_size == 0 ) return; + iterator iend = Storage::data() + m_size; + InitializePolicy::destroy( position ); + if ( ( position + 1 ) < iend ) + raw_alias_copy( position + 1, iend, position ); + m_size--; + return position; + } + + iterator erase( iterator first, iterator last ) + { + iterator iend = Storage::data() + m_size; + InitializePolicy::destroy( first, last ); + iterator position = raw_alias_copy( last, iend, first ); + m_size -= ( last - first ); + return position; + } + + void append( const_iterator first, const_iterator last ) + { + // TODO: distance can't be called on destructive iterators - check + // and use pushback if needed? + size_type d = distance( first, last ); + size_type old_size = m_size; + if ( try_grow( d ) ) + InitializePolicy::copy( first, last, Storage::data() + old_size ); + } + + // TODO: This can be much optimized in the grow case by copying in three parts + void insert( iterator position, const value_type& value ) + { + iterator iend = Storage::data() + m_size; + if ( try_grow( 1 ) ) + { + raw_alias_copy( position, iend, position + 1 ); + copy_construct_object( position, value ); + } + } + + // TODO: This can be much optimized in the grow case by copying in three parts + void insert( iterator position, const_iterator first, const_iterator last ) + { + // TODO: distance can't be called on destructive iterators - check + // and use pushback if needed? + iterator iend = Storage::data() + m_size; + size_type d = distance( first, last ); + if ( try_grow( d ) ) + { + raw_alias_copy( position, iend, position + d ); + InitializePolicy::copy( first, last, position ); + } + } + + inline void resize( size_type new_size ) + { + size_type old_size = m_size; + resize_impl( new_size ); + if ( m_size > old_size ) InitializePolicy::initialize( Storage::data() + old_size, Storage::data() + m_size ); + } + + inline void resize( size_type new_size, default_init ) + { + size_type old_size = m_size; + resize_impl( new_size ); + if ( m_size > old_size ) uninitialized_construct( Storage::data() + old_size, Storage::data() + m_size ); + } + + inline void resize( size_type new_size, const value_type& value ) + { + size_type old_size = m_size; + resize_impl( new_size ); + if ( m_size > old_size ) uninitialized_fill( Storage::data() + old_size, Storage::data() + m_size, value ); + } + + inline void assign( const value_type* ptr, size_type sz ) + { + if ( ptr != nullptr && sz > 0 ) + { + if ( try_resize( sz, false ) ) + InitializePolicy::copy( ptr, ptr + sz, Storage::data() ); + } + else m_size = 0; + } + + template< typename InputIterator > + inline void assign( InputIterator first, InputIterator last ) + { + // TODO: distance can't be called on destructive iterators - check + // and use pushback if needed? + if ( m_size > 0 ) InitializePolicy::destroy( Storage::data(), Storage::data() + m_size ); + size_type d = distance( first, last ); + if ( try_resize( d, false ) ) + InitializePolicy::copy( first, last, Storage::data() ); + } + + // explicit copy + inline void assign( const growing_storage& other ) + { + assign( other.data(), other.size() ); + } + + inline void clear() + { + if ( m_size > 0 ) + { + InitializePolicy::destroy( Storage::data(), Storage::data() + m_size ); + m_size = 0; + } + } + + ~growing_storage() + { + clear(); + Storage::reallocate( 0, false ); + } + + protected: + + inline void resize_impl( size_type new_size ) + { + size_type old_size = m_size; + if ( new_size != old_size ) + { + if ( new_size < old_size ) + { + InitializePolicy::destroy( Storage::data() + new_size, Storage::data() + old_size ); + } + if ( try_resize( new_size, true ) ) + { + // TODO: error checking + } + } + } + + // TODO: return type error checking + bool try_grow( size_t amount ) + { + size_type new_size = amount + m_size; + if ( new_size > m_capacity ) + { + size_type new_capacity = NextCapacity::get( new_size - m_capacity, m_capacity, max_size() ); + if ( new_capacity > 0 && Storage::reallocate( new_capacity, true ) ) + { + m_capacity = new_capacity; + } + else return false; + } + m_size = new_size; + return true; + } + // TODO: return type error checking + bool try_reserve( size_t new_capacity, bool copy_needed ) + { + if ( new_capacity > m_capacity ) + { + if ( new_capacity > 0 && Storage::reallocate( new_capacity, copy_needed ) ) + { + m_capacity = new_capacity; + } + else return false; + } + return true; + } + // TODO: return type error checking + bool try_resize( size_t new_size, bool copy_needed ) + { + if ( new_size > m_size ) + { + if ( try_reserve( new_size, copy_needed ) ) + { + m_size = new_size; + return true; + } + return false; + } + m_size = new_size; + return true; + } + protected: + size_type m_size; + size_type m_capacity; + + }; + +} + +#endif // NV_STL_CONTAINER_GROWING_STORAGE_HH + Index: /trunk/nv/stl/container/initialize_policy.hh =================================================================== --- /trunk/nv/stl/container/initialize_policy.hh (revision 433) +++ /trunk/nv/stl/container/initialize_policy.hh (revision 434) @@ -21,4 +21,9 @@ struct default_init + { + + }; + + struct struct_policy_initialize_base { @@ -49,4 +54,16 @@ }; + struct policy_initialize_standard : policy_initialize_always + { + template < typename ForwardIterator > + inline static void initialize( ForwardIterator first, ForwardIterator last ) + { + typedef typename iterator_traits< ForwardIterator >::value_type value_type; + if ( !has_trivial_constructor() ) + detail::uninitialized_construct_impl( first, last, false_type() ); + } + }; + + struct policy_initialize_never { @@ -70,34 +87,4 @@ }; - struct policy_initialize_standard - { - template < typename ForwardIterator > - inline static void initialize( ForwardIterator first, ForwardIterator last ) - { - typedef typename iterator_traits< ForwardIterator >::value_type value_type; - if ( !has_trivial_constructor() ) - detail::uninitialized_construct_impl( first, last, false_type() ); - } - template < typename InputIterator, typename ForwardIterator > - inline static ForwardIterator copy( InputIterator first, InputIterator last, ForwardIterator out ) - { - return uninitialized_copy( first, last, out ); - } - template < typename ForwardIterator > - inline static void destroy( ForwardIterator first, ForwardIterator last ) - { - typedef typename iterator_traits< ForwardIterator >::value_type value_type; - if ( !has_trivial_destructor() ) - detail::uninitialized_destroy_impl( first, last, false_type() ); - } - template < typename ForwardIterator > - inline static void destroy( ForwardIterator first ) - { - typedef typename iterator_traits< ForwardIterator >::value_type value_type; - if ( !has_trivial_destructor() ) - destroy_object( first ); - } - }; - } Index: unk/nv/stl/container/sized_container_handler.hh =================================================================== --- /trunk/nv/stl/container/sized_container_handler.hh (revision 433) +++ (revision ) @@ -1,141 +1,0 @@ -// Copyright (C) 2015 ChaosForge Ltd -// http://chaosforge.org/ -// -// This file is part of Nova libraries. -// For conditions of distribution and use, see copying.txt file in root folder. - -/** -* @file sized_container_handler.hh -* @author Kornel Kisielewicz epyon@chaosforge.org -* @brief sized contiguous container handler -*/ - -#ifndef NV_STL_CONTAINER_SIZED_CONTAINER_HANDLER_HH -#define NV_STL_CONTAINER_SIZED_CONTAINER_HANDLER_HH - -#include -#include - -namespace nv -{ - - template < - typename Storage, - typename InitializePolicy = policy_initialize_standard - > - class sized_container_handler : public Storage - { - public: - typedef typename Storage::value_type value_type; - typedef typename Storage::size_type size_type; - - inline sized_container_handler() {} - inline explicit sized_container_handler( size_type new_size ) { resize( new_size ); } - inline explicit sized_container_handler( default_init ) { resize( default_init() ); } - inline sized_container_handler( size_type new_size, const value_type& v ) { resize( new_size, v ); } - - // prevent copying - sized_container_handler( const sized_container_handler& ) = delete; - sized_container_handler& operator=( const sized_container_handler& ) = delete; - // allow move - sized_container_handler( sized_container_handler&& ) = default; - sized_container_handler& operator=( sized_container_handler&& ) = default; - - - inline void resize( size_type new_size ) - { - size_type old_size = Storage::size(); - resize_impl( new_size ); - initialize_range( old_size, Storage::size() ); - } - - inline void resize( size_type new_size, default_init ) - { - size_type old_size = Storage::size(); - resize_impl( new_size ); - initialize_range( old_size, Storage::size(), default_init() ); - } - - inline void resize( size_type new_size, const value_type& value ) - { - size_type old_size = Storage::size(); - resize_impl( new_size ); - initialize_range( old_size, Storage::size(), value ); - } - - inline void assign( const value_type* ptr, size_type sz ) - { - if ( Storage::size() > 0 ) InitializePolicy::destroy( Storage::data(), Storage::data() + Storage::size() ); - if ( ptr != nullptr && sz > 0 ) - { - if ( sz != Storage::size() && Storage::try_resize( sz, false ) ) - InitializePolicy::copy( ptr, ptr + sz, Storage::data() ); - } - else Storage::try_resize( 0, false ); - } - - template< typename InputIterator > - inline void assign( InputIterator first, InputIterator last ) - { - // TODO: distance can't be called on destructive iterators - check - // and use pushback if needed? - size_type d = distance( first, last ); - if ( d != Storage::size() && Storage::try_resize( d, false ) ) - InitializePolicy::copy( first, last, Storage::data() ); - } - - // explicit copy - inline void assign( const sized_container_handler& other ) - { - assign( other.data(), other.size() ); - } - - inline void clear() - { - if ( Storage::size() > 0 ) - { - InitializePolicy::destroy( Storage::data(), Storage::data() + Storage::size() ); - Storage::try_resize( 0, false ); - } - } - - ~sized_container_handler() - { - if ( Storage::size() > 0 ) clear(); - } - - protected: - - inline void initialize_range( size_type old_size, size_type new_size ) - { - if ( new_size > old_size ) InitializePolicy::initialize( Storage::data() + old_size, Storage::data() + new_size ); - } - inline void initialize_range( size_type old_size, size_type new_size, default_init ) - { - if ( new_size > old_size ) uninitialized_construct( Storage::data() + old_size, Storage::data() + new_size ); - } - inline void initialize_range( size_type old_size, size_type new_size, const value_type& value ) - { - if ( new_size > old_size ) uninitialized_fill( Storage::data() + old_size, Storage::data() + new_size, value ); - } - inline void resize_impl( size_type new_size ) - { - size_type old_size = Storage::size(); - if ( new_size != old_size ) - { - if ( new_size < old_size ) - { - InitializePolicy::destroy( Storage::data() + new_size, Storage::data() + old_size ); - } - if ( Storage::try_resize( new_size, true ) ) - { - // TODO: error checking - } - } - } - - }; - -} - -#endif // NV_STL_CONTAINER_SIZED_CONTAINER_HANDLER_HH Index: /trunk/nv/stl/container/sized_storage.hh =================================================================== --- /trunk/nv/stl/container/sized_storage.hh (revision 434) +++ /trunk/nv/stl/container/sized_storage.hh (revision 434) @@ -0,0 +1,167 @@ +// Copyright (C) 2015 ChaosForge Ltd +// http://chaosforge.org/ +// +// This file is part of Nova libraries. +// For conditions of distribution and use, see copying.txt file in root folder. + +/** +* @file sized_storage.hh +* @author Kornel Kisielewicz epyon@chaosforge.org +* @brief sized contiguous container handler +*/ + +#ifndef NV_STL_CONTAINER_SIZED_STORAGE_HH +#define NV_STL_CONTAINER_SIZED_STORAGE_HH + +#include +#include + +namespace nv +{ + + template < + typename Storage, + typename InitializePolicy = policy_initialize_standard + > + class sized_storage : public Storage + { + public: + typedef size_t size_type; + typedef typename Storage::value_type value_type; + + static constexpr bool is_fixed = false; + + static constexpr size_type max_size() { return size_type( 0x80000000 ); } + constexpr size_t capacity() const { return m_size; } + constexpr size_t size() const { return m_size; } + constexpr bool empty() const { return m_size == 0; } + constexpr size_t raw_size() const { return sizeof( value_type ) * m_size; } + + operator array_ref< value_type >() { return array_ref< value_type >( Storage::data(), m_size ); } + operator array_view< value_type >() const { return array_view< value_type >( Storage::data(), m_size ); } + + constexpr sized_storage() : m_size( 0 ) {} + inline explicit sized_storage( size_type new_size ) : m_size( 0 ) { resize( new_size ); } + inline explicit sized_storage( default_init ) : m_size( 0 ) { resize( default_init() ); } + inline sized_storage( size_type new_size, const value_type& v ) : m_size( 0 ) { resize( new_size, v ); } + + // prevent copying + sized_storage( const sized_storage& ) = delete; + sized_storage& operator=( const sized_storage& ) = delete; + // allow move + // allow move + inline sized_storage( sized_storage&& other ) + : Storage( nv::move( other ) ), m_size( other.m_size ) + { + other.m_size = 0; + } + inline sized_storage& operator=( sized_storage&& other ) + { + if ( m_size > 0 ) Storage::reallocate( 0, false ); + m_size = other.m_size; + Storage::operator=( nv::move( other ) ); + other.m_size = 0; + return *this; + } + + inline void resize( size_type new_size ) + { + size_type old_size = m_size; + resize_impl( new_size ); + if ( m_size > old_size ) InitializePolicy::initialize( Storage::data() + old_size, Storage::data() + m_size ); + } + + inline void resize( size_type new_size, default_init ) + { + size_type old_size = m_size; + resize_impl( new_size ); + if ( m_size > old_size ) uninitialized_construct( Storage::data() + old_size, Storage::data() + m_size ); + } + + inline void resize( size_type new_size, const value_type& value ) + { + size_type old_size = m_size; + resize_impl( new_size ); + if ( m_size > old_size ) uninitialized_fill( Storage::data() + old_size, Storage::data() + m_size, value ); + } + + inline void assign( const value_type* ptr, size_type sz ) + { + if ( m_size > 0 ) InitializePolicy::destroy( Storage::data(), Storage::data() + m_size ); + if ( ptr != nullptr && sz > 0 ) + { + if ( try_resize( sz, false ) ) + InitializePolicy::copy( ptr, ptr + sz, Storage::data() ); + } + else try_resize( 0, false ); + } + + template< typename InputIterator > + inline void assign( InputIterator first, InputIterator last ) + { + // TODO: distance can't be called on destructive iterators - check + // and use pushback if needed? + size_type d = distance( first, last ); + if ( try_resize( d, false ) ) + InitializePolicy::copy( first, last, Storage::data() ); + } + + // explicit copy + inline void assign( const sized_storage& other ) + { + assign( other.data(), other.size() ); + } + + inline void clear() + { + if ( m_size > 0 ) + { + InitializePolicy::destroy( Storage::data(), Storage::data() + m_size ); + try_resize( 0, false ); + } + } + + ~sized_storage() + { + clear(); + } + + protected: + + // TODO: return type error checking + bool try_resize( size_t new_size, bool copy_needed ) + { + if ( new_size != m_size ) + { + if ( Storage::reallocate( new_size, copy_needed ) ) + { + m_size = new_size; + return true; + } + return false; + } + return true; + } + + inline void resize_impl( size_type new_size ) + { + size_type old_size = m_size; + if ( new_size != old_size ) + { + if ( new_size < old_size ) + { + InitializePolicy::destroy( Storage::data() + new_size, Storage::data() + old_size ); + } + if ( try_resize( new_size, true ) ) + { + // TODO: error checking + } + } + } + protected: + size_type m_size; + }; + +} + +#endif // NV_STL_CONTAINER_SIZED_STORAGE_HH Index: /trunk/nv/stl/memory.hh =================================================================== --- /trunk/nv/stl/memory.hh (revision 433) +++ /trunk/nv/stl/memory.hh (revision 434) @@ -19,4 +19,5 @@ #include #include +#include #include #include @@ -416,125 +417,4 @@ } - namespace detail - { - - template < typename Super, bool Const = Super::is_const > - class add_iterators {}; - - template < typename Super > - class add_iterators < Super, true > : public Super - { - public: - typedef typename Super::value_type value_type; - typedef const value_type* iterator; - typedef nv::reverse_iterator reverse_iterator; - typedef const value_type* const_iterator; - typedef nv::reverse_iterator const_reverse_iterator; - - using Super::Super; - - inline const_iterator begin() const { return const_iterator( Super::data() ); } - inline const_iterator end() const { return const_iterator( Super::data() + Super::size() ); } - inline const_iterator cbegin() const { return const_iterator( Super::data() ); } - inline const_iterator cend() const { return const_iterator( Super::data() + Super::size() ); } - inline const_reverse_iterator rbegin() const { return const_reverse_iterator( end() ); } - inline const_reverse_iterator crbegin() const { return const_reverse_iterator( end() ); } - inline const_reverse_iterator rend() const { return const_reverse_iterator( begin() ); } - inline const_reverse_iterator crend() const { return const_reverse_iterator( begin() ); } - inline const_iterator iat( size_t i ) const { NV_ASSERT( i <= Super::size(), "Index out of range" ); return begin() + i; } - }; - - template < typename Super > - class add_iterators < Super, false > : public Super - { - public: - typedef typename Super::value_type value_type; - typedef value_type* iterator; - typedef const value_type* const_iterator; - typedef nv::reverse_iterator reverse_iterator; - typedef nv::reverse_iterator const_reverse_iterator; - - using Super::Super; - - inline const_iterator begin() const { return const_iterator( Super::data() ); } - inline const_iterator end() const { return const_iterator( Super::data() + Super::size() ); } - inline iterator begin() { return iterator( Super::data() ); } - inline iterator end() { return iterator( Super::data() + Super::size() ); } - inline const_iterator cbegin() const { return const_iterator( Super::data() ); } - inline const_iterator cend() const { return const_iterator( Super::data() + Super::size() ); } - inline reverse_iterator rbegin() { return reverse_iterator( end() ); } - inline const_reverse_iterator rbegin() const { return const_reverse_iterator( end() ); } - inline const_reverse_iterator crbegin() const { return const_reverse_iterator( end() ); } - inline reverse_iterator rend() { return reverse_iterator( begin() ); } - inline const_reverse_iterator rend() const { return const_reverse_iterator( begin() ); } - inline const_reverse_iterator crend() const { return const_reverse_iterator( begin() ); } - inline const_iterator iat( size_t i ) const { NV_ASSERT( i <= Super::size(), "Index out of range" ); return begin() + i; } - inline iterator iat( size_t i ) { NV_ASSERT( i <= Super::size(), "Index out of range" ); return begin() + i; } - }; - - template < typename Super, bool Const = Super::is_const > - class add_random_access {}; - - template < typename Super > - class add_random_access < Super, true > : public Super - { - public: - typedef typename Super::value_type value_type; - typedef typename Super::size_type size_type; - typedef const value_type* const_iterator; - typedef value_type& reference; - typedef const value_type& const_reference; - - using Super::Super; - - inline const_reference front() const { NV_ASSERT( !Super::empty(), "front() called on empty data!" ); return Super::data()[0]; } - inline const_reference back() const { NV_ASSERT( !Super::empty(), "front() called on empty data!" ); return Super::data()[Super::size() - 1]; } - - const_reference operator[]( size_type i ) const - { - NV_ASSERT( i < Super::size(), "Out of range" ); - return Super::data()[i]; - } - }; - - template < typename Super > - class add_random_access < Super, false > : public Super - { - public: - typedef typename Super::value_type value_type; - typedef typename Super::size_type size_type; - typedef value_type* iterator; - typedef const value_type* const_iterator; - typedef value_type& reference; - typedef const value_type& const_reference; - - using Super::Super; - - inline reference front() { NV_ASSERT( !Super::empty(), "front() called on empty data!" ); return Super::data()[0]; } - inline const_reference front() const { NV_ASSERT( !Super::empty(), "front() called on empty data!" ); return Super::data()[0]; } - inline reference back() { NV_ASSERT( !Super::empty(), "front() called on empty data!" ); return Super::data()[Super::size() - 1]; } - inline const_reference back() const { NV_ASSERT( !Super::empty(), "front() called on empty data!" ); return Super::data()[Super::size() - 1]; } - - reference operator[]( size_type i ) - { - NV_ASSERT( i < Super::size(), "Out of range" ); - return Super::data()[i]; - } - - const_reference operator[]( size_type i ) const - { - NV_ASSERT( i < Super::size(), "Out of range" ); - return Super::data()[i]; - } - - inline void fill( const value_type& value ) - { - fill_n( iterator( Super::data() ), iterator( Super::data() + this->size() ), value ); - } - - }; - - } - } Index: /trunk/nv/stl/string/short_string.hh =================================================================== --- /trunk/nv/stl/string/short_string.hh (revision 433) +++ /trunk/nv/stl/string/short_string.hh (revision 434) @@ -9,4 +9,35 @@ #include +#include +#include +#include +#include + +namespace nv +{ + template < typename Storage > + class string_buffer_ops : Storage + { + + }; + + template < typename T, size_t N > + using short_string = + string_buffer_ops< + random_access < + string_base< + growing_storage< + static_storage< T, N > > > > >; + + template < typename T > + using buffer_string = + string_buffer_ops< + random_access < + string_base< + growing_storage< + dynamic_storage< T > > > > >; + + +} #endif // NV_STL_STRING_SHORT_STRING_HH Index: /trunk/nv/stl/vector.hh =================================================================== --- /trunk/nv/stl/vector.hh (revision 433) +++ /trunk/nv/stl/vector.hh (revision 434) @@ -15,7 +15,7 @@ #include +#include #include -#include -#include +#include namespace nv @@ -23,14 +23,13 @@ template< typename T > - using growable_dynamic_storage = growable_storage< dynamic_storage< T > >; + using growable_dynamic_storage = growing_storage< dynamic_storage< T > >; template< typename T, size_t N > - using growable_static_storage = growable_storage< static_storage< T, N > >; + using growable_static_storage = growing_storage< static_storage< T, N > >; template< typename T > using vector = - detail::add_random_access < - detail::add_iterators < - growing_container_handler< growable_dynamic_storage< T > > > >; + random_access < + growable_dynamic_storage< T > >; }