Scarab  v3.4.1
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 merge( const param_array& an_array );
112 
113  void erase( unsigned a_index );
114  param_ptr_t remove( unsigned a_index );
115  void clear();
116 
117  iterator begin();
118  const_iterator begin() const;
119 
120  iterator end();
121  const_iterator end() const;
122 
123  reverse_iterator rbegin();
124  const_reverse_iterator rbegin() const;
125 
126  reverse_iterator rend();
127  const_reverse_iterator rend() const;
128 
129  virtual std::string to_string() const;
130 
131  protected:
132  contents f_contents;
133  };
134 
135 
136  template< typename XValType >
137  XValType param_array::get_value( unsigned a_index, XValType a_default ) const
138  {
139  return a_index < size() ? operator[]( a_index ).as_value().as< XValType >() : a_default;
140  }
141 
143  {
144  return std::unique_ptr< param_array >( new param_array( *this ) );
145  }
146 
148  {
149  return std::unique_ptr< param_array >( new param_array( std::move( *this ) ) );
150  }
151 
152  inline bool param_array::is_null() const
153  {
154  return false;
155  }
156 
157  inline bool param_array::is_array() const
158  {
159  return true;
160  }
161 
162  inline unsigned param_array::size() const
163  {
164  return f_contents.size();
165  }
166  inline bool param_array::empty() const
167  {
168  return f_contents.empty();
169  }
170 
171  inline std::string param_array::get_value( unsigned a_index, const std::string& a_default ) const
172  {
173  return a_index < size() ? operator[]( a_index ).to_string() : a_default;
174  }
175 
176  inline std::string param_array::get_value( unsigned a_index, const char* a_default ) const
177  {
178  return get_value( a_index, std::string( a_default ) );
179  }
180 
181  inline const param& param_array::operator[]( unsigned a_index ) const
182  {
183  return *f_contents.at( a_index );
184  }
185  inline param& param_array::operator[]( unsigned a_index )
186  {
187  return *f_contents.at( a_index );
188  }
189 
190  inline const param& param_array::front() const
191  {
192  return *f_contents.front();
193  }
195  {
196  return *f_contents.front();
197  }
198 
199  inline const param& param_array::back() const
200  {
201  return *f_contents.back();
202  }
204  {
205  return *f_contents.back();
206  }
207 
208  // assign a copy of a_value to the array at a_index
209  inline void param_array::assign( unsigned a_index, const param& a_value )
210  {
211  erase( a_index );
212  f_contents.at( a_index ) = a_value.clone();
213  return;
214  }
215  // directly move a_value to the array at a_index
216  inline void param_array::assign( unsigned a_index, param&& a_value )
217  {
218  erase( a_index );
219  f_contents.at( a_index ) = a_value.move_clone();
220  return;
221  }
222  // directly assign a_value_ptr to the array at a_index
223  inline void param_array::assign( unsigned a_index, param_ptr_t a_value_ptr )
224  {
225  erase( a_index );
226  f_contents.at( a_index ) = std::move(a_value_ptr);
227  return;
228  }
229  // directly move a_value to the array at a_index
230  template< typename T, typename std::enable_if< std::is_convertible< T, param_value >::value, T >::type* >
231  inline void param_array::assign( unsigned a_index, T a_value )
232  {
233  erase( a_index );
234  f_contents.at( a_index ) = param_ptr_t( new param_value( a_value ) );
235  return;
236  }
237 
238  inline void param_array::push_back( const param& a_value )
239  {
240  f_contents.push_back( a_value.clone() );
241  return;
242  }
243  inline void param_array::push_back( param&& a_value )
244  {
245  f_contents.push_back( a_value.move_clone() );
246  return;
247  }
248  inline void param_array::push_back( param_ptr_t a_value_ptr )
249  {
250  f_contents.push_back( std::move(a_value_ptr) );
251  return;
252  }
253  template< typename T, typename std::enable_if< std::is_convertible< T, param_value >::value, T >::type* >
254  inline void param_array::push_back( T a_value )
255  {
256  f_contents.push_back( param_ptr_t( new param_value( a_value ) ) );
257  return;
258  }
259 
260  inline void param_array::push_front( const param& a_value )
261  {
262  f_contents.push_front( a_value.clone() );
263  return;
264  }
265  inline void param_array::push_front( param&& a_value )
266  {
267  f_contents.push_front( a_value.move_clone() );
268  return;
269  }
270  inline void param_array::push_front( param_ptr_t a_value_ptr )
271  {
272  f_contents.push_front( std::move(a_value_ptr) );
273  return;
274  }
275  template< typename T, typename std::enable_if< std::is_convertible< T, param_value >::value, T >::type* >
276  inline void param_array::push_front( T a_value )
277  {
278  f_contents.push_front( param_ptr_t( new param_value( a_value ) ) );
279  return;
280  }
281 
282  inline void param_array::append( const param_array& an_array )
283  {
284  for( const_iterator it = const_iterator(an_array.begin()); it != const_iterator(an_array.end()); ++it )
285  {
286  push_back( *it );
287  }
288  return;
289  }
290 
291  inline void param_array::erase( unsigned a_index )
292  {
293  f_contents.at( a_index ).reset();
294  return;
295  }
296  inline param_ptr_t param_array::remove( unsigned a_index )
297  {
298  param_ptr_t t_current( std::move( f_contents.at( a_index ) ) );
299  return t_current;
300  }
301  inline void param_array::clear()
302  {
303  f_contents.clear();
304  return;
305  }
306 
308  {
309  return iterator( f_contents.begin() );
310  }
312  {
313  return const_iterator( f_contents.cbegin() );
314  }
315 
317  {
318  return iterator( f_contents.end() );
319  }
321  {
322  return const_iterator( f_contents.cend() );
323  }
324 
326  {
327  return f_contents.rbegin();
328  }
330  {
331  return f_contents.rbegin();
332  }
333 
335  {
336  return f_contents.rend();
337  }
339  {
340  return f_contents.crend();
341  }
342 
343  SCARAB_API std::ostream& operator<<(std::ostream& out, const param_array& value);
344 
345 } /* namespace scarab */
346 
347 #endif /* SCARAB_PARAM_ARRAY_HH_ */
virtual bool is_null() const
Definition: param_array.hh:152
std::deque< std::unique_ptr< param > > param_array_contents
Definition: param_array.hh:24
virtual param_ptr_t clone() const
boost::indirect_iterator< param_array_contents::iterator, param > param_array_iterator
Definition: param_array.hh:28
param_array_iterator iterator
Definition: param_array.hh:35
void push_front(const param &a_value)
Definition: param_array.hh:260
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:147
std::string type(const x_type &a_param)
Definition: typename.hh:24
const param & back() const
Definition: param_array.hh:199
contents::const_reverse_iterator const_reverse_iterator
Definition: param_array.hh:38
const param & operator[](unsigned a_index) const
Definition: param_array.hh:181
virtual bool is_array() const
Definition: param_array.hh:157
void append(const param_array &an_array)
Definition: param_array.hh:282
param_array_contents contents
Definition: param_array.hh:34
param_ptr_t remove(unsigned a_index)
Definition: param_array.hh:296
bool empty() const
Definition: param_array.hh:166
reverse_iterator rend()
Definition: param_array.hh:334
std::string get_value(unsigned a_index, const std::string &a_default) const
Definition: param_array.hh:171
reverse_iterator rbegin()
Definition: param_array.hh:325
SCARAB_API std::ostream & operator<<(std::ostream &out, const param_array &a_value)
Definition: param_array.cc:167
std::unique_ptr< param > param_ptr_t
Definition: param_base.hh:23
void erase(unsigned a_index)
Definition: param_array.hh:291
void assign(unsigned a_index, const param &a_value)
Definition: param_array.hh:209
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:238
virtual param_ptr_t clone() const
Definition: param_array.hh:142
const param & front() const
Definition: param_array.hh:190
contents::value_type contents_type
Definition: param_array.hh:39
auto to_string(T &&value) -> decltype(std::forward< T >(value))
Convert an object to a string (directly forward if this can become a string)
Definition: CLI11.hpp:1028
unsigned size() const
Definition: param_array.hh:162