← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/constrained_value.h

  • Committer: Brian Aker
  • Date: 2010-10-24 01:34:39 UTC
  • mto: This revision was merged to the branch mainline in revision 1875.
  • Revision ID: brian@tangent.org-20101024013439-w9r8qtmt5ihnqtkd
Encapsulate table_name from table_list.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/constrained_value.h
20
20
#ifndef DRIZZLED_CONSTRAINED_VALUE_H
21
21
#define DRIZZLED_CONSTRAINED_VALUE_H
22
22
 
23
 
#include <boost/exception/info.hpp>
24
23
#include <boost/program_options.hpp>
25
24
#include <boost/program_options/errors.hpp>
26
25
#include <iostream>
27
 
#include <netinet/in.h> /* for in_port_t */
28
26
 
29
27
namespace drizzled
30
28
{
31
29
 
32
 
/* We have to make this mixin exception class because boost program_option
33
 
  exceptions don't derive from f-ing boost::exception. FAIL
34
 
*/
35
 
class invalid_option_value :
36
 
  public boost::exception,
37
 
  public boost::program_options::invalid_option_value
38
 
{
39
 
public:
40
 
  invalid_option_value(const std::string &option_value) :
41
 
    boost::exception(),
42
 
    boost::program_options::invalid_option_value(option_value)
43
 
  {}
44
 
};
45
 
 
46
30
template<class T> class constrained_value;
47
31
template<class T>
48
32
std::istream& operator>>(std::istream& is, constrained_value<T>& bound_val);
81
65
    return set_value(rhs);
82
66
  }
83
67
 
84
 
  T get() const
 
68
  T getVal() const
85
69
  {
86
70
    return m_val;
87
71
  }
104
88
  friend
105
89
  std::ostream& operator<<(std::ostream& os, const constrained_value<T>& v)
106
90
  {
107
 
    os << v.get();
 
91
    os << v.getVal();
108
92
    return os;
109
93
  }
110
94
};
111
95
 
112
 
namespace
113
 
{
114
 
template<class T, T min_val>
115
 
bool less_than_min(T val_to_check)
116
 
{
117
 
  return val_to_check < min_val;
118
 
}
119
 
 
120
 
template<>
121
 
inline bool less_than_min<uint16_t, 0>(uint16_t)
122
 
{
123
 
  return false;
124
 
}
125
 
 
126
 
template<>
127
 
inline bool less_than_min<uint32_t, 0>(uint32_t)
128
 
{
129
 
  return false;
130
 
}
131
 
 
132
 
template<>
133
 
inline bool less_than_min<uint64_t, 0>(uint64_t)
134
 
{
135
 
  return false;
136
 
}
137
 
 
138
 
template<class T, T min_val>
139
 
bool greater_than_max(T val_to_check)
140
 
{
141
 
  return val_to_check > min_val;
142
 
}
143
 
 
144
 
template<>
145
 
inline bool greater_than_max<uint16_t, UINT16_MAX>(uint16_t)
146
 
{
147
 
  return false;
148
 
}
149
 
 
150
 
template<>
151
 
inline bool greater_than_max<uint32_t, UINT32_MAX>(uint32_t)
152
 
{
153
 
  return false;
154
 
}
155
 
 
156
 
template<>
157
 
inline bool greater_than_max<uint64_t, UINT64_MAX>(uint64_t)
158
 
{
159
 
  return false;
160
 
}
161
 
} 
162
 
 
163
 
typedef boost::error_info<struct tag_invalid_max,uint64_t> invalid_max_info;
164
 
typedef boost::error_info<struct tag_invalid_min,int64_t> invalid_min_info;
165
 
 
166
 
template<class T,
167
 
  T MAXVAL,
168
 
  T MINVAL, unsigned int ALIGN= 1>
 
96
template<class T, uint64_t MAXVAL=UINT64_MAX, int64_t MINVAL=INT64_MIN, int ALIGN=1>
169
97
class constrained_check :
170
98
  public constrained_value<T>
171
99
{
177
105
protected:
178
106
  constrained_value<T>& set_value(const constrained_value<T>& rhs)
179
107
  {
180
 
    return set_value(rhs.get());
 
108
    return set_value(rhs.getVal());
181
109
  }
182
110
 
183
111
  constrained_value<T>& set_value(T rhs)
184
112
  {
185
 
    if (greater_than_max<T,MAXVAL>(rhs))
186
 
    {
187
 
      boost::throw_exception(invalid_option_value(boost::lexical_cast<std::string>(rhs)) << invalid_max_info(static_cast<uint64_t>(MAXVAL)));
188
 
    }
189
 
      
190
 
    if (less_than_min<T,MINVAL>(rhs))
191
 
    {
192
 
      boost::throw_exception(invalid_option_value(boost::lexical_cast<std::string>(rhs)) << invalid_min_info(static_cast<int64_t>(MINVAL)));
 
113
    if ((rhs > MAXVAL) || (rhs < MINVAL))
 
114
    {
 
115
      boost::throw_exception(boost::program_options::invalid_option_value(boost::lexical_cast<std::string>(rhs)));
193
116
    }
194
117
    rhs-= rhs % ALIGN;
195
 
    this->setVal(rhs);
 
118
    setVal(rhs);
196
119
    return *this;
197
120
  }
198
121
 
199
122
 
200
123
};
201
124
 
202
 
typedef constrained_check<uint64_t, UINT64_MAX, 0> uint64_constraint;
203
 
typedef constrained_check<uint32_t, UINT32_MAX, 0> uint32_constraint;
204
 
typedef constrained_check<uint64_t, UINT64_MAX, 1> uint64_nonzero_constraint;
205
 
typedef constrained_check<uint32_t, UINT32_MAX, 1> uint32_nonzero_constraint;
206
 
typedef drizzled::constrained_check<in_port_t, 65535, 0> port_constraint;
207
 
 
208
125
typedef constrained_check<uint32_t,65535,1> back_log_constraints;
209
126
 
210
127
} /* namespace drizzled */