← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to unittests/temporal_generator.cc

  • Committer: Brian Aker
  • Date: 2009-10-15 00:22:33 UTC
  • mto: (1183.1.11 merge)
  • mto: This revision was merged to the branch mainline in revision 1198.
  • Revision ID: brian@gaz-20091015002233-fa4ao2mbc67wls91
First pass of information engine. OMG, ponies... is it so much easier to
deal with creating and engine.

The list table iterator though... its ass, needs to go. We should also
abstract out share. Very few engines need a custom one. Just say'in

Show diffs side-by-side

added added

removed removed

Lines of Context:
unittests/temporal_generator.cc
1
 
/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
 
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
 
 *
4
 
 *  Copyright (C) 2010 Pawel Blokus
5
 
 *
6
 
 *  This program is free software; you can redistribute it and/or modify
7
 
 *  it under the terms of the GNU General Public License as published by
8
 
 *  the Free Software Foundation; either version 2 of the License, or
9
 
 *  (at your option) any later version.
10
 
 *
11
 
 *  This program is distributed in the hope that it will be useful,
12
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 
 *  GNU General Public License for more details.
15
 
 *
16
 
 *  You should have received a copy of the GNU General Public License
17
 
 *  along with this program; if not, write to the Free Software
18
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19
 
 */
20
 
 
21
 
#include "config.h"
22
 
 
23
 
#include <drizzled/temporal.h>
24
 
#include <drizzled/temporal_format.h>
25
 
#include <drizzled/temporal_interval.h>
26
 
 
27
 
#include "temporal_generator.h"
28
 
 
29
 
using namespace drizzled;
30
 
 
31
 
void TemporalGenerator::DateGen::make_date(Date *date,
32
 
                                          uint32_t years, uint32_t months, uint32_t days)
33
 
{
34
 
  date->set_years(years);
35
 
  date->set_months(months);
36
 
  date->set_days(days);
37
 
  date->set_epoch_seconds();
38
 
}
39
 
 
40
 
void TemporalGenerator::DateGen::make_valid_date(drizzled::Date *date)
41
 
{
42
 
  date->set_years(2005);
43
 
  date->set_months(5);
44
 
  date->set_days(26);
45
 
  date->set_epoch_seconds();
46
 
}
47
 
 
48
 
void TemporalGenerator::TemporalGen::leap_day_in_leap_year(drizzled::Temporal *temporal)
49
 
{
50
 
  temporal->set_years(2008);
51
 
  temporal->set_months(2);
52
 
  temporal->set_days(29);
53
 
  temporal->set_epoch_seconds();
54
 
}
55
 
 
56
 
void TemporalGenerator::TemporalGen::leap_day_in_non_leap_year(drizzled::Temporal *temporal)
57
 
{
58
 
  temporal->set_years(2010);
59
 
  temporal->set_months(2);
60
 
  temporal->set_days(29);
61
 
  temporal->set_epoch_seconds();
62
 
}
63
 
 
64
 
void TemporalGenerator::TimeGen::make_time(drizzled::Time *time,
65
 
                                   uint32_t hours, uint32_t minutes, uint32_t seconds,
66
 
                                   uint32_t useconds)
67
 
{
68
 
  time->set_hours(hours);
69
 
  time->set_minutes(minutes);
70
 
  time->set_seconds(seconds);
71
 
  time->set_useconds(useconds);
72
 
  time->set_epoch_seconds();
73
 
}
74
 
 
75
 
void TemporalGenerator::TemporalGen::make_min_time(drizzled::Temporal *temporal)
76
 
{
77
 
  temporal->set_hours(0);
78
 
  temporal->set_minutes(0);
79
 
  temporal->set_seconds(0);
80
 
  temporal->set_epoch_seconds();
81
 
}
82
 
 
83
 
void TemporalGenerator::TemporalGen::make_max_time(drizzled::Temporal *temporal)
84
 
{
85
 
  temporal->set_hours(23);
86
 
  temporal->set_minutes(59);
87
 
  temporal->set_seconds(59);
88
 
  temporal->set_epoch_seconds();
89
 
}
90
 
 
91
 
void TemporalGenerator::DateTimeGen::make_datetime(drizzled::DateTime *datetime,
92
 
                   uint32_t years, uint32_t months, uint32_t days, uint32_t hours,
93
 
                   uint32_t minutes, uint32_t seconds, uint32_t useconds)
94
 
{
95
 
  datetime->set_years(years);
96
 
  datetime->set_months(months);
97
 
  datetime->set_days(days);
98
 
  datetime->set_hours(hours);
99
 
  datetime->set_minutes(minutes);
100
 
  datetime->set_seconds(seconds);
101
 
  datetime->set_useconds(useconds);
102
 
  datetime->set_epoch_seconds();
103
 
}                     
104
 
 
105
 
void TemporalGenerator::DateTimeGen::make_valid_datetime(drizzled::DateTime *datetime)
106
 
{
107
 
  datetime->set_years(1999);
108
 
  datetime->set_months(8);
109
 
  datetime->set_days(15);
110
 
  datetime->set_hours(13);
111
 
  datetime->set_minutes(34);
112
 
  datetime->set_seconds(6);
113
 
  datetime->set_epoch_seconds();
114
 
}
115
 
 
116
 
void TemporalGenerator::TimestampGen::make_timestamp(drizzled::Timestamp *timestamp,
117
 
                                             uint32_t years, uint32_t months, uint32_t days,
118
 
                                             uint32_t hours, uint32_t minutes, uint32_t seconds)
119
 
{
120
 
  timestamp->set_years(years);
121
 
  timestamp->set_months(months);
122
 
  timestamp->set_days(days);
123
 
  timestamp->set_hours(hours);
124
 
  timestamp->set_minutes(minutes);
125
 
  timestamp->set_seconds(seconds);
126
 
  timestamp->set_epoch_seconds();
127
 
}
128
 
 
129
 
void TemporalGenerator::TimestampGen::make_micro_timestamp(drizzled::MicroTimestamp *timestamp,
130
 
                                                   uint32_t years, uint32_t months, uint32_t days,
131
 
                                                   uint32_t hours, uint32_t minutes,
132
 
                                                   uint32_t seconds, uint32_t microseconds)
133
 
{
134
 
  make_timestamp(timestamp, years, months, days, hours, minutes, seconds);
135
 
  timestamp->set_useconds(microseconds);
136
 
  timestamp->set_epoch_seconds();
137
 
}
138
 
                                 
139
 
void TemporalGenerator::TimestampGen::make_nano_timestamp(drizzled::NanoTimestamp *timestamp,
140
 
                                                  uint32_t years, uint32_t months, uint32_t days,
141
 
                                                  uint32_t hours, uint32_t minutes,
142
 
                                                  uint32_t seconds, uint32_t nanoseconds)
143
 
{
144
 
  make_timestamp(timestamp, years, months, days, hours, minutes, seconds);
145
 
  timestamp->set_nseconds(nanoseconds);
146
 
  timestamp->set_epoch_seconds();
147
 
}
148
 
 
149
 
drizzled::TemporalFormat *TemporalGenerator::TemporalFormatGen::make_temporal_format(const char *regexp,
150
 
                                                                  int32_t year_part_index,
151
 
                                                                  int32_t month_part_index,
152
 
                                                                  int32_t day_part_index,
153
 
                                                                  int32_t hour_part_index,
154
 
                                                                  int32_t minute_part_index,
155
 
                                                                  int32_t second_part_index,
156
 
                                                                  int32_t usecond_part_index,
157
 
                                                                  int32_t nsecond_part_index)
158
 
{
159
 
  drizzled::TemporalFormat *temporal_format= new drizzled::TemporalFormat(regexp);
160
 
  
161
 
  temporal_format->set_year_part_index(year_part_index);
162
 
  temporal_format->set_month_part_index(month_part_index);
163
 
  temporal_format->set_day_part_index(day_part_index);
164
 
  temporal_format->set_hour_part_index(hour_part_index);
165
 
  temporal_format->set_minute_part_index(minute_part_index);
166
 
  temporal_format->set_second_part_index(second_part_index);
167
 
  temporal_format->set_usecond_part_index(usecond_part_index);
168
 
  temporal_format->set_nsecond_part_index(nsecond_part_index);
169
 
 
170
 
  return temporal_format;
171
 
}
172
 
 
173
 
drizzled::TemporalInterval *TemporalGenerator::TemporalIntervalGen::make_temporal_interval(
174
 
                                                              uint32_t  year,
175
 
                                                              uint32_t  month,
176
 
                                                              uint32_t  day,
177
 
                                                              uint32_t  hour,
178
 
                                                              uint64_t  minute,
179
 
                                                              uint64_t  second,
180
 
                                                              uint64_t  second_part,
181
 
                                                              bool neg)
182
 
{
183
 
  drizzled::TemporalInterval *interval= new drizzled::TemporalInterval();
184
 
 
185
 
  interval->set_year(year);
186
 
  interval->set_month(month);
187
 
  interval->set_day(day);
188
 
  interval->set_hour(hour);
189
 
  interval->set_minute(minute);
190
 
  interval->set_second(second);
191
 
  interval->set_second_part(second_part);
192
 
  interval->setNegative(neg);
193
 
 
194
 
  return interval;
195
 
}