← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/program_options/config_file.h

  • Committer: Jay Pipes
  • Date: 2009-04-10 17:06:58 UTC
  • mto: (971.1.47 mordred)
  • mto: This revision was merged to the branch mainline in revision 990.
  • Revision ID: jpipes@serialcoder-20090410170658-d3azdnas1fn8v68l
Removal of log.cc (binlog), added Applier plugin and fixed up Replicator
plugin.  New transaction_services.cc class implementation of the API for
converting between internal formats and GPB Command Messages.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/program_options/config_file.h
1
 
/*
2
 
 * Copyright (C) 2002-2004 Vladimir Prus.
3
 
 * Copyright (C) 2010 Monty Taylor
4
 
 *
5
 
 * Distributed under the Boost Software License, Version 1.0.
6
 
 * (See accompanying file LICENSE_1_0.txt or copy at
7
 
 * http://www.boost.org/LICENSE_1_0.txt)
8
 
 */
9
 
 
10
 
#ifndef DRIZZLED_PROGRAM_OPTIONS_CONFIG_FILE_H
11
 
#define DRIZZLED_PROGRAM_OPTIONS_CONFIG_FILE_H
12
 
 
13
 
#include <boost/program_options.hpp>
14
 
#include <boost/program_options/eof_iterator.hpp>
15
 
#include <boost/static_assert.hpp>
16
 
#include <boost/type_traits/is_same.hpp>
17
 
#include <boost/shared_ptr.hpp>
18
 
#include <boost/algorithm/string.hpp>
19
 
 
20
 
#include <boost/noncopyable.hpp>
21
 
 
22
 
#include <iosfwd>
23
 
#include <vector>
24
 
#include <utility>
25
 
#include <set>
26
 
 
27
 
namespace drizzled
28
 
{
29
 
namespace program_options
30
 
{
31
 
 
32
 
typedef std::pair<std::string, std::string> option_result_pair;
33
 
std::string parse_suffix(const std::string& arg_val);
34
 
option_result_pair parse_size_suffixes(std::string s);
35
 
option_result_pair parse_size_arg(std::string s);
36
 
 
37
 
std::string parse_suffix(const std::string& arg_val)
38
 
{
39
 
  try
40
 
  {
41
 
    size_t size_suffix_pos= arg_val.find_last_of("kmgKMG");
42
 
    if (size_suffix_pos == arg_val.size()-1)
43
 
    {
44
 
      char suffix= arg_val[size_suffix_pos];
45
 
      std::string size_val(arg_val.substr(0, size_suffix_pos));
46
 
 
47
 
      uint64_t base_size= boost::lexical_cast<uint64_t>(size_val);
48
 
      uint64_t new_size= 0;
49
 
 
50
 
      switch (suffix)
51
 
      {
52
 
      case 'K':
53
 
      case 'k':
54
 
        new_size= base_size * 1024;
55
 
        break;
56
 
      case 'M':
57
 
      case 'm':
58
 
        new_size= base_size * 1024 * 1024;
59
 
        break;
60
 
      case 'G':
61
 
      case 'g':
62
 
        new_size= base_size * 1024 * 1024 * 1024;
63
 
        break;
64
 
      }
65
 
      return boost::lexical_cast<std::string>(new_size);
66
 
    }
67
 
  }
68
 
  catch (std::exception&)
69
 
  { }
70
 
 
71
 
  return arg_val;
72
 
}
73
 
 
74
 
option_result_pair parse_size_suffixes(std::string s)
75
 
{
76
 
  size_t equal_pos= s.find("=");
77
 
  if (equal_pos != std::string::npos)
78
 
  {
79
 
    std::string arg_key(s.substr(0, equal_pos));
80
 
    std::string arg_val(parse_suffix(s.substr(equal_pos+1)));
81
 
 
82
 
    if (arg_val != s.substr(equal_pos+1))
83
 
    {
84
 
      return std::make_pair(arg_key, arg_val);
85
 
    }
86
 
  }
87
 
 
88
 
  return std::make_pair(std::string(""), std::string(""));
89
 
}
90
 
 
91
 
option_result_pair parse_size_arg(std::string s)
92
 
{
93
 
  if (s.find("--") == 0)
94
 
  {
95
 
    return parse_size_suffixes(s.substr(2));
96
 
  }
97
 
  return make_pair(std::string(""), std::string(""));
98
 
}
99
 
 
100
 
class invalid_syntax :
101
 
  public boost::program_options::error
102
 
{
103
 
public:
104
 
  enum kind_t
105
 
  {
106
 
    long_not_allowed = 30,
107
 
    long_adjacent_not_allowed,
108
 
    short_adjacent_not_allowed,
109
 
    empty_adjacent_parameter,
110
 
    missing_parameter,
111
 
    extra_parameter,
112
 
    unrecognized_line
113
 
  };
114
 
 
115
 
  invalid_syntax(const std::string& in_tokens, kind_t in_kind);
116
 
 
117
 
 
118
 
  // gcc says that throw specification on dtor is loosened
119
 
  // without this line
120
 
  ~invalid_syntax() throw() {}
121
 
 
122
 
  kind_t kind() const
123
 
  {
124
 
    return m_kind;
125
 
  }
126
 
 
127
 
 
128
 
  const std::string& tokens() const
129
 
  {
130
 
    return m_tokens;
131
 
  }
132
 
 
133
 
 
134
 
protected:
135
 
  /** Used to convert kind_t to a related error text */
136
 
  static std::string error_message(kind_t kind)
137
 
  {
138
 
    // Initially, store the message in 'const char*' variable, to avoid
139
 
    // conversion to string in all cases.
140
 
    const char* msg;
141
 
    switch(kind)
142
 
    {
143
 
    case long_not_allowed:
144
 
      msg = "long options are not allowed";
145
 
      break;
146
 
    case long_adjacent_not_allowed:
147
 
      msg = "parameters adjacent to long options not allowed";
148
 
      break;
149
 
    case short_adjacent_not_allowed:
150
 
      msg = "parameters adjust to short options are not allowed";
151
 
      break;
152
 
    case empty_adjacent_parameter:
153
 
      msg = "adjacent parameter is empty";
154
 
      break;
155
 
    case missing_parameter:
156
 
      msg = "required parameter is missing";
157
 
      break;
158
 
    case extra_parameter:
159
 
      msg = "extra parameter";
160
 
      break;
161
 
    case unrecognized_line:
162
 
      msg = "unrecognized line";
163
 
      break;
164
 
    default:
165
 
      msg = "unknown error";
166
 
    }
167
 
    return msg;
168
 
  }
169
 
 
170
 
private:
171
 
  // TODO: copy ctor might throw
172
 
  std::string m_tokens;
173
 
 
174
 
  kind_t m_kind;
175
 
};
176
 
 
177
 
invalid_syntax::invalid_syntax(const std::string& in_tokens,
178
 
                               invalid_syntax::kind_t in_kind) :
179
 
  boost::program_options::error(error_message(in_kind).append(" in '").append(in_tokens).append("'")),
180
 
  m_tokens(in_tokens),
181
 
  m_kind(in_kind)
182
 
{ }
183
 
 
184
 
namespace detail
185
 
{
186
 
 
187
 
/** Standalone parser for config files in ini-line format.
188
 
  The parser is a model of single-pass lvalue iterator, and
189
 
  default constructor creates past-the-end-iterator. The typical usage is:
190
 
  config_file_iterator i(is, ... set of options ...), e;
191
 
  for(; i !=e; ++i) {
192
 
 *i;
193
 
 }
194
 
 
195
 
 Syntax conventions:
196
 
 
197
 
 - config file can not contain positional options
198
 
 - '#' is comment character: it is ignored together with
199
 
 the rest of the line.
200
 
 - variable assignments are in the form
201
 
 name '=' value.
202
 
 spaces around '=' are trimmed.
203
 
 - Section names are given in brackets. 
204
 
 
205
 
 The actual option name is constructed by combining current section
206
 
 name and specified option name, with dot between. If section_name 
207
 
 already contains dot at the end, new dot is not inserted. For example:
208
 
 @verbatim
209
 
 [gui.accessibility]
210
 
 visual_bell=yes
211
 
 @endverbatim
212
 
 will result in option "gui.accessibility.visual_bell" with value
213
 
 "yes" been returned.
214
 
 
215
 
 */    
216
 
class common_config_file_iterator :
217
 
  public boost::eof_iterator<common_config_file_iterator,
218
 
                             boost::program_options::option>
219
 
{
220
 
public:
221
 
  common_config_file_iterator()
222
 
  {
223
 
    found_eof();
224
 
  }
225
 
 
226
 
  common_config_file_iterator(const std::set<std::string>& in_allowed_options,
227
 
                              bool allow_unregistered) :
228
 
    allowed_options(in_allowed_options),
229
 
    m_allow_unregistered(allow_unregistered)
230
 
  {
231
 
    for(std::set<std::string>::const_iterator i = allowed_options.begin();
232
 
        i != allowed_options.end(); 
233
 
        ++i)
234
 
    {
235
 
      add_option(i->c_str());
236
 
    }
237
 
  }
238
 
 
239
 
  virtual ~common_config_file_iterator() {}
240
 
 
241
 
public: // Method required by eof_iterator
242
 
 
243
 
  void get()
244
 
  {
245
 
    std::string s;
246
 
    std::string::size_type n;
247
 
    bool found = false;
248
 
 
249
 
    while(this->getline(s)) {
250
 
 
251
 
      // strip '#' comments and whitespace
252
 
      if ((n = s.find('#')) != std::string::npos)
253
 
        s = s.substr(0, n);
254
 
      boost::trim(s);
255
 
 
256
 
      if (!s.empty()) {
257
 
        // Handle section name
258
 
        if (*s.begin() == '[' && *s.rbegin() == ']')
259
 
        {
260
 
          m_prefix = s.substr(1, s.size()-2);
261
 
          if (*m_prefix.rbegin() != '.')
262
 
            m_prefix += '.';
263
 
        }
264
 
        else
265
 
        {
266
 
          
267
 
          std::string name;
268
 
          std::string option_value("true");
269
 
 
270
 
          if ((n = s.find('=')) != std::string::npos)
271
 
          {
272
 
 
273
 
            name = m_prefix + boost::trim_copy(s.substr(0, n));
274
 
            option_value = boost::trim_copy(parse_suffix(s.substr(n+1)));
275
 
 
276
 
          }
277
 
          else
278
 
          {
279
 
            name = m_prefix + boost::trim_copy(s);
280
 
          }
281
 
 
282
 
          bool registered = allowed_option(name);
283
 
          if (!registered && !m_allow_unregistered)
284
 
            boost::throw_exception(boost::program_options::unknown_option(name));
285
 
 
286
 
          found = true;
287
 
          this->value().string_key = name;
288
 
          this->value().value.clear();
289
 
          this->value().value.push_back(option_value);
290
 
          this->value().unregistered = !registered;
291
 
          this->value().original_tokens.clear();
292
 
          this->value().original_tokens.push_back(name);
293
 
          this->value().original_tokens.push_back(option_value);
294
 
          break;
295
 
 
296
 
        }
297
 
      }
298
 
    }
299
 
    if (!found)
300
 
      found_eof();
301
 
  }
302
 
 
303
 
protected: // Stubs for derived classes
304
 
 
305
 
  // Obtains next line from the config file
306
 
  // Note: really, this design is a bit ugly
307
 
  // The most clean thing would be to pass 'line_iterator' to
308
 
  // constructor of this class, but to avoid templating this class
309
 
  // we'd need polymorphic iterator, which does not exist yet.
310
 
  virtual bool getline(std::string&) { return false; }
311
 
 
312
 
private:
313
 
  /** Adds another allowed option. If the 'name' ends with
314
 
    '*', then all options with the same prefix are
315
 
    allowed. For example, if 'name' is 'foo*', then 'foo1' and
316
 
    'foo_bar' are allowed. */
317
 
  void add_option(const char* name)
318
 
  {
319
 
    std::string s(name);
320
 
    assert(!s.empty());
321
 
    if (*s.rbegin() == '*')
322
 
    {
323
 
      s.resize(s.size()-1);
324
 
      bool bad_prefixes(false);
325
 
      // If 's' is a prefix of one of allowed suffix, then
326
 
      // lower_bound will return that element.
327
 
      // If some element is prefix of 's', then lower_bound will
328
 
      // return the next element.
329
 
      std::set<std::string>::iterator i = allowed_prefixes.lower_bound(s);
330
 
      if (i != allowed_prefixes.end())
331
 
      {
332
 
        if (i->find(s) == 0)
333
 
          bad_prefixes = true;                    
334
 
      }
335
 
      if (i != allowed_prefixes.begin())
336
 
      {
337
 
        --i;
338
 
        if (s.find(*i) == 0)
339
 
          bad_prefixes = true;
340
 
      }
341
 
      if (bad_prefixes)
342
 
        boost::throw_exception(boost::program_options::error("bad prefixes"));
343
 
      allowed_prefixes.insert(s);
344
 
    }
345
 
  }
346
 
 
347
 
 
348
 
  // Returns true if 's' is a registered option name.
349
 
  bool allowed_option(const std::string& s) const
350
 
  {
351
 
    std::set<std::string>::const_iterator i = allowed_options.find(s);
352
 
    if (i != allowed_options.end())
353
 
      return true;        
354
 
    // If s is "pa" where "p" is allowed prefix then
355
 
    // lower_bound should find the element after "p". 
356
 
    // This depends on 'allowed_prefixes' invariant.
357
 
    i = allowed_prefixes.lower_bound(s);
358
 
    if (i != allowed_prefixes.begin() && s.find(*--i) == 0)
359
 
      return true;
360
 
    return false;
361
 
  }
362
 
 
363
 
 
364
 
  // That's probably too much data for iterator, since
365
 
  // it will be copied, but let's not bother for now.
366
 
  std::set<std::string> allowed_options;
367
 
  // Invariant: no element is prefix of other element.
368
 
  std::set<std::string> allowed_prefixes;
369
 
  std::string m_prefix;
370
 
  bool m_allow_unregistered;
371
 
};
372
 
 
373
 
template<class charT>
374
 
class basic_config_file_iterator :
375
 
  public common_config_file_iterator
376
 
{
377
 
public:
378
 
 
379
 
  basic_config_file_iterator()
380
 
  {
381
 
    found_eof();
382
 
  }
383
 
 
384
 
  /** Creates a config file parser for the specified stream. */
385
 
  basic_config_file_iterator(std::basic_istream<charT>& is, 
386
 
                             const std::set<std::string>& allowed_options,
387
 
                             bool allow_unregistered = false); 
388
 
 
389
 
private: // base overrides
390
 
 
391
 
  bool getline(std::string&);
392
 
 
393
 
private: // internal data
394
 
  boost::shared_ptr<std::basic_istream<charT> > is;
395
 
};
396
 
 
397
 
typedef basic_config_file_iterator<char> config_file_iterator;
398
 
typedef basic_config_file_iterator<wchar_t> wconfig_file_iterator;
399
 
 
400
 
struct null_deleter
401
 
{
402
 
  void operator()(void const *) const {}
403
 
};
404
 
 
405
 
 
406
 
template<class charT>
407
 
basic_config_file_iterator<charT>::
408
 
basic_config_file_iterator(std::basic_istream<charT>& in_is, 
409
 
                           const std::set<std::string>& in_allowed_options,
410
 
                           bool in_allow_unregistered) :
411
 
  common_config_file_iterator(in_allowed_options, in_allow_unregistered)
412
 
{
413
 
  this->is.reset(&in_is, null_deleter());                 
414
 
  get();
415
 
}
416
 
 
417
 
 
418
 
// Specializing this function for wchar_t causes problems on
419
 
// borland and vc7, as well as on metrowerks. On the first two
420
 
// I don't know a workaround, so make use of 'to_internal' to
421
 
// avoid specialization.
422
 
template<class charT>
423
 
bool
424
 
basic_config_file_iterator<charT>::getline(std::string& s)
425
 
{
426
 
  if (std::getline(*is, s))
427
 
  {
428
 
    return true;
429
 
  }
430
 
  else
431
 
  {
432
 
    return false;
433
 
  }
434
 
}
435
 
 
436
 
} /* namespace detail */
437
 
 
438
 
/** Parse a config file. 
439
 
 
440
 
  Read from given stream.
441
 
*/
442
 
template<class charT>
443
 
boost::program_options::basic_parsed_options<charT>
444
 
parse_config_file(std::basic_istream<charT>& is,
445
 
                  const boost::program_options::options_description& desc,
446
 
                  bool allow_unregistered = false)
447
 
{    
448
 
  std::set<std::string> allowed_options;
449
 
 
450
 
  const std::vector<boost::shared_ptr<boost::program_options::option_description> >& options = desc.options();
451
 
  for (unsigned i = 0; i < options.size(); ++i)
452
 
  {
453
 
    const boost::program_options::option_description& d= *options[i];
454
 
 
455
 
    if (d.long_name().empty())
456
 
      boost::throw_exception(boost::program_options::error("long name required for config file"));
457
 
 
458
 
    allowed_options.insert(d.long_name());
459
 
  }
460
 
 
461
 
  // Parser return char strings
462
 
  boost::program_options::parsed_options result(&desc);        
463
 
  std::copy(detail::basic_config_file_iterator<charT>(is,
464
 
                                                      allowed_options,
465
 
                                                      allow_unregistered), 
466
 
       detail::basic_config_file_iterator<charT>(), 
467
 
       std::back_inserter(result.options));
468
 
  // Convert char strings into desired type.
469
 
  return boost::program_options::basic_parsed_options<charT>(result);
470
 
}
471
 
 
472
 
/** Parse a config file. 
473
 
 
474
 
  Read from file with the given name. The character type is
475
 
  passed to the file stream. 
476
 
*/
477
 
template<class charT>
478
 
boost::program_options::basic_parsed_options<charT>
479
 
parse_config_file(const char* filename,
480
 
                  const boost::program_options::options_description& desc,
481
 
                  bool allow_unregistered = false)
482
 
{ 
483
 
  // Parser return char strings
484
 
  std::basic_ifstream< charT > strm(filename);
485
 
  if (!strm) 
486
 
  {
487
 
    boost::throw_exception("Couldn't open file");
488
 
  }
489
 
  return parse_config_file(strm, desc, allow_unregistered);
490
 
}
491
 
 
492
 
} /* namespace program_options */
493
 
} /* namespace drizzled */
494
 
 
495
 
#endif /* DRIZZLED_PROGRAM_OPTIONS_CONFIG_FILE_H */
496