Scarab  v2.2.3
Project 8 C++ Utility Library
param_array.hh
Go to the documentation of this file.
1 /*
2  * param_array.hh
3  *
4  * Created on: Jan 14, 2014
5  * Author: nsoblath
6  */
7 
8 #ifndef SCARAB_PARAM_ARRAY_HH_
9 #define SCARAB_PARAM_ARRAY_HH_
10 
11 #include "param_value.hh"
12 
13 #include <boost/iterator/iterator_adaptor.hpp>
14 #include <boost/type_traits/is_convertible.hpp>
15 #include <boost/utility/enable_if.hpp>
16 #include <boost/iterator/indirect_iterator.hpp>
17 
18 #include <deque>
19 
20 
21 namespace scarab
22 {
23  class param_value;
24  class param_node;
25 
26  typedef std::deque< std::unique_ptr< param > > param_array_contents;
27 
28  typedef boost::indirect_iterator< param_array_contents::iterator, param > param_array_iterator;
29  typedef boost::indirect_iterator< param_array_contents::const_iterator, const param > param_array_const_iterator;
30 
31  class SCARAB_API param_array : public param
32  {
33  public:
34  typedef param_array_contents contents;
35  typedef param_array_iterator iterator;
36  typedef param_array_const_iterator const_iterator;
37  typedef contents::reverse_iterator reverse_iterator;
38  typedef contents::const_reverse_iterator const_reverse_iterator;
39  typedef contents::value_type contents_type;
40 
41  public:
42  param_array();
43  param_array( const param_array& orig );
44  param_array( param_array&& orig );
45  virtual ~param_array();
46 
47  param_array& operator=( const param_array& rhs );
48  param_array& operator=( param_array&& rhs );
49 
50  virtual param_ptr_t clone() const;
51  virtual param_ptr_t move_clone();
52 
53  virtual bool is_null() const;
54  virtual bool is_array() const;
55 
56  virtual bool has_subset( const param& a_subset ) const;
57 
58  unsigned size() const;
59  bool empty() const;
60 
63  void resize( unsigned a_size );
64 
67  std::string get_value( unsigned a_index, const std::string& a_default ) const;
68  std::string get_value( unsigned a_index, const char* a_default ) const;
71  template< typename XValType >
72  XValType get_value( unsigned a_index, XValType a_default ) const;
73 
76  const param& operator[]( unsigned a_index ) const;
79  param& operator[]( unsigned a_index );
80 
81  const param& front() const;
82  param& front();
83 
84  const param& back() const;
85  param& back();
86 
87  // assign a copy of a_value to the array at a_index
88  void assign( unsigned a_index, const param& a_value );
89  // directly assign a_value to the array at a_index
90  void assign( unsigned a_index, param&& a_value );
91  // directly assign a_value_ptr to the array at a_index
92  void assign( unsigned a_index, param_ptr_t a_value_ptr );
93  // directly assign a_value to the array at a_index for any type that param_value accepts
94  template< typename T, typename std::enable_if< std::is_convertible< T, param_value >::value, T >::type* = nullptr >
95  void assign( unsigned a_index, T a_value );
96 
97  void push_back( const param& a_value );
98  void push_back( param&& a_value );
99  void push_back( param_ptr_t a_value_ptr );
100  template< typename T, typename std::enable_if< std::is_convertible< T, param_value >::value, T >::type* = nullptr >
101  void push_back( T a_value );
102 
103  void push_front( const param& a_value );
104  void push_front( param&& a_value );
105  void push_front( param_ptr_t a_value_ptr );
106  template< typename T, typename std::enable_if< std::is_convertible< T, param_value >::value, T >::type* = nullptr >
107  void push_front( T a_value );
108 
109  void append( const param_array& an_array );
110 
111  void erase( unsigned a_index );
112  param_ptr_t remove( unsigned a_index );
113  void clear();
114 
115  iterator begin();
116  const_iterator begin() const;
117 
118  iterator end();
119  const_iterator end() const;
120 
121  reverse_iterator rbegin();
122  const_reverse_iterator rbegin() const;
123 
124  reverse_iterator rend();
125  const_reverse_iterator rend() const;
126 
127  virtual std::string to_string() const;
128 
129  protected:
130  contents f_contents;
131  };
132 
133 
134  template< typename XValType >
135  XValType param_array::get_value( unsigned a_index, XValType a_default ) const
136  {
137  return a_index < size() ? operator[]( a_index ).as_value().as< XValType >() : a_default;
138  }
139 
141  {
142  return std::unique_ptr< param_array >( new param_array( *this ) );
143  }
144 
146  {
147  return std::unique_ptr< param_array >( new param_array( std::move( *this ) ) );
148  }
149 
150  inline bool param_array::is_null() const
151  {
152  return false;
153  }
154 
155  inline bool param_array::is_array() const
156  {
157  return true;
158  }
159 
160  inline unsigned param_array::size() const
161  {
162  return f_contents.size();
163  }
164  inline bool param_array::empty() const
165  {
166  return f_contents.empty();
167  }
168 
169  inline void param_array::resize( unsigned a_size )
170  {
171  f_contents.resize( a_size );
172  return;
173  }
174 
175  inline std::string param_array::get_value( unsigned a_index, const std::string& a_default ) const
176  {
177  return a_index < size() ? operator[]( a_index ).to_string() : a_default;
178  }
179 
180  inline std::string param_array::get_value( unsigned a_index, const char* a_default ) const
181  {
182  return get_value( a_index, std::string( a_default ) );
183  }
184 
185  inline const param& param_array::operator[]( unsigned a_index ) const
186  {
187  return *f_contents.at( a_index );
188  }
189  inline param& param_array::operator[]( unsigned a_index )
190  {
191  return *f_contents.at( a_index );
192  }
193 
194  inline const param& param_array::front() const
195  {
196  return *f_contents.front();
197  }
199  {
200  return *f_contents.front();
201  }
202 
203  inline const param& param_array::back() const
204  {
205  return *f_contents.back();
206  }
208  {
209  return *f_contents.back();
210  }
211 
212  // assign a copy of a_value to the array at a_index
213  inline void param_array::assign( unsigned a_index, const param& a_value )
214  {
215  erase( a_index );
216  f_contents[ a_index ] = a_value.clone();
217  return;
218  }
219  // directly move a_value to the array at a_index
220  inline void param_array::assign( unsigned a_index, param&& a_value )
221  {
222  erase( a_index );
223  f_contents[ a_index ] = a_value.move_clone();
224  return;
225  }
226  // directly assign a_value_ptr to the array at a_index
227  inline void param_array::assign( unsigned a_index, param_ptr_t a_value_ptr )
228  {
229  erase( a_index );
230  f_contents[ a_index ] = std::move(a_value_ptr);
231  return;
232  }
233  // directly move a_value to the array at a_index
234  template< typename T, typename std::enable_if< std::is_convertible< T, param_value >::value, T >::type* >
235  inline void param_array::assign( unsigned a_index, T a_value )
236  {
237  erase( a_index );
238  f_contents[ a_index ] = param_ptr_t( new param_value( a_value ) );
239  return;
240  }
241 
242  inline void param_array::push_back( const param& a_value )
243  {
244  f_contents.push_back( a_value.clone() );
245  return;
246  }
247  inline void param_array::push_back( param&& a_value )
248  {
249  f_contents.push_back( a_value.move_clone() );
250  return;
251  }
252  inline void param_array::push_back( param_ptr_t a_value_ptr )
253  {
254  f_contents.push_back( std::move(a_value_ptr) );
255  return;
256  }
257  template< typename T, typename std::enable_if< std::is_convertible< T, param_value >::value, T >::type* >
258  inline void param_array::push_back( T a_value )
259  {
260  f_contents.push_back( param_ptr_t( new param_value( a_value ) ) );
261  return;
262  }
263 
264  inline void param_array::push_front( const param& a_value )
265  {
266  f_contents.push_front( a_value.clone() );
267  return;
268  }
269  inline void param_array::push_front( param&& a_value )
270  {
271  f_contents.push_front( a_value.move_clone() );
272  return;
273  }
274  inline void param_array::push_front( param_ptr_t a_value_ptr )
275  {
276  f_contents.push_front( std::move(a_value_ptr) );
277  return;
278  }
279  template< typename T, typename std::enable_if< std::is_convertible< T, param_value >::value, T >::type* >
280  inline void param_array::push_front( T a_value )
281  {
282  f_contents.push_front( param_ptr_t( new param_value( a_value ) ) );
283  return;
284  }
285 
286  inline void param_array::append( const param_array& an_array )
287  {
288  for( const_iterator it = const_iterator(an_array.begin()); it != const_iterator(an_array.end()); ++it )
289  {
290  push_back( *it );
291  }
292  return;
293  }
294 
295  inline void param_array::erase( unsigned a_index )
296  {
297  f_contents[ a_index ].reset();
298  return;
299  }
300  inline param_ptr_t param_array::remove( unsigned a_index )
301  {
302  param_ptr_t t_current( std::move( f_contents[ a_index ] ) );
303  return t_current;
304  }
305  inline void param_array::clear()
306  {
307  f_contents.clear();
308  return;
309  }
310 
312  {
313  return iterator( f_contents.begin() );
314  }
316  {
317  return const_iterator( f_contents.cbegin() );
318  }
319 
321  {
322  return iterator( f_contents.end() );
323  }
325  {
326  return const_iterator( f_contents.cend() );
327  }
328 
330  {
331  return f_contents.rbegin();
332  }
334  {
335  return f_contents.rbegin();
336  }
337 
339  {
340  return f_contents.rend();
341  }
343  {
344  return f_contents.crend();
345  }
346 
347  SCARAB_API std::ostream& operator<<(std::ostream& out, const param_array& value);
348 
349 } /* namespace scarab */
350 
351 #endif /* SCARAB_PARAM_ARRAY_HH_ */
std::deque< std::unique_ptr< param > > param_array_contents
Definition: param_array.hh:24
boost::indirect_iterator< param_array_contents::iterator, param > param_array_iterator
Definition: param_array.hh:28
std::string get_value(unsigned a_index, const std::string &a_default) const
Definition: param_array.hh:175
param_array_iterator iterator
Definition: param_array.hh:35
void push_front(const param &a_value)
Definition: param_array.hh:264
boost::indirect_iterator< param_array_contents::const_iterator, const param > param_array_const_iterator
Definition: param_array.hh:29
#define SCARAB_API
Definition: scarab_api.hh:24
virtual param_ptr_t move_clone()
Definition: param_array.hh:145
virtual bool is_array() const
Definition: param_array.hh:155
std::string type(const x_type &a_param)
Definition: typename.hh:22
virtual param_ptr_t clone() const
Definition: param_array.hh:140
virtual bool is_null() const
Definition: param_array.hh:150
contents::const_reverse_iterator const_reverse_iterator
Definition: param_array.hh:38
unsigned size() const
Definition: param_array.hh:160
void append(const param_array &an_array)
Definition: param_array.hh:286
param_array_contents contents
Definition: param_array.hh:34
param_ptr_t remove(unsigned a_index)
Definition: param_array.hh:300
bool empty() const
Definition: param_array.hh:164
reverse_iterator rend()
Definition: param_array.hh:338
reverse_iterator rbegin()
Definition: param_array.hh:329
SCARAB_API std::ostream & operator<<(std::ostream &out, const param_array &a_value)
Definition: param_array.cc:112
std::unique_ptr< param > param_ptr_t
Definition: param_base.hh:23
const param & operator[](unsigned a_index) const
Definition: param_array.hh:185
std::string to_string(std::uint64_t x)
Definition: date.h:7722
const param & front() const
Definition: param_array.hh:194
void erase(unsigned a_index)
Definition: param_array.hh:295
void assign(unsigned a_index, const param &a_value)
Definition: param_array.hh:213
contents::reverse_iterator reverse_iterator
Definition: param_array.hh:37
param_array_const_iterator const_iterator
Definition: param_array.hh:36
void push_back(const param &a_value)
Definition: param_array.hh:242
contents::value_type contents_type
Definition: param_array.hh:39
virtual param_ptr_t clone() const
const param & back() const
Definition: param_array.hh:203
void resize(unsigned a_size)
Definition: param_array.hh:169