KJB
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
l_word_list.h
Go to the documentation of this file.
1 
10 /*
11  * $Id: l_word_list.h 17287 2014-08-13 23:56:14Z predoehl $
12  */
13 
14 #ifndef WRAP_KJB_WORD_LIST_H
15 #define WRAP_KJB_WORD_LIST_H
16 
17 #include "l/l_sys_io.h"
18 #include "l/l_word_list.h"
19 #include "l_cpp/l_exception.h"
20 
21 #ifdef MAC_OSX
22 # include <stddef.h>
23 #endif
24 
25 #include <vector>
26 #include <string>
27 #include <algorithm>
28 #include <functional>
29 #include <iterator>
30 
31 namespace kjb
32 {
33 
60 class Word_list
61 {
62  kjb_c::Word_list *m_word_list;
63 
64  // Basic predicate to match a C++ string to a C string.
65  // We need this because we need the test as to whether wl_word equals null.
66  //
67  // This class wouldn't be necessary -- we could use std::bind2nd -- but in
68  // some old versions of GCC it is broken, so we wrote this functor by hand.
69  struct pred_matcher
70  {
71  pred_matcher(const std::string& target) : target_(&target) {}
72 
73  bool operator()(const char* wl_word)
74  {
75  return wl_word && *target_ == wl_word;
76  }
77  private:
78  const std::string* target_;
79  };
80 
81  // I think we need this for the argc/argv ctor
82  static void append_f( Word_list* wl, const char* cstring )
83  {
84  wl -> append( cstring );
85  }
86 
87 public:
88 
110  const char* pattern,
111  int (*filter)(const char*) = kjb_c::is_file
112  )
113  : m_word_list( 0 )
114  {
115  int rc = kjb_c::kjb_glob( & m_word_list, pattern, filter );
116  if ( rc != kjb_c::NO_ERROR )
117  {
118  KJB_THROW_2( Result_error, "Bad glob" );
119  }
120  NTX( m_word_list );
121  }
122 
135  const std::string& pattern,
136  int (*filter)(const char*) = kjb_c::is_file
137  )
138  : m_word_list( 0 )
139  {
140  Word_list similar( pattern.c_str(), filter );
141  std::swap( m_word_list, similar.m_word_list );
142  }
143 
148  Word_list( int num_words = 0 )
149  : m_word_list( 0 )
150  {
151  ETX( kjb_c::get_target_word_list( &m_word_list, num_words ) );
152  NTX( m_word_list );
153  }
154 
156  Word_list( int argc, const char* const* argv )
157  : m_word_list( 0 )
158  {
159  ETX( kjb_c::get_target_word_list( &m_word_list, argc ) );
160  NTX( m_word_list );
161  std::for_each( argv, argv+argc,
162  std::bind1st(std::ptr_fun(append_f),this) );
163  }
164 
169  Word_list( const Word_list& that )
170  : m_word_list( 0 )
171  {
172  ETX( kjb_c::copy_word_list( &m_word_list, that.m_word_list ) );
173  NTX( m_word_list );
174  }
175 
180  Word_list& operator=( const Word_list& that )
181  {
182  if ( this != &that )
183  {
184  Word_list coppie( that );
185  std::swap( m_word_list, coppie.m_word_list );
186  }
187  return *this;
188  }
189 
198  size_t size() const
199  {
200  NTX( m_word_list );
201  return m_word_list -> num_words;
202  }
203 
205  int count_strings() const
206  {
207  return kjb_c::count_strings_in_word_list( m_word_list );
208  }
209 
213  const kjb_c::Word_list* c_ptr() const
214  {
215  NTX( m_word_list );
216  return m_word_list;
217  }
218 
227  size_t match( const std::string& word ) const
228  {
229  NTX( m_word_list );
230  const char* const* const WLW = m_word_list -> words;
231  const char* const* const fp = std::find_if(WLW, WLW + size(),
232  pred_matcher(word) );
233  return fp - WLW;
234  }
235 
241  const char* operator[]( size_t index ) const
242  {
243  NTX( m_word_list );
244  if ( size() <= index )
245  {
247  }
248  return m_word_list -> words[ index ];
249  }
250 
263  void append( const std::string& word )
264  {
265  ETX( kjb_c::append_word_list( &m_word_list, word.c_str() ) );
266  }
267 
270  {
271  ETX( kjb_c::trim_word_list_empty_entries_at_tail( m_word_list ) );
272  }
273 
275  operator std::vector< std::string >() const
276  {
277  NTX( m_word_list );
278  std::vector< std::string > vvv( size() );
279  const char* const* const WLW = m_word_list -> words;
280  std::copy( WLW, WLW + size(), vvv.begin() );
281  return vvv;
282  }
283 
285  Word_list operator+( const Word_list& that ) const
286  {
287  Word_list result;
288  std::vector< const kjb_c::Word_list* > input( 2 );
289  input[ 0 ] = m_word_list;
290  input[ 1 ] = that.m_word_list;
291  ETX( kjb_c::concat_word_lists(&result.m_word_list, 2, &input.front()));
292  return result;
293  }
294 
297  {
298  free_word_list( m_word_list );
299  }
300 
302  //class const_iterator : public std::iterator< std::input_iterator_tag,
303  // void, void, void, const char* >
305  public std::iterator<
306  std::bidirectional_iterator_tag,
307  char*,
308  ptrdiff_t,
309  char* const*,
310  char* const&>
311  {
312  size_t m_index;
313  const kjb_c::Word_list* m_list;
314 
315  public:
316  const_iterator( size_t iii, const kjb_c::Word_list* www )
317  : m_index( iii ), m_list( www )
318  {}
319 
321  {
322  ++m_index;
323  return *this;
324  }
325 
327  {
328  const_iterator tmp(*this);
329  operator++();
330  return tmp;
331  }
332 
334  {
335  --m_index;
336  return *this;
337  }
338 
340  {
341  const_iterator tmp(*this);
342  operator--();
343  return tmp;
344  }
345 
346  reference operator*() const
347  {
348  return m_list->words[m_index];
349  }
350 
351  bool operator==(const const_iterator& iii) const
352  {
353  return m_index == iii.m_index && m_list == iii.m_list;
354  }
355 
356  bool operator!=(const const_iterator& iii) const
357  {
358  return m_index != iii.m_index || m_list != iii.m_list;
359  }
360  };
361 
364  {
365  return cbegin();
366  }
367 
370  {
371  return cend();
372  }
373 
376  {
377  return const_iterator( 0, m_word_list );
378  }
379 
382  {
383  return const_iterator( size(), m_word_list );
384  }
385 };
386 
387 } // namespace kjb
388 
389 #endif
390 
size_t match(const std::string &word) const
Searches the word list for an entry, looking for an exact match.
Definition: l_word_list.h:227
const_iterator operator++(int)
Definition: l_word_list.h:326
Word_list(const char *pattern, int(*filter)(const char *)=kjb_c::is_file)
Construct by searching for a Glob pattern, seeking files.
Definition: l_word_list.h:109
const_iterator & operator++()
Definition: l_word_list.h:320
#define ETX(a)
Definition: l_exception.h:67
Word_list(int argc, const char *const *argv)
construct a word list from an "argv" style array of arguments.
Definition: l_word_list.h:156
const_iterator begin() const
synonym for cbegin
Definition: l_word_list.h:363
Object thrown when an index argument exceeds the size of a container.
Definition: l_exception.h:399
int count_strings() const
return the number of non-empty entries in the list
Definition: l_word_list.h:205
reference operator*() const
Definition: l_word_list.h:346
Wrapper for the libKJB type Word_list (useful for globs).
Definition: l_word_list.h:60
#define KJB_THROW(ex)
Definition: l_exception.h:46
Word_list operator+(const Word_list &that) const
concatenate two word lists
Definition: l_word_list.h:285
const_iterator operator--(int)
Definition: l_word_list.h:339
#define NTX(a)
Definition: l_exception.h:89
Object thrown when a function cannot generate a valid result.
Definition: l_exception.h:516
Word_list & operator=(const Word_list &that)
assignment operator deep-copies contents of given list.
Definition: l_word_list.h:180
bool operator!=(const const_iterator &iii) const
Definition: l_word_list.h:356
const_iterator(size_t iii, const kjb_c::Word_list *www)
Definition: l_word_list.h:316
const kjb_c::Word_list * c_ptr() const
Return the underlying C representation (as const)
Definition: l_word_list.h:213
Word_list(int num_words=0)
take non-negative word-count; generate that many empty entries.
Definition: l_word_list.h:148
size_t size() const
Number of entries in the word list (could be empty, though).
Definition: l_word_list.h:198
iterator class used to traverse and read the list
Definition: l_word_list.h:304
void append(const std::string &word)
insert a given string into the list (maybe increasing its size).
Definition: l_word_list.h:263
#define KJB_THROW_2(ex, msg)
Definition: l_exception.h:48
void swap(kjb::Gsl_Multimin_fdf &m1, kjb::Gsl_Multimin_fdf &m2)
Swap two wrapped multimin objects.
Definition: gsl_multimin.h:693
const char * operator[](size_t index) const
Access an entry of the word list; this performs range checking.
Definition: l_word_list.h:241
Word_list(const std::string &pattern, int(*filter)(const char *)=kjb_c::is_file)
Construct by searching for a Glob pattern, seeking files.
Definition: l_word_list.h:134
const_iterator end() const
synonym for cend
Definition: l_word_list.h:369
const_iterator cend() const
generate, return const_iterator pointing one-past-last entry
Definition: l_word_list.h:381
Word_list(const Word_list &that)
copy ctor (slow) creates a deep copy of an existing word list.
Definition: l_word_list.h:169
Support for error handling exception classes in libKJB.
const_iterator & operator--()
Definition: l_word_list.h:333
bool operator==(const const_iterator &iii) const
Definition: l_word_list.h:351
void trim_empty_entries_at_tail()
remove all empty entries from back (only) of the list.
Definition: l_word_list.h:269
const_iterator cbegin() const
generate, return const_iterator to front of list
Definition: l_word_list.h:375
~Word_list()
dtor releases memory of underlying C structure
Definition: l_word_list.h:296