← Back to branch summary

~davidagraf/zorba/trace_without_debug_info

« back to all changes in this revision

Viewing changes to src/runtime/durations_dates_times/pregenerated/durations_dates_times.cpp

  • Committer: David Graf
  • Date: 2012-06-27 07:20:59 UTC
  • mfrom: (10869.1.25 zorba)
  • Revision ID: davidagraf@gmail.com-20120627072059-723duu6vsbqu60ax
merged trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/runtime/durations_dates_times/pregenerated/durations_dates_times.cpp
33
33
namespace zorba {
34
34
 
35
35
// <YearsFromDurationIterator>
36
 
YearsFromDurationIterator::class_factory<YearsFromDurationIterator>
37
 
YearsFromDurationIterator::g_class_factory;
38
 
 
39
 
 
40
 
void YearsFromDurationIterator::accept(PlanIterVisitor& v) const {
 
36
SERIALIZABLE_CLASS_VERSIONS(YearsFromDurationIterator)
 
37
 
 
38
void YearsFromDurationIterator::serialize(::zorba::serialization::Archiver& ar)
 
39
{
 
40
  serialize_baseclass(ar,
 
41
  (NaryBaseIterator<YearsFromDurationIterator, PlanIteratorState>*)this);
 
42
}
 
43
 
 
44
 
 
45
void YearsFromDurationIterator::accept(PlanIterVisitor& v) const
 
46
{
41
47
  v.beginVisit(*this);
42
48
 
43
49
  std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
55
61
 
56
62
 
57
63
// <MonthsFromDurationIterator>
58
 
MonthsFromDurationIterator::class_factory<MonthsFromDurationIterator>
59
 
MonthsFromDurationIterator::g_class_factory;
60
 
 
61
 
 
62
 
void MonthsFromDurationIterator::accept(PlanIterVisitor& v) const {
 
64
SERIALIZABLE_CLASS_VERSIONS(MonthsFromDurationIterator)
 
65
 
 
66
void MonthsFromDurationIterator::serialize(::zorba::serialization::Archiver& ar)
 
67
{
 
68
  serialize_baseclass(ar,
 
69
  (NaryBaseIterator<MonthsFromDurationIterator, PlanIteratorState>*)this);
 
70
}
 
71
 
 
72
 
 
73
void MonthsFromDurationIterator::accept(PlanIterVisitor& v) const
 
74
{
63
75
  v.beginVisit(*this);
64
76
 
65
77
  std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
77
89
 
78
90
 
79
91
// <DaysFromDurationIterator>
80
 
DaysFromDurationIterator::class_factory<DaysFromDurationIterator>
81
 
DaysFromDurationIterator::g_class_factory;
82
 
 
83
 
 
84
 
void DaysFromDurationIterator::accept(PlanIterVisitor& v) const {
 
92
SERIALIZABLE_CLASS_VERSIONS(DaysFromDurationIterator)
 
93
 
 
94
void DaysFromDurationIterator::serialize(::zorba::serialization::Archiver& ar)
 
95
{
 
96
  serialize_baseclass(ar,
 
97
  (NaryBaseIterator<DaysFromDurationIterator, PlanIteratorState>*)this);
 
98
}
 
99
 
 
100
 
 
101
void DaysFromDurationIterator::accept(PlanIterVisitor& v) const
 
102
{
85
103
  v.beginVisit(*this);
86
104
 
87
105
  std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
99
117
 
100
118
 
101
119
// <HoursFromDurationIterator>
102
 
HoursFromDurationIterator::class_factory<HoursFromDurationIterator>
103
 
HoursFromDurationIterator::g_class_factory;
104
 
 
105
 
 
106
 
void HoursFromDurationIterator::accept(PlanIterVisitor& v) const {
 
120
SERIALIZABLE_CLASS_VERSIONS(HoursFromDurationIterator)
 
121
 
 
122
void HoursFromDurationIterator::serialize(::zorba::serialization::Archiver& ar)
 
123
{
 
124
  serialize_baseclass(ar,
 
125
  (NaryBaseIterator<HoursFromDurationIterator, PlanIteratorState>*)this);
 
126
}
 
127
 
 
128
 
 
129
void HoursFromDurationIterator::accept(PlanIterVisitor& v) const
 
130
{
107
131
  v.beginVisit(*this);
108
132
 
109
133
  std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
121
145
 
122
146
 
123
147
// <MinutesFromDurationIterator>
124
 
MinutesFromDurationIterator::class_factory<MinutesFromDurationIterator>
125
 
MinutesFromDurationIterator::g_class_factory;
126
 
 
127
 
 
128
 
void MinutesFromDurationIterator::accept(PlanIterVisitor& v) const {
 
148
SERIALIZABLE_CLASS_VERSIONS(MinutesFromDurationIterator)
 
149
 
 
150
void MinutesFromDurationIterator::serialize(::zorba::serialization::Archiver& ar)
 
151
{
 
152
  serialize_baseclass(ar,
 
153
  (NaryBaseIterator<MinutesFromDurationIterator, PlanIteratorState>*)this);
 
154
}
 
155
 
 
156
 
 
157
void MinutesFromDurationIterator::accept(PlanIterVisitor& v) const
 
158
{
129
159
  v.beginVisit(*this);
130
160
 
131
161
  std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
143
173
 
144
174
 
145
175
// <SecondsFromDurationIterator>
146
 
SecondsFromDurationIterator::class_factory<SecondsFromDurationIterator>
147
 
SecondsFromDurationIterator::g_class_factory;
148
 
 
149
 
 
150
 
void SecondsFromDurationIterator::accept(PlanIterVisitor& v) const {
 
176
SERIALIZABLE_CLASS_VERSIONS(SecondsFromDurationIterator)
 
177
 
 
178
void SecondsFromDurationIterator::serialize(::zorba::serialization::Archiver& ar)
 
179
{
 
180
  serialize_baseclass(ar,
 
181
  (NaryBaseIterator<SecondsFromDurationIterator, PlanIteratorState>*)this);
 
182
}
 
183
 
 
184
 
 
185
void SecondsFromDurationIterator::accept(PlanIterVisitor& v) const
 
186
{
151
187
  v.beginVisit(*this);
152
188
 
153
189
  std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
165
201
 
166
202
 
167
203
// <YearFromDatetimeIterator>
168
 
YearFromDatetimeIterator::class_factory<YearFromDatetimeIterator>
169
 
YearFromDatetimeIterator::g_class_factory;
170
 
 
171
 
 
172
 
void YearFromDatetimeIterator::accept(PlanIterVisitor& v) const {
 
204
SERIALIZABLE_CLASS_VERSIONS(YearFromDatetimeIterator)
 
205
 
 
206
void YearFromDatetimeIterator::serialize(::zorba::serialization::Archiver& ar)
 
207
{
 
208
  serialize_baseclass(ar,
 
209
  (NaryBaseIterator<YearFromDatetimeIterator, PlanIteratorState>*)this);
 
210
}
 
211
 
 
212
 
 
213
void YearFromDatetimeIterator::accept(PlanIterVisitor& v) const
 
214
{
173
215
  v.beginVisit(*this);
174
216
 
175
217
  std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
187
229
 
188
230
 
189
231
// <MonthFromDatetimeIterator>
190
 
MonthFromDatetimeIterator::class_factory<MonthFromDatetimeIterator>
191
 
MonthFromDatetimeIterator::g_class_factory;
192
 
 
193
 
 
194
 
void MonthFromDatetimeIterator::accept(PlanIterVisitor& v) const {
 
232
SERIALIZABLE_CLASS_VERSIONS(MonthFromDatetimeIterator)
 
233
 
 
234
void MonthFromDatetimeIterator::serialize(::zorba::serialization::Archiver& ar)
 
235
{
 
236
  serialize_baseclass(ar,
 
237
  (NaryBaseIterator<MonthFromDatetimeIterator, PlanIteratorState>*)this);
 
238
}
 
239
 
 
240
 
 
241
void MonthFromDatetimeIterator::accept(PlanIterVisitor& v) const
 
242
{
195
243
  v.beginVisit(*this);
196
244
 
197
245
  std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
209
257
 
210
258
 
211
259
// <DayFromDatetimeIterator>
212
 
DayFromDatetimeIterator::class_factory<DayFromDatetimeIterator>
213
 
DayFromDatetimeIterator::g_class_factory;
214
 
 
215
 
 
216
 
void DayFromDatetimeIterator::accept(PlanIterVisitor& v) const {
 
260
SERIALIZABLE_CLASS_VERSIONS(DayFromDatetimeIterator)
 
261
 
 
262
void DayFromDatetimeIterator::serialize(::zorba::serialization::Archiver& ar)
 
263
{
 
264
  serialize_baseclass(ar,
 
265
  (NaryBaseIterator<DayFromDatetimeIterator, PlanIteratorState>*)this);
 
266
}
 
267
 
 
268
 
 
269
void DayFromDatetimeIterator::accept(PlanIterVisitor& v) const
 
270
{
217
271
  v.beginVisit(*this);
218
272
 
219
273
  std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
231
285
 
232
286
 
233
287
// <HoursFromDatetimeIterator>
234
 
HoursFromDatetimeIterator::class_factory<HoursFromDatetimeIterator>
235
 
HoursFromDatetimeIterator::g_class_factory;
236
 
 
237
 
 
238
 
void HoursFromDatetimeIterator::accept(PlanIterVisitor& v) const {
 
288
SERIALIZABLE_CLASS_VERSIONS(HoursFromDatetimeIterator)
 
289
 
 
290
void HoursFromDatetimeIterator::serialize(::zorba::serialization::Archiver& ar)
 
291
{
 
292
  serialize_baseclass(ar,
 
293
  (NaryBaseIterator<HoursFromDatetimeIterator, PlanIteratorState>*)this);
 
294
}
 
295
 
 
296
 
 
297
void HoursFromDatetimeIterator::accept(PlanIterVisitor& v) const
 
298
{
239
299
  v.beginVisit(*this);
240
300
 
241
301
  std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
253
313
 
254
314
 
255
315
// <MinutesFromDatetimeIterator>
256
 
MinutesFromDatetimeIterator::class_factory<MinutesFromDatetimeIterator>
257
 
MinutesFromDatetimeIterator::g_class_factory;
258
 
 
259
 
 
260
 
void MinutesFromDatetimeIterator::accept(PlanIterVisitor& v) const {
 
316
SERIALIZABLE_CLASS_VERSIONS(MinutesFromDatetimeIterator)
 
317
 
 
318
void MinutesFromDatetimeIterator::serialize(::zorba::serialization::Archiver& ar)
 
319
{
 
320
  serialize_baseclass(ar,
 
321
  (NaryBaseIterator<MinutesFromDatetimeIterator, PlanIteratorState>*)this);
 
322
}
 
323
 
 
324
 
 
325
void MinutesFromDatetimeIterator::accept(PlanIterVisitor& v) const
 
326
{
261
327
  v.beginVisit(*this);
262
328
 
263
329
  std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
275
341
 
276
342
 
277
343
// <SecondsFromDatetimeIterator>
278
 
SecondsFromDatetimeIterator::class_factory<SecondsFromDatetimeIterator>
279
 
SecondsFromDatetimeIterator::g_class_factory;
280
 
 
281
 
 
282
 
void SecondsFromDatetimeIterator::accept(PlanIterVisitor& v) const {
 
344
SERIALIZABLE_CLASS_VERSIONS(SecondsFromDatetimeIterator)
 
345
 
 
346
void SecondsFromDatetimeIterator::serialize(::zorba::serialization::Archiver& ar)
 
347
{
 
348
  serialize_baseclass(ar,
 
349
  (NaryBaseIterator<SecondsFromDatetimeIterator, PlanIteratorState>*)this);
 
350
}
 
351
 
 
352
 
 
353
void SecondsFromDatetimeIterator::accept(PlanIterVisitor& v) const
 
354
{
283
355
  v.beginVisit(*this);
284
356
 
285
357
  std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
297
369
 
298
370
 
299
371
// <TimezoneFromDatetimeIterator>
300
 
TimezoneFromDatetimeIterator::class_factory<TimezoneFromDatetimeIterator>
301
 
TimezoneFromDatetimeIterator::g_class_factory;
302
 
 
303
 
 
304
 
void TimezoneFromDatetimeIterator::accept(PlanIterVisitor& v) const {
 
372
SERIALIZABLE_CLASS_VERSIONS(TimezoneFromDatetimeIterator)
 
373
 
 
374
void TimezoneFromDatetimeIterator::serialize(::zorba::serialization::Archiver& ar)
 
375
{
 
376
  serialize_baseclass(ar,
 
377
  (NaryBaseIterator<TimezoneFromDatetimeIterator, PlanIteratorState>*)this);
 
378
}
 
379
 
 
380
 
 
381
void TimezoneFromDatetimeIterator::accept(PlanIterVisitor& v) const
 
382
{
305
383
  v.beginVisit(*this);
306
384
 
307
385
  std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
319
397
 
320
398
 
321
399
// <YearFromDateIterator>
322
 
YearFromDateIterator::class_factory<YearFromDateIterator>
323
 
YearFromDateIterator::g_class_factory;
324
 
 
325
 
 
326
 
void YearFromDateIterator::accept(PlanIterVisitor& v) const {
 
400
SERIALIZABLE_CLASS_VERSIONS(YearFromDateIterator)
 
401
 
 
402
void YearFromDateIterator::serialize(::zorba::serialization::Archiver& ar)
 
403
{
 
404
  serialize_baseclass(ar,
 
405
  (NaryBaseIterator<YearFromDateIterator, PlanIteratorState>*)this);
 
406
}
 
407
 
 
408
 
 
409
void YearFromDateIterator::accept(PlanIterVisitor& v) const
 
410
{
327
411
  v.beginVisit(*this);
328
412
 
329
413
  std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
341
425
 
342
426
 
343
427
// <MonthFromDateIterator>
344
 
MonthFromDateIterator::class_factory<MonthFromDateIterator>
345
 
MonthFromDateIterator::g_class_factory;
346
 
 
347
 
 
348
 
void MonthFromDateIterator::accept(PlanIterVisitor& v) const {
 
428
SERIALIZABLE_CLASS_VERSIONS(MonthFromDateIterator)
 
429
 
 
430
void MonthFromDateIterator::serialize(::zorba::serialization::Archiver& ar)
 
431
{
 
432
  serialize_baseclass(ar,
 
433
  (NaryBaseIterator<MonthFromDateIterator, PlanIteratorState>*)this);
 
434
}
 
435
 
 
436
 
 
437
void MonthFromDateIterator::accept(PlanIterVisitor& v) const
 
438
{
349
439
  v.beginVisit(*this);
350
440
 
351
441
  std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
363
453
 
364
454
 
365
455
// <DayFromDateIterator>
366
 
DayFromDateIterator::class_factory<DayFromDateIterator>
367
 
DayFromDateIterator::g_class_factory;
368
 
 
369
 
 
370
 
void DayFromDateIterator::accept(PlanIterVisitor& v) const {
 
456
SERIALIZABLE_CLASS_VERSIONS(DayFromDateIterator)
 
457
 
 
458
void DayFromDateIterator::serialize(::zorba::serialization::Archiver& ar)
 
459
{
 
460
  serialize_baseclass(ar,
 
461
  (NaryBaseIterator<DayFromDateIterator, PlanIteratorState>*)this);
 
462
}
 
463
 
 
464
 
 
465
void DayFromDateIterator::accept(PlanIterVisitor& v) const
 
466
{
371
467
  v.beginVisit(*this);
372
468
 
373
469
  std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
385
481
 
386
482
 
387
483
// <TimezoneFromDateIterator>
388
 
TimezoneFromDateIterator::class_factory<TimezoneFromDateIterator>
389
 
TimezoneFromDateIterator::g_class_factory;
390
 
 
391
 
 
392
 
void TimezoneFromDateIterator::accept(PlanIterVisitor& v) const {
 
484
SERIALIZABLE_CLASS_VERSIONS(TimezoneFromDateIterator)
 
485
 
 
486
void TimezoneFromDateIterator::serialize(::zorba::serialization::Archiver& ar)
 
487
{
 
488
  serialize_baseclass(ar,
 
489
  (NaryBaseIterator<TimezoneFromDateIterator, PlanIteratorState>*)this);
 
490
}
 
491
 
 
492
 
 
493
void TimezoneFromDateIterator::accept(PlanIterVisitor& v) const
 
494
{
393
495
  v.beginVisit(*this);
394
496
 
395
497
  std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
407
509
 
408
510
 
409
511
// <HoursFromTimeIterator>
410
 
HoursFromTimeIterator::class_factory<HoursFromTimeIterator>
411
 
HoursFromTimeIterator::g_class_factory;
412
 
 
413
 
 
414
 
void HoursFromTimeIterator::accept(PlanIterVisitor& v) const {
 
512
SERIALIZABLE_CLASS_VERSIONS(HoursFromTimeIterator)
 
513
 
 
514
void HoursFromTimeIterator::serialize(::zorba::serialization::Archiver& ar)
 
515
{
 
516
  serialize_baseclass(ar,
 
517
  (NaryBaseIterator<HoursFromTimeIterator, PlanIteratorState>*)this);
 
518
}
 
519
 
 
520
 
 
521
void HoursFromTimeIterator::accept(PlanIterVisitor& v) const
 
522
{
415
523
  v.beginVisit(*this);
416
524
 
417
525
  std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
429
537
 
430
538
 
431
539
// <MinutesFromTimeIterator>
432
 
MinutesFromTimeIterator::class_factory<MinutesFromTimeIterator>
433
 
MinutesFromTimeIterator::g_class_factory;
434
 
 
435
 
 
436
 
void MinutesFromTimeIterator::accept(PlanIterVisitor& v) const {
 
540
SERIALIZABLE_CLASS_VERSIONS(MinutesFromTimeIterator)
 
541
 
 
542
void MinutesFromTimeIterator::serialize(::zorba::serialization::Archiver& ar)
 
543
{
 
544
  serialize_baseclass(ar,
 
545
  (NaryBaseIterator<MinutesFromTimeIterator, PlanIteratorState>*)this);
 
546
}
 
547
 
 
548
 
 
549
void MinutesFromTimeIterator::accept(PlanIterVisitor& v) const
 
550
{
437
551
  v.beginVisit(*this);
438
552
 
439
553
  std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
451
565
 
452
566
 
453
567
// <SecondsFromTimeIterator>
454
 
SecondsFromTimeIterator::class_factory<SecondsFromTimeIterator>
455
 
SecondsFromTimeIterator::g_class_factory;
456
 
 
457
 
 
458
 
void SecondsFromTimeIterator::accept(PlanIterVisitor& v) const {
 
568
SERIALIZABLE_CLASS_VERSIONS(SecondsFromTimeIterator)
 
569
 
 
570
void SecondsFromTimeIterator::serialize(::zorba::serialization::Archiver& ar)
 
571
{
 
572
  serialize_baseclass(ar,
 
573
  (NaryBaseIterator<SecondsFromTimeIterator, PlanIteratorState>*)this);
 
574
}
 
575
 
 
576
 
 
577
void SecondsFromTimeIterator::accept(PlanIterVisitor& v) const
 
578
{
459
579
  v.beginVisit(*this);
460
580
 
461
581
  std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
473
593
 
474
594
 
475
595
// <TimezoneFromTimeIterator>
476
 
TimezoneFromTimeIterator::class_factory<TimezoneFromTimeIterator>
477
 
TimezoneFromTimeIterator::g_class_factory;
478
 
 
479
 
 
480
 
void TimezoneFromTimeIterator::accept(PlanIterVisitor& v) const {
 
596
SERIALIZABLE_CLASS_VERSIONS(TimezoneFromTimeIterator)
 
597
 
 
598
void TimezoneFromTimeIterator::serialize(::zorba::serialization::Archiver& ar)
 
599
{
 
600
  serialize_baseclass(ar,
 
601
  (NaryBaseIterator<TimezoneFromTimeIterator, PlanIteratorState>*)this);
 
602
}
 
603
 
 
604
 
 
605
void TimezoneFromTimeIterator::accept(PlanIterVisitor& v) const
 
606
{
481
607
  v.beginVisit(*this);
482
608
 
483
609
  std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();