source: trunk/nv/stl/array.hh @ 368

Last change on this file since 368 was 368, checked in by epyon, 10 years ago
  • massive restructuring
  • detail::data_base class for container/reference class base
File size: 7.0 KB
Line 
1// Copyright (C) 2014 ChaosForge Ltd
2// http://chaosforge.org/
3//
4// This file is part of NV Libraries.
5// For conditions of distribution and use, see copyright notice in nv.hh
6
7/**
8 * @file array.hh
9 * @author Kornel Kisielewicz epyon@chaosforge.org
10 * @brief exception free array classes
11 */
12
13#ifndef NV_CORE_ARRAY_HH
14#define NV_CORE_ARRAY_HH
15
16#include <nv/core/common.hh>
17#include <nv/stl/memory.hh>
18#include <vector>
19#include <algorithm>
20#include <array>
21
22namespace nv
23{
24        using std::vector;
25        using std::array;
26
27        template< class T, std::size_t N >
28        class static_array : public detail::data_base< T, false, N >
29        {
30        public:
31                typedef T              value_type;
32                typedef T*             iterator;
33                typedef const T*       const_iterator;
34                typedef T&             reference;
35                typedef const T&       const_reference;
36                typedef std::size_t    size_type;
37                typedef std::ptrdiff_t difference_type;
38
39                typedef std::reverse_iterator<iterator>       reverse_iterator;
40                typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
41
42//              iterator        begin()        { return m_data; }
43//              const_iterator  begin()  const { return m_data; }
44//              const_iterator  cbegin() const { return m_data; }
45//
46//              iterator        end()        { return m_data+N; }
47//              const_iterator  end()  const { return m_data+N; }
48//              const_iterator  cend() const { return m_data+N; }
49//
50//              reverse_iterator rbegin()              { return reverse_iterator( end() ); }
51//              const_reverse_iterator rbegin() const  { return const_reverse_iterator( end() ); }
52//              const_reverse_iterator crbegin() const { return const_reverse_iterator( end() ); }
53//
54//              reverse_iterator rend()                { return reverse_iterator( begin() ); }
55//              const_reverse_iterator rend() const    { return const_reverse_iterator( begin() ); }
56//              const_reverse_iterator crend() const   { return const_reverse_iterator( begin() ); }
57
58                reference operator[]( size_type i )
59                {
60                        NV_ASSERT( i < N, "Out of range" );
61                        return this->m_data[i];
62                }
63
64                const_reference operator[]( size_type i ) const
65                {     
66                        NV_ASSERT( i < N, "Out of range" );
67                        return this->m_data[i];
68                }
69
70//              reference       front()       { return m_data[0]; }
71//              const_reference front() const { return m_data[0]; }
72//              reference       back()        { return m_data[N-1]; }
73//              const_reference back() const  { return m_data[N-1]; }
74//
75//              static size_type size()     { return N; }
76//              static bool      empty()    { return false; }
77//              static size_type max_size() { return N; }
78//
79//              const value_type* data() const { return m_data; }
80//              value_type*       data()       { return m_data; }
81//
82//              size_type   raw_size() const { return N * ELEMENT_SIZE; }
83//              const char* raw_data() const { return (const char*)m_data; }
84//              char*       raw_data()       { return (char*)m_data; }
85
86                void assign( const value_type& value ) { std::fill_n( this->begin(), this->size(), value ); }
87
88                static const size_type SIZE = N;
89                static const size_type ELEMENT_SIZE = sizeof(T);
90        };
91
92        template< class T >
93        class dynamic_array : public detail::data_base< T, false, 0 >
94        {
95        public:
96                typedef T              value_type;
97                typedef T*             iterator;
98                typedef const T*       const_iterator;
99                typedef T&             reference;
100                typedef const T&       const_reference;
101                typedef std::size_t    size_type;
102                typedef std::ptrdiff_t difference_type;
103
104                typedef std::reverse_iterator<iterator>       reverse_iterator;
105                typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
106
107                dynamic_array() : detail::data_base< T, false, 0 >() {}
108//                      : m_data( nullptr ), m_size(0) {}
109                explicit dynamic_array( size_type new_size ) : detail::data_base< T, false, 0 >( new value_type[new_size], new_size ) {}
110//                      : m_data( new value_type[ new_size ] ), m_size( new_size ) {}
111                dynamic_array( const value_type& value, size_type size ) : detail::data_base< T, false, 0 >()
112//                      : m_data( nullptr ), m_size(0)
113                { assign( value, size ); }
114                dynamic_array( const_iterator values, size_type size ) : detail::data_base< T, false, 0 >()
115//                      : m_data( nullptr ), m_size(0)
116                { assign( values, size ); }
117
118                void resize( size_type new_size )
119                {
120                        if ( new_size != this->m_size )
121                        {
122                                value_type* old_data = this->m_data;
123                                this->m_data = new_size > 0 ? new value_type[new_size] : nullptr;
124                                if ( old_data && this->m_data )
125                                {
126                                        std::copy_n( old_data, new_size > this->m_size ? this->m_size : new_size, this->m_data );
127                                }
128                                delete[] old_data;
129                                this->m_size = new_size;
130                        }
131                }
132
133//              iterator        begin()        { return m_data; }
134//              const_iterator  begin()  const { return m_data; }
135//              const_iterator  cbegin() const { return m_data; }
136//
137//              iterator        end()        { return m_data+m_size; }
138//              const_iterator  end()  const { return m_data+m_size; }
139//              const_iterator  cend() const { return m_data+m_size; }
140//
141//              reverse_iterator rbegin()              { return reverse_iterator( end() ); }
142//              const_reverse_iterator rbegin() const  { return const_reverse_iterator( end() ); }
143//              const_reverse_iterator crbegin() const { return const_reverse_iterator( end() ); }
144//
145//              reverse_iterator rend()                { return reverse_iterator( begin() ); }
146//              const_reverse_iterator rend() const    { return const_reverse_iterator( begin() ); }
147//              const_reverse_iterator crend() const   { return const_reverse_iterator( begin() ); }
148
149                reference operator[]( size_type i )
150                {
151                        NV_ASSERT( i < this->m_size, "Out of range" );
152                        return this->m_data[i];
153                }
154
155                const_reference operator[]( size_type i ) const
156                {     
157                        NV_ASSERT( i < this->m_size, "Out of range" );
158                        return this->m_data[i];
159                }
160
161//              reference       front()       { return m_data[0]; }
162//              const_reference front() const { return m_data[0]; }
163//              reference       back()        { return m_data[m_size-1]; }
164//              const_reference back() const  { return m_data[m_size-1]; }
165//
166//              size_type        size() const     { return m_size; }
167//              bool             empty() const    { return m_size == 0; }
168//              static size_type max_size()       { return std::numeric_limits< size_type >::max(); }
169//              const value_type* data() const { return m_data; }
170//              value_type*       data()       { return m_data; }
171//
172//              size_type   raw_size() const { return m_size * ELEMENT_SIZE; }
173//              const char* raw_data() const { return (const char*)m_data; }
174//              char*       raw_data()       { return (char*)m_data; }
175
176                void assign( const value_type& value ) { std::fill_n( this->begin(), this->size(), value ); }
177                void assign( const value_type& value, size_type new_size )
178                {
179                        resize( new_size );
180                        std::fill_n( this->begin(), this->size(), value );
181                }
182                void assign( const_iterator values, size_type new_size )
183                {
184                        resize( new_size );
185                        std::copy_n( values, this->size(), this->m_data );
186                }
187
188                ~dynamic_array() { delete[] this->m_data; }
189
190                static const size_type ELEMENT_SIZE = sizeof(T);
191        };
192
193}
194
195#endif // NV_CORE_ARRAY_HH
Note: See TracBrowser for help on using the repository browser.