← Back to branch summary

~ubuntu-branches/ubuntu/wily/davix/wily

« back to all changes in this revision

Viewing changes to deps/boost_intern/boost/date_time/gregorian/gregorian_io.hpp

  • Committer: Package Import Robot
  • Author(s): Mattias Ellert
  • Date: 2015-07-31 13:17:55 UTC
  • mfrom: (5.1.3 sid)
  • Revision ID: package-import@ubuntu.com-20150731131755-mizprbmn7ogv33te
Tags: 0.4.1-1
* Update to version 0.4.1
* Implement Multi-Arch support

Show diffs side-by-side

added added

removed removed

Lines of Context:
deps/boost_intern/boost/date_time/gregorian/gregorian_io.hpp
1
 
#ifndef DATE_TIME_GREGORIAN_IO_HPP__
2
 
#define DATE_TIME_GREGORIAN_IO_HPP__
3
 
 
4
 
/* Copyright (c) 2004-2005 CrystalClear Software, Inc.
5
 
 * Use, modification and distribution is subject to the
6
 
 * Boost Software License, Version 1.0. (See accompanying
7
 
 * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
8
 
 * Author: Jeff Garland, Bart Garst
9
 
 * $Date: 2008-11-12 11:37:53 -0800 (Wed, 12 Nov 2008) $
10
 
 */
11
 
 
12
 
#include <locale>
13
 
#include <iostream>
14
 
#include <iterator> // i/ostreambuf_iterator
15
 
#include <boost/io/ios_state.hpp>
16
 
#include <boost/date_time/date_facet.hpp>
17
 
#include <boost/date_time/period_parser.hpp>
18
 
#include <boost/date_time/period_formatter.hpp>
19
 
#include <boost/date_time/special_values_parser.hpp>
20
 
#include <boost/date_time/special_values_formatter.hpp>
21
 
#include <boost/date_time/gregorian/gregorian_types.hpp>
22
 
#include <boost/date_time/gregorian/conversion.hpp> // to_tm will be needed in the facets
23
 
 
24
 
namespace boost {
25
 
namespace gregorian {
26
 
 
27
 
 
28
 
  typedef boost::date_time::period_formatter<wchar_t> wperiod_formatter;
29
 
  typedef boost::date_time::period_formatter<char>    period_formatter;
30
 
  
31
 
  typedef boost::date_time::date_facet<date,wchar_t> wdate_facet;
32
 
  typedef boost::date_time::date_facet<date,char>    date_facet;
33
 
 
34
 
  typedef boost::date_time::period_parser<date,char>       period_parser;
35
 
  typedef boost::date_time::period_parser<date,wchar_t>    wperiod_parser;
36
 
    
37
 
  typedef boost::date_time::special_values_formatter<char> special_values_formatter; 
38
 
  typedef boost::date_time::special_values_formatter<wchar_t> wspecial_values_formatter; 
39
 
  
40
 
  typedef boost::date_time::special_values_parser<date,char> special_values_parser; 
41
 
  typedef boost::date_time::special_values_parser<date,wchar_t> wspecial_values_parser; 
42
 
  
43
 
  typedef boost::date_time::date_input_facet<date,char>    date_input_facet;
44
 
  typedef boost::date_time::date_input_facet<date,wchar_t> wdate_input_facet;
45
 
 
46
 
  template <class CharT, class TraitsT>
47
 
  inline std::basic_ostream<CharT, TraitsT>&
48
 
  operator<<(std::basic_ostream<CharT, TraitsT>& os, const boost::gregorian::date& d) {
49
 
    boost::io::ios_flags_saver iflags(os);
50
 
    typedef boost::date_time::date_facet<date, CharT> custom_date_facet;
51
 
    std::ostreambuf_iterator<CharT> output_itr(os);
52
 
    if (std::has_facet<custom_date_facet>(os.getloc()))
53
 
      std::use_facet<custom_date_facet>(os.getloc()).put(output_itr, os, os.fill(), d);
54
 
    else {
55
 
      //instantiate a custom facet for dealing with dates since the user
56
 
      //has not put one in the stream so far.  This is for efficiency 
57
 
      //since we would always need to reconstruct for every date
58
 
      //if the locale did not already exist.  Of course this will be overridden
59
 
      //if the user imbues at some later point.  With the default settings
60
 
      //for the facet the resulting format will be the same as the
61
 
      //std::time_facet settings.
62
 
      custom_date_facet* f = new custom_date_facet();
63
 
      std::locale l = std::locale(os.getloc(), f);
64
 
      os.imbue(l);
65
 
      f->put(output_itr, os, os.fill(), d);
66
 
    }
67
 
    return os;
68
 
  }
69
 
 
70
 
  //! input operator for date
71
 
  template <class CharT, class Traits>
72
 
  inline
73
 
  std::basic_istream<CharT, Traits>&
74
 
  operator>>(std::basic_istream<CharT, Traits>& is, date& d)
75
 
  {
76
 
    boost::io::ios_flags_saver iflags(is);
77
 
    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 
78
 
    if (strm_sentry) {
79
 
      try {
80
 
        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
81
 
        
82
 
        std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
83
 
        if(std::has_facet<date_input_facet>(is.getloc())) {
84
 
          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, d);
85
 
        }
86
 
        else {
87
 
          date_input_facet* f = new date_input_facet();
88
 
          std::locale l = std::locale(is.getloc(), f);
89
 
          is.imbue(l);
90
 
          f->get(sit, str_end, is, d);
91
 
        }
92
 
      }
93
 
      catch(...) { 
94
 
        // mask tells us what exceptions are turned on
95
 
        std::ios_base::iostate exception_mask = is.exceptions();
96
 
        // if the user wants exceptions on failbit, we'll rethrow our 
97
 
        // date_time exception & set the failbit
98
 
        if(std::ios_base::failbit & exception_mask) {
99
 
          try { is.setstate(std::ios_base::failbit); } 
100
 
          catch(std::ios_base::failure&) {} // ignore this one
101
 
          throw; // rethrow original exception
102
 
        }
103
 
        else {
104
 
          // if the user want's to fail quietly, we simply set the failbit
105
 
          is.setstate(std::ios_base::failbit); 
106
 
        } 
107
 
            
108
 
      }
109
 
    }    
110
 
    return is;
111
 
  }
112
 
 
113
 
  template <class CharT, class TraitsT>
114
 
  inline std::basic_ostream<CharT, TraitsT>&
115
 
  operator<<(std::basic_ostream<CharT, TraitsT>& os, const boost::gregorian::date_duration& dd) {
116
 
    boost::io::ios_flags_saver iflags(os);
117
 
    typedef boost::date_time::date_facet<date, CharT> custom_date_facet;
118
 
    std::ostreambuf_iterator<CharT> output_itr(os);
119
 
    if (std::has_facet<custom_date_facet>(os.getloc()))
120
 
      std::use_facet<custom_date_facet>(os.getloc()).put(output_itr, os, os.fill(), dd);
121
 
    else {
122
 
      custom_date_facet* f = new custom_date_facet();
123
 
      std::locale l = std::locale(os.getloc(), f);
124
 
      os.imbue(l);
125
 
      f->put(output_itr, os, os.fill(), dd);
126
 
 
127
 
    }
128
 
    return os;
129
 
  }
130
 
 
131
 
  //! input operator for date_duration
132
 
  template <class CharT, class Traits>
133
 
  inline
134
 
  std::basic_istream<CharT, Traits>&
135
 
  operator>>(std::basic_istream<CharT, Traits>& is, date_duration& dd)
136
 
  {
137
 
    boost::io::ios_flags_saver iflags(is);
138
 
    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 
139
 
    if (strm_sentry) {
140
 
      try {
141
 
        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
142
 
        
143
 
        std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
144
 
        if(std::has_facet<date_input_facet>(is.getloc())) {
145
 
          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, dd);
146
 
        }
147
 
        else {
148
 
          date_input_facet* f = new date_input_facet();
149
 
          std::locale l = std::locale(is.getloc(), f);
150
 
          is.imbue(l);
151
 
          f->get(sit, str_end, is, dd);
152
 
        }
153
 
      }
154
 
      catch(...) { 
155
 
        std::ios_base::iostate exception_mask = is.exceptions();
156
 
        if(std::ios_base::failbit & exception_mask) {
157
 
          try { is.setstate(std::ios_base::failbit); } 
158
 
          catch(std::ios_base::failure&) {}
159
 
          throw; // rethrow original exception
160
 
        }
161
 
        else {
162
 
          is.setstate(std::ios_base::failbit); 
163
 
        } 
164
 
            
165
 
      }
166
 
    }
167
 
    return is;
168
 
  }
169
 
 
170
 
  template <class CharT, class TraitsT>
171
 
  inline std::basic_ostream<CharT, TraitsT>&
172
 
  operator<<(std::basic_ostream<CharT, TraitsT>& os, const boost::gregorian::date_period& dp) {
173
 
    boost::io::ios_flags_saver iflags(os);
174
 
    typedef boost::date_time::date_facet<date, CharT> custom_date_facet;
175
 
    std::ostreambuf_iterator<CharT> output_itr(os);
176
 
    if (std::has_facet<custom_date_facet>(os.getloc()))
177
 
      std::use_facet<custom_date_facet>(os.getloc()).put(output_itr, os, os.fill(), dp);
178
 
    else {
179
 
      //instantiate a custom facet for dealing with date periods since the user
180
 
      //has not put one in the stream so far.  This is for efficiency 
181
 
      //since we would always need to reconstruct for every time period
182
 
      //if the local did not already exist.  Of course this will be overridden
183
 
      //if the user imbues at some later point.  With the default settings
184
 
      //for the facet the resulting format will be the same as the
185
 
      //std::time_facet settings.
186
 
      custom_date_facet* f = new custom_date_facet();
187
 
      std::locale l = std::locale(os.getloc(), f);
188
 
      os.imbue(l);
189
 
      f->put(output_itr, os, os.fill(), dp);
190
 
 
191
 
    }
192
 
    return os;
193
 
  }
194
 
 
195
 
  //! input operator for date_period 
196
 
  template <class CharT, class Traits>
197
 
  inline
198
 
  std::basic_istream<CharT, Traits>&
199
 
  operator>>(std::basic_istream<CharT, Traits>& is, date_period& dp)
200
 
  {
201
 
    boost::io::ios_flags_saver iflags(is);
202
 
    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 
203
 
    if (strm_sentry) {
204
 
      try {
205
 
        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
206
 
 
207
 
        std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
208
 
        if(std::has_facet<date_input_facet>(is.getloc())) {
209
 
          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, dp);
210
 
        }
211
 
        else {
212
 
          date_input_facet* f = new date_input_facet();
213
 
          std::locale l = std::locale(is.getloc(), f);
214
 
          is.imbue(l);
215
 
          f->get(sit, str_end, is, dp);
216
 
        }
217
 
      }
218
 
      catch(...) { 
219
 
        std::ios_base::iostate exception_mask = is.exceptions();
220
 
        if(std::ios_base::failbit & exception_mask) {
221
 
          try { is.setstate(std::ios_base::failbit); } 
222
 
          catch(std::ios_base::failure&) {}
223
 
          throw; // rethrow original exception
224
 
        }
225
 
        else {
226
 
          is.setstate(std::ios_base::failbit); 
227
 
        } 
228
 
            
229
 
      }
230
 
    }
231
 
    return is;
232
 
  }
233
 
 
234
 
  /********** small gregorian types **********/
235
 
  
236
 
  template <class CharT, class TraitsT>
237
 
  inline std::basic_ostream<CharT, TraitsT>&
238
 
  operator<<(std::basic_ostream<CharT, TraitsT>& os, const boost::gregorian::greg_month& gm) {
239
 
    boost::io::ios_flags_saver iflags(os);
240
 
    typedef boost::date_time::date_facet<date, CharT> custom_date_facet;
241
 
    std::ostreambuf_iterator<CharT> output_itr(os);
242
 
    if (std::has_facet<custom_date_facet>(os.getloc()))
243
 
      std::use_facet<custom_date_facet>(os.getloc()).put(output_itr, os, os.fill(), gm);
244
 
    else {
245
 
      custom_date_facet* f = new custom_date_facet();//-> 10/1074199752/32 because year & day not initialized in put(...)
246
 
      //custom_date_facet* f = new custom_date_facet("%B");
247
 
      std::locale l = std::locale(os.getloc(), f);
248
 
      os.imbue(l);
249
 
      f->put(output_itr, os, os.fill(), gm);
250
 
    }
251
 
    return os;
252
 
  }
253
 
 
254
 
  //! input operator for greg_month
255
 
  template <class CharT, class Traits>
256
 
  inline
257
 
  std::basic_istream<CharT, Traits>&
258
 
  operator>>(std::basic_istream<CharT, Traits>& is, greg_month& m)
259
 
  {
260
 
    boost::io::ios_flags_saver iflags(is);
261
 
    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 
262
 
    if (strm_sentry) {
263
 
      try {
264
 
        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
265
 
 
266
 
        std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
267
 
        if(std::has_facet<date_input_facet>(is.getloc())) {
268
 
          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, m);
269
 
        }
270
 
        else {
271
 
          date_input_facet* f = new date_input_facet();
272
 
          std::locale l = std::locale(is.getloc(), f);
273
 
          is.imbue(l);
274
 
          f->get(sit, str_end, is, m);
275
 
        }
276
 
      }
277
 
      catch(...) { 
278
 
        std::ios_base::iostate exception_mask = is.exceptions();
279
 
        if(std::ios_base::failbit & exception_mask) {
280
 
          try { is.setstate(std::ios_base::failbit); } 
281
 
          catch(std::ios_base::failure&) {}
282
 
          throw; // rethrow original exception
283
 
        }
284
 
        else {
285
 
          is.setstate(std::ios_base::failbit); 
286
 
        } 
287
 
            
288
 
      }
289
 
    }
290
 
    return is;
291
 
  }
292
 
 
293
 
 
294
 
  template <class CharT, class TraitsT>
295
 
  inline std::basic_ostream<CharT, TraitsT>&
296
 
  operator<<(std::basic_ostream<CharT, TraitsT>& os, const boost::gregorian::greg_weekday& gw) {
297
 
    boost::io::ios_flags_saver iflags(os);
298
 
    typedef boost::date_time::date_facet<date, CharT> custom_date_facet;
299
 
    std::ostreambuf_iterator<CharT> output_itr(os);
300
 
    if (std::has_facet<custom_date_facet>(os.getloc()))
301
 
      std::use_facet<custom_date_facet>(os.getloc()).put(output_itr, os, os.fill(), gw);
302
 
    else {
303
 
      custom_date_facet* f = new custom_date_facet();
304
 
      std::locale l = std::locale(os.getloc(), f);
305
 
      os.imbue(l);
306
 
      f->put(output_itr, os, os.fill(), gw);
307
 
    }
308
 
    return os;
309
 
  }
310
 
 
311
 
  //! input operator for greg_weekday
312
 
  template <class CharT, class Traits>
313
 
  inline
314
 
  std::basic_istream<CharT, Traits>&
315
 
  operator>>(std::basic_istream<CharT, Traits>& is, greg_weekday& wd)
316
 
  {
317
 
    boost::io::ios_flags_saver iflags(is);
318
 
    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 
319
 
    if (strm_sentry) {
320
 
      try {
321
 
        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
322
 
 
323
 
        std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
324
 
        if(std::has_facet<date_input_facet>(is.getloc())) {
325
 
          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, wd);
326
 
        }
327
 
        else {
328
 
          date_input_facet* f = new date_input_facet();
329
 
          std::locale l = std::locale(is.getloc(), f);
330
 
          is.imbue(l);
331
 
          f->get(sit, str_end, is, wd);
332
 
        }
333
 
      }
334
 
      catch(...) { 
335
 
        std::ios_base::iostate exception_mask = is.exceptions();
336
 
        if(std::ios_base::failbit & exception_mask) {
337
 
          try { is.setstate(std::ios_base::failbit); } 
338
 
          catch(std::ios_base::failure&) {}
339
 
          throw; // rethrow original exception
340
 
        }
341
 
        else {
342
 
          is.setstate(std::ios_base::failbit); 
343
 
        } 
344
 
            
345
 
      }
346
 
    }
347
 
    return is;
348
 
  }
349
 
 
350
 
  //NOTE: output operator for greg_day was not necessary
351
 
 
352
 
  //! input operator for greg_day
353
 
  template <class CharT, class Traits>
354
 
  inline
355
 
  std::basic_istream<CharT, Traits>&
356
 
  operator>>(std::basic_istream<CharT, Traits>& is, greg_day& gd)
357
 
  {
358
 
    boost::io::ios_flags_saver iflags(is);
359
 
    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 
360
 
    if (strm_sentry) {
361
 
      try {
362
 
        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
363
 
 
364
 
        std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
365
 
        if(std::has_facet<date_input_facet>(is.getloc())) {
366
 
          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, gd);
367
 
        }
368
 
        else {
369
 
          date_input_facet* f = new date_input_facet();
370
 
          std::locale l = std::locale(is.getloc(), f);
371
 
          is.imbue(l);
372
 
          f->get(sit, str_end, is, gd);
373
 
        }
374
 
      }
375
 
      catch(...) { 
376
 
        std::ios_base::iostate exception_mask = is.exceptions();
377
 
        if(std::ios_base::failbit & exception_mask) {
378
 
          try { is.setstate(std::ios_base::failbit); } 
379
 
          catch(std::ios_base::failure&) {}
380
 
          throw; // rethrow original exception
381
 
        }
382
 
        else {
383
 
          is.setstate(std::ios_base::failbit); 
384
 
        } 
385
 
            
386
 
      }
387
 
    }
388
 
    return is;
389
 
  }
390
 
 
391
 
  //NOTE: output operator for greg_year was not necessary
392
 
 
393
 
  //! input operator for greg_year
394
 
  template <class CharT, class Traits>
395
 
  inline
396
 
  std::basic_istream<CharT, Traits>&
397
 
  operator>>(std::basic_istream<CharT, Traits>& is, greg_year& gy)
398
 
  {
399
 
    boost::io::ios_flags_saver iflags(is);
400
 
    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 
401
 
    if (strm_sentry) {
402
 
      try {
403
 
        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
404
 
 
405
 
        std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
406
 
        if(std::has_facet<date_input_facet>(is.getloc())) {
407
 
          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, gy);
408
 
        }
409
 
        else {
410
 
          date_input_facet* f = new date_input_facet();
411
 
          std::locale l = std::locale(is.getloc(), f);
412
 
          is.imbue(l);
413
 
          f->get(sit, str_end, is, gy);
414
 
        }
415
 
      }
416
 
      catch(...) { 
417
 
        std::ios_base::iostate exception_mask = is.exceptions();
418
 
        if(std::ios_base::failbit & exception_mask) {
419
 
          try { is.setstate(std::ios_base::failbit); } 
420
 
          catch(std::ios_base::failure&) {}
421
 
          throw; // rethrow original exception
422
 
        }
423
 
        else {
424
 
          is.setstate(std::ios_base::failbit); 
425
 
        } 
426
 
            
427
 
      }
428
 
    }
429
 
    return is;
430
 
  }
431
 
 
432
 
  /********** date generator types **********/
433
 
  
434
 
  template <class CharT, class TraitsT>
435
 
  inline std::basic_ostream<CharT, TraitsT>&
436
 
  operator<<(std::basic_ostream<CharT, TraitsT>& os, const boost::gregorian::partial_date& pd) {
437
 
    boost::io::ios_flags_saver iflags(os);
438
 
    typedef boost::date_time::date_facet<date, CharT> custom_date_facet;
439
 
    std::ostreambuf_iterator<CharT> output_itr(os);
440
 
    if (std::has_facet<custom_date_facet>(os.getloc()))
441
 
      std::use_facet<custom_date_facet>(os.getloc()).put(output_itr, os, os.fill(), pd);
442
 
    else {
443
 
      custom_date_facet* f = new custom_date_facet();
444
 
      std::locale l = std::locale(os.getloc(), f);
445
 
      os.imbue(l);
446
 
      f->put(output_itr, os, os.fill(), pd);
447
 
    }
448
 
    return os;
449
 
  }
450
 
 
451
 
  //! input operator for partial_date
452
 
  template <class CharT, class Traits>
453
 
  inline
454
 
  std::basic_istream<CharT, Traits>&
455
 
  operator>>(std::basic_istream<CharT, Traits>& is, partial_date& pd)
456
 
  {
457
 
    boost::io::ios_flags_saver iflags(is);
458
 
    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 
459
 
    if (strm_sentry) {
460
 
      try {
461
 
        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
462
 
 
463
 
        std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
464
 
        if(std::has_facet<date_input_facet>(is.getloc())) {
465
 
          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, pd);
466
 
        }
467
 
        else {
468
 
          date_input_facet* f = new date_input_facet();
469
 
          std::locale l = std::locale(is.getloc(), f);
470
 
          is.imbue(l);
471
 
          f->get(sit, str_end, is, pd);
472
 
        }
473
 
      }
474
 
      catch(...) { 
475
 
        std::ios_base::iostate exception_mask = is.exceptions();
476
 
        if(std::ios_base::failbit & exception_mask) {
477
 
          try { is.setstate(std::ios_base::failbit); } 
478
 
          catch(std::ios_base::failure&) {}
479
 
          throw; // rethrow original exception
480
 
        }
481
 
        else {
482
 
          is.setstate(std::ios_base::failbit); 
483
 
        } 
484
 
            
485
 
      }
486
 
    }
487
 
    return is;
488
 
  }
489
 
 
490
 
  template <class CharT, class TraitsT>
491
 
  inline std::basic_ostream<CharT, TraitsT>&
492
 
  operator<<(std::basic_ostream<CharT, TraitsT>& os, const boost::gregorian::nth_day_of_the_week_in_month& nkd) {
493
 
    boost::io::ios_flags_saver iflags(os);
494
 
    typedef boost::date_time::date_facet<date, CharT> custom_date_facet;
495
 
    std::ostreambuf_iterator<CharT> output_itr(os);
496
 
    if (std::has_facet<custom_date_facet>(os.getloc()))
497
 
      std::use_facet<custom_date_facet>(os.getloc()).put(output_itr, os, os.fill(), nkd);
498
 
    else {
499
 
      custom_date_facet* f = new custom_date_facet();
500
 
      std::locale l = std::locale(os.getloc(), f);
501
 
      os.imbue(l);
502
 
      f->put(output_itr, os, os.fill(), nkd);
503
 
    }
504
 
    return os;
505
 
  }
506
 
 
507
 
  //! input operator for nth_day_of_the_week_in_month
508
 
  template <class CharT, class Traits>
509
 
  inline
510
 
  std::basic_istream<CharT, Traits>&
511
 
  operator>>(std::basic_istream<CharT, Traits>& is, 
512
 
             nth_day_of_the_week_in_month& nday)
513
 
  {
514
 
    boost::io::ios_flags_saver iflags(is);
515
 
    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 
516
 
    if (strm_sentry) {
517
 
      try {
518
 
        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
519
 
 
520
 
        std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
521
 
        if(std::has_facet<date_input_facet>(is.getloc())) {
522
 
          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, nday);
523
 
        }
524
 
        else {
525
 
          date_input_facet* f = new date_input_facet();
526
 
          std::locale l = std::locale(is.getloc(), f);
527
 
          is.imbue(l);
528
 
          f->get(sit, str_end, is, nday);
529
 
        }
530
 
      }
531
 
      catch(...) { 
532
 
        std::ios_base::iostate exception_mask = is.exceptions();
533
 
        if(std::ios_base::failbit & exception_mask) {
534
 
          try { is.setstate(std::ios_base::failbit); } 
535
 
          catch(std::ios_base::failure&) {}
536
 
          throw; // rethrow original exception
537
 
        }
538
 
        else {
539
 
          is.setstate(std::ios_base::failbit); 
540
 
        } 
541
 
            
542
 
      }
543
 
    }
544
 
    return is;
545
 
  }
546
 
 
547
 
 
548
 
  template <class CharT, class TraitsT>
549
 
  inline std::basic_ostream<CharT, TraitsT>&
550
 
  operator<<(std::basic_ostream<CharT, TraitsT>& os, const boost::gregorian::first_day_of_the_week_in_month& fkd) {
551
 
    boost::io::ios_flags_saver iflags(os);
552
 
    typedef boost::date_time::date_facet<date, CharT> custom_date_facet;
553
 
    std::ostreambuf_iterator<CharT> output_itr(os);
554
 
    if (std::has_facet<custom_date_facet>(os.getloc()))
555
 
      std::use_facet<custom_date_facet>(os.getloc()).put(output_itr, os, os.fill(), fkd);
556
 
    else {
557
 
      custom_date_facet* f = new custom_date_facet();
558
 
      std::locale l = std::locale(os.getloc(), f);
559
 
      os.imbue(l);
560
 
      f->put(output_itr, os, os.fill(), fkd);
561
 
    }
562
 
    return os;
563
 
  }
564
 
 
565
 
  //! input operator for first_day_of_the_week_in_month
566
 
  template <class CharT, class Traits>
567
 
  inline
568
 
  std::basic_istream<CharT, Traits>&
569
 
  operator>>(std::basic_istream<CharT, Traits>& is, 
570
 
             first_day_of_the_week_in_month& fkd)
571
 
  {
572
 
    boost::io::ios_flags_saver iflags(is);
573
 
    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 
574
 
    if (strm_sentry) {
575
 
      try {
576
 
        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
577
 
 
578
 
        std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
579
 
        if(std::has_facet<date_input_facet>(is.getloc())) {
580
 
          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, fkd);
581
 
        }
582
 
        else {
583
 
          date_input_facet* f = new date_input_facet();
584
 
          std::locale l = std::locale(is.getloc(), f);
585
 
          is.imbue(l);
586
 
          f->get(sit, str_end, is, fkd);
587
 
        }
588
 
      }
589
 
      catch(...) { 
590
 
        std::ios_base::iostate exception_mask = is.exceptions();
591
 
        if(std::ios_base::failbit & exception_mask) {
592
 
          try { is.setstate(std::ios_base::failbit); } 
593
 
          catch(std::ios_base::failure&) {}
594
 
          throw; // rethrow original exception
595
 
        }
596
 
        else {
597
 
          is.setstate(std::ios_base::failbit); 
598
 
        } 
599
 
            
600
 
      }
601
 
    }
602
 
    return is;
603
 
  }
604
 
 
605
 
 
606
 
  template <class CharT, class TraitsT>
607
 
  inline std::basic_ostream<CharT, TraitsT>&
608
 
  operator<<(std::basic_ostream<CharT, TraitsT>& os, const boost::gregorian::last_day_of_the_week_in_month& lkd) {
609
 
    boost::io::ios_flags_saver iflags(os);
610
 
    typedef boost::date_time::date_facet<date, CharT> custom_date_facet;
611
 
    std::ostreambuf_iterator<CharT> output_itr(os);
612
 
    if (std::has_facet<custom_date_facet>(os.getloc()))
613
 
      std::use_facet<custom_date_facet>(os.getloc()).put(output_itr, os, os.fill(), lkd);
614
 
    else {
615
 
      custom_date_facet* f = new custom_date_facet();
616
 
      std::locale l = std::locale(os.getloc(), f);
617
 
      os.imbue(l);
618
 
      f->put(output_itr, os, os.fill(), lkd);
619
 
    }
620
 
    return os;
621
 
  }
622
 
 
623
 
  //! input operator for last_day_of_the_week_in_month
624
 
  template <class CharT, class Traits>
625
 
  inline
626
 
  std::basic_istream<CharT, Traits>&
627
 
  operator>>(std::basic_istream<CharT, Traits>& is, 
628
 
             last_day_of_the_week_in_month& lkd)
629
 
  {
630
 
    boost::io::ios_flags_saver iflags(is);
631
 
    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 
632
 
    if (strm_sentry) {
633
 
      try {
634
 
        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
635
 
 
636
 
        std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
637
 
        if(std::has_facet<date_input_facet>(is.getloc())) {
638
 
          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, lkd);
639
 
        }
640
 
        else {
641
 
          date_input_facet* f = new date_input_facet();
642
 
          std::locale l = std::locale(is.getloc(), f);
643
 
          is.imbue(l);
644
 
          f->get(sit, str_end, is, lkd);
645
 
        }
646
 
      }
647
 
      catch(...) { 
648
 
        std::ios_base::iostate exception_mask = is.exceptions();
649
 
        if(std::ios_base::failbit & exception_mask) {
650
 
          try { is.setstate(std::ios_base::failbit); } 
651
 
          catch(std::ios_base::failure&) {}
652
 
          throw; // rethrow original exception
653
 
        }
654
 
        else {
655
 
          is.setstate(std::ios_base::failbit); 
656
 
        } 
657
 
            
658
 
      }
659
 
    }
660
 
    return is;
661
 
  }
662
 
 
663
 
 
664
 
  template <class CharT, class TraitsT>
665
 
  inline std::basic_ostream<CharT, TraitsT>&
666
 
  operator<<(std::basic_ostream<CharT, TraitsT>& os, const boost::gregorian::first_day_of_the_week_after& fda) {
667
 
    boost::io::ios_flags_saver iflags(os);
668
 
    typedef boost::date_time::date_facet<date, CharT> custom_date_facet;
669
 
    std::ostreambuf_iterator<CharT> output_itr(os);
670
 
    if (std::has_facet<custom_date_facet>(os.getloc())) {
671
 
      std::use_facet<custom_date_facet>(os.getloc()).put(output_itr, os, os.fill(), fda);
672
 
    } 
673
 
    else {
674
 
      custom_date_facet* f = new custom_date_facet();
675
 
      std::locale l = std::locale(os.getloc(), f);
676
 
      os.imbue(l);
677
 
      f->put(output_itr, os, os.fill(), fda);
678
 
    }
679
 
    return os;
680
 
  }
681
 
 
682
 
  //! input operator for first_day_of_the_week_after
683
 
  template <class CharT, class Traits>
684
 
  inline
685
 
  std::basic_istream<CharT, Traits>&
686
 
  operator>>(std::basic_istream<CharT, Traits>& is, 
687
 
             first_day_of_the_week_after& fka)
688
 
  {
689
 
    boost::io::ios_flags_saver iflags(is);
690
 
    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 
691
 
    if (strm_sentry) {
692
 
      try {
693
 
        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
694
 
 
695
 
        std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
696
 
        if(std::has_facet<date_input_facet>(is.getloc())) {
697
 
          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, fka);
698
 
        }
699
 
        else {
700
 
          date_input_facet* f = new date_input_facet();
701
 
          std::locale l = std::locale(is.getloc(), f);
702
 
          is.imbue(l);
703
 
          f->get(sit, str_end, is, fka);
704
 
        }
705
 
      }
706
 
      catch(...) { 
707
 
        std::ios_base::iostate exception_mask = is.exceptions();
708
 
        if(std::ios_base::failbit & exception_mask) {
709
 
          try { is.setstate(std::ios_base::failbit); } 
710
 
          catch(std::ios_base::failure&) {}
711
 
          throw; // rethrow original exception
712
 
        }
713
 
        else {
714
 
          is.setstate(std::ios_base::failbit); 
715
 
        } 
716
 
            
717
 
      }
718
 
    }
719
 
    return is;
720
 
  }
721
 
 
722
 
 
723
 
  template <class CharT, class TraitsT>
724
 
  inline std::basic_ostream<CharT, TraitsT>&
725
 
  operator<<(std::basic_ostream<CharT, TraitsT>& os, const boost::gregorian::first_day_of_the_week_before& fdb) {
726
 
    boost::io::ios_flags_saver iflags(os);
727
 
    typedef boost::date_time::date_facet<date, CharT> custom_date_facet;
728
 
    std::ostreambuf_iterator<CharT> output_itr(os);
729
 
    if (std::has_facet<custom_date_facet>(os.getloc())) {
730
 
      std::use_facet<custom_date_facet>(os.getloc()).put(output_itr, os, os.fill(), fdb);
731
 
    }
732
 
    else {
733
 
      custom_date_facet* f = new custom_date_facet();
734
 
      std::locale l = std::locale(os.getloc(), f);
735
 
      os.imbue(l);
736
 
      f->put(output_itr, os, os.fill(), fdb);
737
 
    }
738
 
    return os;
739
 
  }
740
 
 
741
 
  //! input operator for first_day_of_the_week_before
742
 
  template <class CharT, class Traits>
743
 
  inline
744
 
  std::basic_istream<CharT, Traits>&
745
 
  operator>>(std::basic_istream<CharT, Traits>& is, 
746
 
             first_day_of_the_week_before& fkb)
747
 
  {
748
 
    boost::io::ios_flags_saver iflags(is);
749
 
    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 
750
 
    if (strm_sentry) {
751
 
      try {
752
 
        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
753
 
 
754
 
        std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
755
 
        if(std::has_facet<date_input_facet>(is.getloc())) {
756
 
          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, fkb);
757
 
        }
758
 
        else {
759
 
          date_input_facet* f = new date_input_facet();
760
 
          std::locale l = std::locale(is.getloc(), f);
761
 
          is.imbue(l);
762
 
          f->get(sit, str_end, is, fkb);
763
 
        }
764
 
      }
765
 
      catch(...) { 
766
 
        std::ios_base::iostate exception_mask = is.exceptions();
767
 
        if(std::ios_base::failbit & exception_mask) {
768
 
          try { is.setstate(std::ios_base::failbit); } 
769
 
          catch(std::ios_base::failure&) {}
770
 
          throw; // rethrow original exception
771
 
        }
772
 
        else {
773
 
          is.setstate(std::ios_base::failbit); 
774
 
        } 
775
 
            
776
 
      }
777
 
    }
778
 
    return is;
779
 
  }
780
 
 
781
 
  
782
 
} } // namespaces
783
 
 
784
 
#endif // DATE_TIME_GREGORIAN_IO_HPP__