← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/temporal.cc

  • Committer: Mark Atwood
  • Date: 2011-06-24 11:45:17 UTC
  • mfrom: (2318.6.64 rf)
  • Revision ID: me@mark.atwood.name-20110624114517-1mq8no6jlp2nrg7m
merge lp:~olafvdspek/drizzle/refactor15

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/temporal.cc
36
36
 
37
37
#include <config.h>
38
38
 
 
39
#include <boost/foreach.hpp>
39
40
#include <drizzled/charset.h>
40
41
#include <drizzled/type/decimal.h>
41
42
#include <drizzled/calendar.h>
54
55
#include <vector>
55
56
#include <string.h>
56
57
 
57
 
namespace drizzled 
58
 
{
 
58
namespace drizzled {
59
59
 
60
60
extern std::vector<TemporalFormat *> known_datetime_formats;
61
61
extern std::vector<TemporalFormat *> known_date_formats;
146
146
 
147
147
bool Date::from_string(const char *from, size_t from_len)
148
148
{
149
 
  /* 
150
 
   * Loop through the known date formats and see if 
151
 
   * there is a match.
152
 
   */
153
 
  bool matched= false;
154
 
  TemporalFormat *current_format;
155
 
  std::vector<TemporalFormat *>::iterator current= known_date_formats.begin();
156
 
 
157
149
  _useconds= 0; // We may not match on it, so we need to make sure we zero it out.
158
 
  while (current != known_date_formats.end())
 
150
  BOOST_FOREACH(TemporalFormat* it, known_date_formats)
159
151
  {
160
 
    current_format= *current;
161
 
    if (current_format->matches(from, from_len, this))
162
 
    {
163
 
      matched= true;
164
 
      break;
165
 
    }
166
 
    current++;
 
152
    if (not it->matches(from, from_len, this))
 
153
      continue;
 
154
    set_epoch_seconds();
 
155
    return is_valid();
167
156
  }
168
 
 
169
 
  if (! matched)
170
 
    return false;
171
 
 
172
 
  set_epoch_seconds();
173
 
  return is_valid();
 
157
  return false;
174
158
}
175
159
 
176
160
bool DateTime::from_string(const char *from, size_t from_len)
177
161
{
178
 
  /* 
179
 
   * Loop through the known datetime formats and see if 
180
 
   * there is a match.
181
 
   */
182
 
  bool matched= false;
183
 
  TemporalFormat *current_format;
184
 
  std::vector<TemporalFormat *>::iterator current= known_datetime_formats.begin();
185
 
 
186
 
  while (current != known_datetime_formats.end())
 
162
  BOOST_FOREACH(TemporalFormat* it, known_datetime_formats)
187
163
  {
188
 
    current_format= *current;
189
 
    if (current_format->matches(from, from_len, this))
190
 
    {
191
 
      matched= true;
192
 
      break;
193
 
    }
194
 
    current++;
 
164
    if (not it->matches(from, from_len, this))
 
165
      continue;
 
166
    set_epoch_seconds();
 
167
    return is_valid();
195
168
  }
196
 
 
197
 
  if (! matched)
198
 
    return false;
199
 
 
200
 
  set_epoch_seconds();
201
 
  return is_valid();
 
169
  return false;
 
170
 
202
171
}
203
172
 
204
173
/*
1008
977
 
1009
978
bool Time::from_string(const char *from, size_t from_len)
1010
979
{
1011
 
  /*
1012
 
   * Loop through the known time formats and see if
1013
 
   * there is a match.
1014
 
   */
1015
 
  bool matched= false;
1016
 
  TemporalFormat *current_format;
1017
 
  std::vector<TemporalFormat *>::iterator current= known_time_formats.begin();
1018
 
 
1019
 
  while (current != known_time_formats.end())
 
980
  BOOST_FOREACH(TemporalFormat* it, known_time_formats)
1020
981
  {
1021
 
    current_format= *current;
1022
 
    if (current_format->matches(from, from_len, this))
1023
 
    {
1024
 
      matched= true;
1025
 
      break;
1026
 
    }
1027
 
    current++;
 
982
    if (not it->matches(from, from_len, this))
 
983
      continue;
 
984
    return is_fuzzy_valid();
1028
985
  }
1029
 
 
1030
 
  if (not matched)
1031
 
    return false;
1032
 
 
1033
 
  return is_fuzzy_valid();
 
986
  return false;
1034
987
}
1035
988
 
1036
989
int Time::to_string(char *to, size_t to_len) const
1037
990
{
1038
 
  return snprintf(to, to_len,
1039
 
                  "%02" PRIu32 ":%02" PRIu32 ":%02" PRIu32,
1040
 
                  _hours, _minutes, _seconds);
 
991
  return snprintf(to, to_len, "%02" PRIu32 ":%02" PRIu32 ":%02" PRIu32, _hours, _minutes, _seconds);
1041
992
}
1042
993
 
1043
994
int Date::to_string(char *to, size_t to_len) const
1044
995
{
1045
 
  return snprintf(to, to_len,
1046
 
                  "%04" PRIu32 "-%02" PRIu32 "-%02" PRIu32,
1047
 
                  _years, _months, _days);
 
996
  return snprintf(to, to_len, "%04" PRIu32 "-%02" PRIu32 "-%02" PRIu32, _years, _months, _days);
1048
997
}
1049
998
 
1050
999
int DateTime::to_string(char *to, size_t to_len) const
1053
1002
  if (_useconds == 0)
1054
1003
  {
1055
1004
    return snprintf(to, to_len,
1056
 
                    "%04" PRIu32 "-%02" PRIu32 "-%02" PRIu32
1057
 
                          " %02" PRIu32 ":%02" PRIu32 ":%02" PRIu32,
1058
 
                    _years, _months, _days,
1059
 
                    _hours, _minutes, _seconds);
 
1005
                    "%04" PRIu32 "-%02" PRIu32 "-%02" PRIu32 " %02" PRIu32 ":%02" PRIu32 ":%02" PRIu32,
 
1006
                    _years, _months, _days, _hours, _minutes, _seconds);
1060
1007
  }
1061
1008
  else
1062
1009
  {
1063
1010
    return snprintf(to, to_len,
1064
 
                    "%04" PRIu32 "-%02" PRIu32 "-%02" PRIu32
1065
 
                       " %02" PRIu32 ":%02" PRIu32 ":%02" PRIu32 ".%06" PRIu32,
1066
 
                    _years, _months, _days,
1067
 
                    _hours, _minutes, _seconds, _useconds);
 
1011
                    "%04" PRIu32 "-%02" PRIu32 "-%02" PRIu32 " %02" PRIu32 ":%02" PRIu32 ":%02" PRIu32 ".%06" PRIu32,
 
1012
                    _years, _months, _days, _hours, _minutes, _seconds, _useconds);
1068
1013
  }
1069
1014
}
1070
1015
 
1071
1016
int MicroTimestamp::to_string(char *to, size_t to_len) const
1072
1017
{
1073
1018
  return snprintf(to, to_len,
1074
 
                  "%04" PRIu32 "-%02" PRIu32 "-%02" PRIu32
1075
 
                  " %02" PRIu32 ":%02" PRIu32 ":%02" PRIu32 ".%06" PRIu32,
1076
 
                  _years, _months, _days,
1077
 
                  _hours, _minutes, _seconds, _useconds);
 
1019
                  "%04" PRIu32 "-%02" PRIu32 "-%02" PRIu32 " %02" PRIu32 ":%02" PRIu32 ":%02" PRIu32 ".%06" PRIu32,
 
1020
                  _years, _months, _days, _hours, _minutes, _seconds, _useconds);
1078
1021
}
1079
1022
 
1080
1023
void Time::to_decimal(type::Decimal *to) const
1108
1051
 
1109
1052
void Date::to_int64_t(int64_t *to) const
1110
1053
{
1111
 
  *to= (_years * INT32_C(10000)) 
1112
 
     + (_months * INT32_C(100)) 
1113
 
     + _days;
 
1054
  *to= (_years * INT32_C(10000)) + (_months * INT32_C(100)) + _days;
1114
1055
}
1115
1056
 
1116
1057
void Date::to_int32_t(int32_t *to) const
1117
1058
{
1118
 
  *to= (_years * INT32_C(10000)) 
1119
 
     + (_months * INT32_C(100)) 
1120
 
     + _days;
 
1059
  *to= (_years * INT32_C(10000)) + (_months * INT32_C(100)) + _days;
1121
1060
}
1122
1061
 
1123
1062
void Time::to_int32_t(int32_t *to) const
1124
1063
{
1125
 
  *to= (_hours * INT32_C(10000)) 
1126
 
     + (_minutes * INT32_C(100)) 
1127
 
     + _seconds;
 
1064
  *to= (_hours * INT32_C(10000)) + (_minutes * INT32_C(100)) + _seconds;
1128
1065
}
1129
1066
 
1130
1067
// We fill the structure based on just int
1131
1068
void Time::to_uint64_t(uint64_t &to) const
1132
1069
{
1133
 
  to= (_hours * 60 * 60)
1134
 
     + (_minutes * 60)
1135
 
     + _seconds;
 
1070
  to= (_hours * 60 * 60) + (_minutes * 60) + _seconds;
1136
1071
}
1137
1072
 
1138
1073
void DateTime::to_int64_t(int64_t *to) const