← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/temporal_interval.h

  • Committer: Monty Taylor
  • Date: 2008-08-02 00:06:32 UTC
  • mto: (236.1.42 codestyle)
  • mto: This revision was merged to the branch mainline in revision 261.
  • Revision ID: monty@inaugust.com-20080802000632-jsse0zdd9r6ic5ku
Actually turn gettext on...

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/temporal_interval.h
1
 
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
 
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
 
 *
4
 
 *  Copyright (C) 2009 Sun Microsystems
5
 
 *
6
 
 *  Authors: 
7
 
 *
8
 
 *  Clint Byrum <clint@fewbar.com>
9
 
 *
10
 
 *  This program is free software; you can redistribute it and/or modify
11
 
 *  it under the terms of the GNU General Public License as published by
12
 
 *  the Free Software Foundation; version 2 of the License.
13
 
 *
14
 
 *  This program is distributed in the hope that it will be useful,
15
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
 
 *  GNU General Public License for more details.
18
 
 *
19
 
 *  You should have received a copy of the GNU General Public License
20
 
 *  along with this program; if not, write to the Free Software
21
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
22
 
 */
23
 
 
24
 
#ifndef DRIZZLED_TEMPORAL_INTERVAL_H
25
 
#define DRIZZLED_TEMPORAL_INTERVAL_H
26
 
 
27
 
/* @TODO Replace this include with some forward decls */
28
 
#include "drizzled/item.h"
29
 
 
30
 
namespace drizzled 
31
 
{
32
 
 
33
 
/**
34
 
 * @brief
35
 
 *  Stores time interval for date/time manipulation
36
 
 */
37
 
class TemporalInterval
38
 
{
39
 
public:
40
 
 
41
 
  TemporalInterval(uint32_t in_year,
42
 
      uint32_t in_month,
43
 
      uint32_t in_day,
44
 
      uint32_t in_hour,
45
 
      uint64_t in_minute,
46
 
      uint64_t in_second,
47
 
      uint64_t in_second_part,
48
 
      bool in_neg)
49
 
    :
50
 
      year(in_year),
51
 
      month(in_month),
52
 
      day(in_day),
53
 
      hour(in_hour),
54
 
      minute(in_minute),
55
 
      second(in_second),
56
 
      second_part(in_second_part),
57
 
      neg(in_neg)
58
 
  {}
59
 
 
60
 
  TemporalInterval()
61
 
    :
62
 
      year(0),
63
 
      month(0),
64
 
      day(0),
65
 
      hour(0),
66
 
      minute(0),
67
 
      second(0),
68
 
      second_part(0),
69
 
      neg(false)
70
 
  {}
71
 
 
72
 
  /**
73
 
   * Sets whether or not this object specifies a negative interval
74
 
   * @param[in] in_neg true if this is a negative interval, false if not
75
 
   */
76
 
  inline void setNegative(bool in_neg= true)
77
 
  {
78
 
    neg= in_neg;
79
 
  }
80
 
 
81
 
  /**
82
 
   * reverse boolean value of the negative flag
83
 
   */
84
 
  inline void toggleNegative()
85
 
  {
86
 
    neg= !neg;
87
 
  }
88
 
 
89
 
  /**
90
 
   * @retval true this is a negative temporal interval
91
 
   * @retval false this is a positive temporal interval
92
 
   */
93
 
  inline bool getNegative() const
94
 
  {
95
 
    return neg;
96
 
  }
97
 
 
98
 
  inline uint32_t  get_year() { return year; };
99
 
  inline void set_year(uint32_t new_year) { year = new_year; };
100
 
 
101
 
  inline uint32_t  get_month(){ return month; };
102
 
  inline void set_month(uint32_t new_month) { month = new_month; };
103
 
 
104
 
  inline uint32_t  get_day(){ return day; };
105
 
  inline void set_day(uint32_t new_day) { day = new_day; };
106
 
 
107
 
  inline uint32_t  get_hour(){ return hour; };
108
 
  inline void set_hour(uint32_t new_hour) { hour = new_hour; };
109
 
 
110
 
  inline uint64_t  get_minute(){ return minute; };
111
 
  inline void set_minute(uint32_t new_minute) { minute = new_minute; };
112
 
 
113
 
  inline uint64_t  get_second(){ return second; };
114
 
  inline void set_second(uint32_t new_second) { second = new_second; };
115
 
 
116
 
  inline uint64_t  get_second_part(){ return second_part; };
117
 
  inline void set_second_part(uint32_t new_second_part) { second_part = new_second_part; };
118
 
 
119
 
  /**
120
 
   * Populate this TemporalInterval from a string value
121
 
   *
122
 
   * To make code easy, allow interval objects without separators.
123
 
   *
124
 
   * @param args argument Item structure
125
 
   * @param int_type type of interval to create
126
 
   * @param str_value String pointer to the input value
127
 
   * @return true if the string would result in a null interval
128
 
   * 
129
 
   */
130
 
  bool initFromItem(Item *args, interval_type int_type, String *str_value);
131
 
 
132
 
  /**
133
 
   * Adds this interval to a DRIZZLE_LTIME structure
134
 
   *
135
 
   * @param[in,out] ltime the interval will be added to ltime directly in the ltime structure
136
 
   * @param[in] int_type the type of interval requested
137
 
   * @retval true date was added and value stored properly
138
 
   * @retval false result of addition is a null value
139
 
   */
140
 
  bool addDate(DRIZZLE_TIME *ltime, interval_type int_type);
141
 
 
142
 
private:
143
 
 
144
 
  /**
145
 
   * The maximum number of text elements to extract into a temporal interval
146
 
   */
147
 
  static const uint32_t MAX_STRING_ELEMENTS = 5;
148
 
 
149
 
  /**
150
 
   * Each of these corresponds to an 'interval_type'
151
 
   */
152
 
  static const uint32_t NUM_YEAR_MONTH_STRING_ELEMENTS         = 2;
153
 
  static const uint32_t NUM_DAY_HOUR_STRING_ELEMENTS           = 2; 
154
 
  static const uint32_t NUM_DAY_MICROSECOND_STRING_ELEMENTS    = 5;
155
 
  static const uint32_t NUM_DAY_MINUTE_STRING_ELEMENTS         = 3;
156
 
  static const uint32_t NUM_DAY_SECOND_STRING_ELEMENTS         = 4;
157
 
  static const uint32_t NUM_HOUR_MICROSECOND_STRING_ELEMENTS   = 4;
158
 
  static const uint32_t NUM_HOUR_MINUTE_STRING_ELEMENTS        = 2;
159
 
  static const uint32_t NUM_HOUR_SECOND_STRING_ELEMENTS        = 3;
160
 
  static const uint32_t NUM_MINUTE_MICROSECOND_STRING_ELEMENTS = 3;
161
 
  static const uint32_t NUM_MINUTE_SECOND_STRING_ELEMENTS      = 2;
162
 
  static const uint32_t NUM_SECOND_MICROSECOND_STRING_ELEMENTS = 2;
163
 
 
164
 
  /**
165
 
   *  @details
166
 
   *  Get a array of positive numbers from a string object.
167
 
   *  Each number is separated by 1 non digit character
168
 
   *  Return error if there is too many numbers.
169
 
   *  If there is too few numbers, assume that the numbers are left out
170
 
   *  from the high end. This allows one to give:
171
 
   *  DAY_TO_SECOND as "D MM:HH:SS", "MM:HH:SS" "HH:SS" or as seconds.
172
 
   *
173
 
   *  @param[in] length:         length of str
174
 
   *  @param[in] cs:             charset of str
175
 
   *  @param[out] values:         array of results
176
 
   *  @param[out] count:          count of elements in result array
177
 
   *  @param transform_msec: if value is true we suppose
178
 
   *  that the last part of string value is microseconds
179
 
   *  and we should transform value to six digit value.
180
 
   *  For example, '1.1' -> '1.100000'
181
 
   */
182
 
  bool getIntervalFromString(const char *str,
183
 
                             uint32_t length, 
184
 
                             const CHARSET_INFO * const cs,
185
 
                             uint32_t count, 
186
 
                             uint64_t *values,
187
 
                             bool transform_msec);
188
 
 
189
 
  uint32_t  year;
190
 
  uint32_t  month;
191
 
  uint32_t  day;
192
 
  uint32_t  hour;
193
 
  uint64_t  minute;
194
 
  uint64_t  second;
195
 
  uint64_t  second_part;
196
 
  bool      neg;
197
 
 
198
 
};
199
 
 
200
 
} /* namespace drizzled */
201
 
 
202
 
#endif /* DRIZZLED_TEMPORAL_INTERVAL_H */