FieldTypes.h
Go to the documentation of this file.
1 /* -*- C++ -*- */
2 
3 /****************************************************************************
4 ** Copyright (c) 2001-2014
5 **
6 ** This file is part of the QuickFIX FIX Engine
7 **
8 ** This file may be distributed under the terms of the quickfixengine.org
9 ** license as defined by quickfixengine.org and appearing in the file
10 ** LICENSE included in the packaging of this file.
11 **
12 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
13 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
14 **
15 ** See http://www.quickfixengine.org/LICENSE for licensing information.
16 **
17 ** Contact ask@quickfixengine.org if any conditions of this licensing are
18 ** not clear to you.
19 **
20 ****************************************************************************/
21 
22 #ifndef FIX_FIELDTYPES_H
23 #define FIX_FIELDTYPES_H
24 
25 #ifdef _MSC_VER
26 #pragma warning( disable : 4503 4355 4786 4290 )
27 #endif
28 
29 #if defined(_MSC_VER) && (_MSC_VER < 1600)
30  #include "stdint_msvc.h"
31 #else
32  #include <stdint.h> /* integer types int8_t .. uint64_t, intptr_t */
33 #endif
34 
35 #include "Utility.h"
36 #include <string>
37 #include <time.h>
38 
39 namespace FIX
40 {
45 
57 // Precision factor of timestamp. [0] - second, [9] - nanosecond
58 static const int PRECISION_FACTOR[10] = {1000000000, 100000000, 10000000, 1000000, 100000, 10000, 1000, 100, 10, 1};
59 
60 struct DateTime
61 {
62  int m_date;
64 
66  static const int64_t SECONDS_PER_DAY = 86400;
67  static const int64_t SECONDS_PER_HOUR = 3600;
68  static const int64_t SECONDS_PER_MIN = 60;
69  static const int64_t MINUTES_PER_HOUR = 60;
70 
71  static const int64_t NANOS_PER_DAY = 86400000000000;
72  static const int64_t NANOS_PER_HOUR = 3600000000000;
73  static const int64_t NANOS_PER_MIN = 60000000000;
74  static const int64_t NANOS_PER_SEC = 1000000000;
75 
76  // time_t epoch (1970-01-01) as a Julian date
77  static const int64_t JULIAN_19700101 = 2440588;
78 
80  DateTime () : m_date (0), m_time (0) {}
81 
83  DateTime (int date, int64_t time) : m_date (date), m_time (time) {}
84 
86  DateTime( int year, int month, int day,
87  int hour, int minute, int second, int millis )
88  {
89  m_date = julianDate( year, month, day );
90  m_time = makeHMS( hour, minute, second, millis * PRECISION_FACTOR[3] );
91  }
92 
94  DateTime( int year, int month, int day,
95  int hour, int minute, int second, int fraction, int precision )
96  {
97  m_date = julianDate( year, month, day );
98  int nanos = convertToNanos(fraction, precision);
99  m_time = makeHMS( hour, minute, second, nanos );
100  }
101 
102  virtual ~DateTime() {}
103 
105  inline int getYear() const
106  {
107  int y, m, d;
108  getYMD( y, m, d );
109  return y;
110  }
111 
113  inline int getMonth() const
114  {
115  int y, m, d;
116  getYMD( y, m, d );
117  return m;
118  }
119 
121  inline int getDay() const
122  {
123  int y, m, d;
124  getYMD( y, m, d );
125  return d;
126  }
127 
130  inline int getDate() const { return getDay(); }
131 
133  inline int getJulianDate() const { return m_date; }
134 
136  inline int getHour() const
137  {
138  return (int)(m_time / NANOS_PER_HOUR);
139  }
140 
142  inline int getMinute() const
143  {
145  }
146 
148  inline int getSecond() const
149  {
151  }
152 
154  inline int getMillisecond() const
155  {
156  return (getNanosecond() / PRECISION_FACTOR[3]);
157  }
158 
160  inline int getMicroecond() const
161  {
162  return (getNanosecond() / PRECISION_FACTOR[6]);
163  }
164 
166  inline unsigned int getNanosecond() const
167  {
168  return static_cast<uint64_t>(m_time) % NANOS_PER_SEC;
169  }
170 
172  inline int getFraction(int precision) const
173  {
174  switch (precision)
175  {
176  case 0:
178 
179  case 1:
180  return (getNanosecond() / PRECISION_FACTOR[1]);
181 
182  case 2:
184 
185  case 3:
186  return (getNanosecond() / PRECISION_FACTOR[3]);
187 
188  case 4:
190 
191  case 5:
192  return (getNanosecond() / PRECISION_FACTOR[5]);
193 
194  case 6:
195  return (getNanosecond() / PRECISION_FACTOR[6]);
196 
197  case 7:
198  return (getNanosecond() / PRECISION_FACTOR[7]);
199 
200  case 8:
201  return (getNanosecond() / PRECISION_FACTOR[8]);
202 
203  case 9:
204  default:
205  return (getNanosecond() / PRECISION_FACTOR[9]);
206  }
207  }
208 
211  inline void getYMD (int& year, int& month, int& day) const
212  {
213  getYMD( m_date, year, month, day );
214  }
215 
218  inline void getHMS( int& hour, int& minute, int& second, int& millis ) const
219  {
220  int ticks = (int)(m_time / NANOS_PER_SEC);
221  hour = ticks / SECONDS_PER_HOUR;
222  minute = (ticks / SECONDS_PER_MIN) % MINUTES_PER_HOUR;
223  second = ticks % SECONDS_PER_MIN;
224  millis = getMillisecond();
225  }
226 
229  inline void getHMS( int& hour, int& minute, int& second, int& fraction, int precision ) const
230  {
231  int ticks = (int)(m_time / NANOS_PER_SEC);
232  hour = ticks / SECONDS_PER_HOUR;
233  minute = (ticks / SECONDS_PER_MIN) % MINUTES_PER_HOUR;
234  second = ticks % SECONDS_PER_MIN;
235  fraction = getFraction(precision);
236  }
237 
239  inline int getWeekDay() const
240  {
241  int Y, M, D;
242  getYMD (Y, M, D);
243  int m = M >= 3 ? M - 2 : M + 10;
244  int Yprime = M >= 3 ? Y : Y - 1;
245  int y = Yprime % 100;
246  int c = Yprime / 100;
247  int wd = (D + int (2.6 * m - 0.2) + y + int (y / 4) + int (c / 4) -
248  (2 * c)) % 7;
249  return 1 + (wd < 0 ? 7 + wd : wd);
250  }
251 
254  inline time_t getTimeT() const
255  {
258  }
259 
261  tm getTmUtc() const
262  {
263  int year, month, day;
264  int hour, minute, second, millis;
265  tm result = { 0 };
266 
267  getYMD( year, month, day );
268  getHMS( hour, minute, second, millis );
269 
270  result.tm_year = year - 1900;
271  result.tm_mon = month - 1;
272  result.tm_mday = day;
273  result.tm_hour = hour;
274  result.tm_min = minute;
275  result.tm_sec = second;
276  result.tm_isdst = -1;
277 
278  return result;
279  }
280 
282  void setYMD( int year, int month, int day )
283  {
284  m_date = julianDate( year, month, day );
285  }
286 
288  void setHMS( int hour, int minute, int second, int millis )
289  {
290  m_time = makeHMS( hour, minute, second, millis * PRECISION_FACTOR[3] );
291  }
292 
294  void setHMS( int hour, int minute, int second, int fraction, int precision )
295  {
296  int nanos = convertToNanos(fraction, precision);
297 
298  m_time = makeHMS( hour, minute, second, nanos);
299  }
300 
302  void setHour( int hour )
303  {
304  int old_hour, min, sec, millis;
305  getHMS( old_hour, min, sec, millis );
306  setHMS( hour, min, sec, millis );
307  }
308 
310  void setMinute( int min )
311  {
312  int hour, old_min, sec, millis;
313  getHMS( hour, old_min, sec, millis );
314  setHMS( hour, min, sec, millis );
315  }
316 
318  void setSecond( int sec )
319  {
320  int hour, min, old_sec, millis;
321  getHMS( hour, min, old_sec, millis );
322  setHMS( hour, min, sec, millis );
323  }
324 
326  void setMillisecond( int millis )
327  {
328  int hour, min, sec, old_millis;
329  getHMS( hour, min, sec, old_millis );
330  setHMS( hour, min, sec, millis );
331  }
332 
334  void setMicrosecond( int micros )
335  {
336  int hour, min, sec, old_nanos;
337  getHMS( hour, min, sec, old_nanos, 9 );
338  setHMS( hour, min, sec, micros, 6 );
339  }
340 
342  void setNanosecond( int nanos )
343  {
344  int hour, min, sec, old_nanos;
345  getHMS( hour, min, sec, old_nanos, 9 );
346  setHMS( hour, min, sec, nanos, 9 );
347  }
348 
350  void setFraction( int fraction, int precision )
351  {
352  int hour, min, sec, old_nanos;
353  getHMS( hour, min, sec, old_nanos, 9 );
354  setHMS( hour, min, sec, fraction, precision );
355  }
356 
358  void clearDate()
359  {
360  m_date = 0;
361  }
362 
364  void clearTime()
365  {
366  m_time = 0;
367  }
368 
370  void set( int date, int64_t time ) { m_date = date; m_time = time; }
371 
373  void set( const DateTime& other )
374  {
375  m_date = other.m_date;
376  m_time = other.m_time;
377  }
378 
380  void operator+=( int seconds )
381  {
382  int d = seconds / SECONDS_PER_DAY;
383  int s = seconds % SECONDS_PER_DAY;
384 
385  m_date += d;
386  m_time += s * NANOS_PER_SEC;
387 
388  if( m_time > NANOS_PER_DAY )
389  {
392  }
393  else if( m_time < 0 )
394  {
395  m_date--;
397  }
398  }
399 
401  static int convertToNanos(int fraction, int precision)
402  {
403  int nanos;
404 
405  switch (precision)
406  {
407  case 0:
408  nanos = fraction * PRECISION_FACTOR[0];
409  break;
410 
411  case 1:
412  nanos = fraction * PRECISION_FACTOR[1];
413  break;
414 
415  case 2:
416  nanos = fraction * PRECISION_FACTOR[2];
417  break;
418 
419  case 3:
420  nanos = fraction * PRECISION_FACTOR[3];
421  break;
422 
423  case 4:
424  nanos = fraction * PRECISION_FACTOR[4];
425  break;
426 
427  case 5:
428  nanos = fraction * PRECISION_FACTOR[5];
429  break;
430 
431  case 6:
432  nanos = fraction * PRECISION_FACTOR[6];
433  break;
434 
435  case 7:
436  nanos = fraction * PRECISION_FACTOR[7];
437  break;
438 
439  case 8:
440  nanos = fraction * PRECISION_FACTOR[8];
441  break;
442 
443  case 9:
444  default:
445  nanos = fraction * PRECISION_FACTOR[9];
446  break;
447  }
448 
449  return nanos;
450  }
451 
454  static int64_t makeHMS( int hour, int minute, int second, int nanos )
455  {
456  return NANOS_PER_SEC * (SECONDS_PER_HOUR * hour +
457  SECONDS_PER_MIN * minute +
458  second) + nanos;
459  }
460 
462  static DateTime nowUtc();
463 
465  static DateTime nowLocal();
466 
468  static DateTime fromUtcTimeT( time_t t, int millis = 0 )
469  {
470  struct tm tm = time_gmtime( &t );
471  return fromTm( tm, millis );
472  }
473 
474  static DateTime fromLocalTimeT( time_t t, int millis = 0 )
475  {
476  struct tm tm = time_localtime( &t );
477  return fromTm( tm, millis );
478  }
479 
480  static DateTime fromUtcTimeT( time_t t, int fraction, int precision )
481  {
482  struct tm tm = time_gmtime( &t );
483  return fromTm( tm, fraction, precision );
484  }
485 
486  static DateTime fromLocalTimeT( time_t t, int fraction, int precision )
487  {
488  struct tm tm = time_localtime( &t );
489  return fromTm( tm, fraction, precision );
490  }
491 
494  static DateTime fromTm( const tm& tm, int millis = 0 )
495  {
496  return DateTime ( julianDate(tm.tm_year + 1900, tm.tm_mon + 1,
497  tm.tm_mday),
498  makeHMS(tm.tm_hour, tm.tm_min, tm.tm_sec, millis * PRECISION_FACTOR[3]) );
499  }
500 
503  static DateTime fromTm( const tm& tm, int fraction, int precision )
504  {
505  int nanos = convertToNanos(fraction, precision);
506  return DateTime ( julianDate(tm.tm_year + 1900, tm.tm_mon + 1,
507  tm.tm_mday),
508  makeHMS(tm.tm_hour, tm.tm_min, tm.tm_sec, nanos) );
509  }
510 
512  static int julianDate( int year, int month, int day )
513  {
514  int a = (14 - month) / 12;
515  int y = year + 4800 - a;
516  int m = month + 12 * a - 3;
517  return (day + int ((153 * m + 2) / 5) + y * 365 +
518  int (y / 4) - int (y / 100) + int (y / 400) - 32045);
519  }
520 
522  static void getYMD( int jday, int& year, int& month, int& day )
523  {
524  int a = jday + 32044;
525  int b = (4 * a + 3) / 146097;
526  int c = a - int ((b * 146097) / 4);
527  int d = (4 * c + 3) / 1461;
528  int e = c - int ((1461 * d) / 4);
529  int m = (5 * e + 2) / 153;
530  day = e - int ((153 * m + 2) / 5) + 1;
531  month = m + 3 - 12 * int (m / 10);
532  year = b * 100 + d - 4800 + int (m / 10);
533  }
534 };
535 
536 inline bool operator==( const DateTime& lhs, const DateTime& rhs )
537 {
538  return lhs.m_date == rhs.m_date && lhs.m_time == rhs.m_time;
539 }
540 
541 inline bool operator!=( const DateTime& lhs, const DateTime& rhs )
542 {
543  return !(lhs == rhs);
544 }
545 
546 inline bool operator<( const DateTime& lhs, const DateTime& rhs )
547 {
548  if( lhs.m_date < rhs.m_date )
549  return true;
550  else if( lhs.m_date > rhs.m_date )
551  return false;
552  else if( lhs.m_time < rhs.m_time )
553  return true;
554  return false;
555 }
556 
557 inline bool operator>( const DateTime& lhs, const DateTime& rhs )
558 {
559  return !(lhs == rhs || lhs < rhs);
560 }
561 
562 inline bool operator<=( const DateTime& lhs, const DateTime& rhs )
563 {
564  return lhs == rhs || lhs < rhs;
565 }
566 
567 inline bool operator>=( const DateTime& lhs, const DateTime& rhs )
568 {
569  return lhs == rhs || lhs > rhs;
570 }
571 
574 inline int operator-( const DateTime& lhs, const DateTime& rhs )
575 {
576  return (DateTime::SECONDS_PER_DAY * (lhs.m_date - rhs.m_date) +
577  // Truncate the nanos before subtracting
578  (int)(lhs.m_time / DateTime::NANOS_PER_SEC) - (int)(rhs.m_time / DateTime::NANOS_PER_SEC));
579 }
580 
582 class UtcTimeStamp : public DateTime
583 {
584 public:
586  UtcTimeStamp()
587  : DateTime( DateTime::nowUtc() ) {}
588 
590  UtcTimeStamp( int hour, int minute, int second, int millisecond = 0 )
592  {
593  setHMS( hour, minute, second, millisecond );
594  }
595 
596  UtcTimeStamp( int hour, int minute, int second, int fraction, int precision )
597  : DateTime( DateTime::nowUtc() )
598  {
599  setHMS( hour, minute, second, fraction, precision );
600  }
601 
602  UtcTimeStamp( int hour, int minute, int second,
603  int date, int month, int year )
604  : DateTime( year, month, date, hour, minute, second, 0 ) {}
605 
606  UtcTimeStamp( int hour, int minute, int second, int millisecond,
607  int date, int month, int year )
608  : DateTime( year, month, date, hour, minute, second, millisecond ) {}
609 
610  UtcTimeStamp( int hour, int minute, int second, int fraction,
611  int date, int month, int year, int precision )
612  : DateTime( year, month, date, hour, minute, second, fraction, precision ) {}
613 
614  explicit UtcTimeStamp( time_t time, int millisecond = 0 )
615  : DateTime( fromUtcTimeT (time, millisecond) ) {}
616 
617  UtcTimeStamp( time_t time, int fraction, int precision )
618  : DateTime( fromUtcTimeT (time, fraction, precision) ) {}
619 
620  UtcTimeStamp( const tm* time, int millisecond = 0 )
621  : DateTime( fromTm (*time, millisecond) ) {}
622 
623  UtcTimeStamp( const tm* time, int fraction, int precision )
624  : DateTime( fromTm (*time, fraction, precision) ) {}
625 
626  void setCurrent()
627  {
628  set( DateTime::nowUtc() );
629  }
630 };
631 
633 class LocalTimeStamp : public DateTime
634 {
635 public:
638  : DateTime( DateTime::nowLocal() ) {}
639 
641  LocalTimeStamp( int hour, int minute, int second, int millisecond = 0 )
642  : DateTime( DateTime::nowLocal() )
643  {
644  setHMS( hour, minute, second, millisecond );
645  }
646 
647  LocalTimeStamp( int hour, int minute, int second, int fraction, int precision )
648  : DateTime( DateTime::nowLocal() )
649  {
650  setHMS( hour, minute, second, fraction, precision );
651  }
652 
653  LocalTimeStamp( int hour, int minute, int second,
654  int date, int month, int year )
655  : DateTime( year, month, date, hour, minute, second, 0 ) {}
656 
657  LocalTimeStamp( int hour, int minute, int second, int millisecond,
658  int date, int month, int year )
659  : DateTime( year, month, date, hour, minute, second, millisecond ) {}
660 
661  LocalTimeStamp( int hour, int minute, int second, int fraction,
662  int date, int month, int year, int precision )
663  : DateTime( year, month, date, hour, minute, second, fraction, precision ) {}
664 
665  explicit LocalTimeStamp( time_t time, int millisecond = 0 )
666  : DateTime( fromLocalTimeT (time, millisecond) ) {}
667 
668  LocalTimeStamp( time_t time, int fraction, int precision )
669  : DateTime( fromLocalTimeT (time, fraction, precision) ) {}
670 
671  LocalTimeStamp( const tm* time, int millisecond = 0 )
672  : DateTime( fromTm (*time, millisecond) ) {}
673 
674  LocalTimeStamp( const tm* time, int fraction, int precision )
675  : DateTime( fromTm (*time, fraction, precision) ) {}
676 
677  void setCurrent()
678  {
679  set( DateTime::nowLocal() );
680  }
681 };
682 
684 class UtcTimeOnly : public DateTime
685 {
686 public:
689  {
690  setCurrent();
691  }
692 
693  UtcTimeOnly( const DateTime& val )
694  : DateTime(val)
695  {
696  clearDate();
697  }
698 
699  UtcTimeOnly( int hour, int minute, int second, int millisecond = 0 )
700  {
701  setHMS( hour, minute, second, millisecond );
702  }
703 
704  UtcTimeOnly( int hour, int minute, int second, int fraction, int precision )
705  {
706  setHMS( hour, minute, second, fraction, precision );
707  }
708 
709  explicit UtcTimeOnly( time_t time, int millisecond = 0 )
710  : DateTime( fromUtcTimeT (time, millisecond) )
711  {
712  clearDate();
713  }
714 
715  UtcTimeOnly( time_t time, int fraction, int precision )
716  : DateTime( fromUtcTimeT (time, fraction, precision) )
717  {
718  clearDate();
719  }
720 
721  UtcTimeOnly( const tm* time, int millisecond = 0 )
722  : DateTime( fromTm (*time, millisecond) )
723  {
724  clearDate();
725  }
726 
727  UtcTimeOnly( const tm* time, int fraction, int precision )
728  : DateTime( fromTm (*time, fraction, precision) )
729  {
730  clearDate();
731  }
732 
734  void setCurrent()
735  {
736  DateTime d = nowUtc();
737  m_time = d.m_time;
738  }
739 };
740 
742 class LocalTimeOnly : public DateTime
743 {
744 public:
746  LocalTimeOnly()
747  {
748  setCurrent();
749  }
750 
751  LocalTimeOnly( const DateTime& val )
752  : DateTime(val)
753  {
754  clearDate();
755  }
756 
757  LocalTimeOnly( int hour, int minute, int second, int millisecond = 0 )
758  {
759  setHMS( hour, minute, second, millisecond );
760  }
761 
762  LocalTimeOnly( int hour, int minute, int second, int fraction, int precision )
763  {
764  setHMS( hour, minute, second, fraction, precision );
765  }
766 
767  explicit LocalTimeOnly( time_t time, int millisecond = 0 )
768  : DateTime( fromLocalTimeT (time, millisecond) )
769  {
770  clearDate();
771  }
772 
773  LocalTimeOnly( time_t time, int fraction, int precision )
774  : DateTime( fromLocalTimeT (time, fraction, precision) )
775  {
776  clearDate();
777  }
778 
779  LocalTimeOnly( const tm* time, int millisecond = 0 )
780  : DateTime( fromTm (*time, millisecond) )
781  {
782  clearDate();
783  }
784 
785  LocalTimeOnly( const tm* time, int fraction, int precision )
786  : DateTime( fromTm (*time, fraction, precision) )
787  {
788  clearDate();
789  }
790 
792  void setCurrent()
793  {
794  DateTime d = nowLocal();
795  m_time = d.m_time;
796  }
797 };
798 
800 class UtcDate : public DateTime
801 {
802 public:
804  UtcDate()
805  {
806  setCurrent();
807  }
808 
809  UtcDate( const DateTime& val )
810  : DateTime( val )
811  {
812  clearTime();
813  }
814 
815  UtcDate( int date, int month, int year )
816  : DateTime(year, month, date, 0, 0, 0, 0) {}
817 
818  UtcDate( int sec )
819  : DateTime( sec / DateTime::SECONDS_PER_DAY, 0 ) {}
820 
821  UtcDate( const tm* time )
822  : DateTime( fromTm (*time) )
823  {
824  clearTime();
825  }
826 
828  void setCurrent()
829  {
830  DateTime d = nowUtc();
831  m_date = d.m_date;
832  }
833 };
834 
836 class LocalDate : public DateTime
837 {
838 public:
840  LocalDate()
841  {
842  setCurrent();
843  }
844 
845  LocalDate( const DateTime& val )
846  : DateTime( val )
847  {
848  clearTime();
849  }
850 
851  LocalDate( int date, int month, int year )
852  : DateTime(year, month, date, 0, 0, 0, 0) {}
853 
854  LocalDate( int sec )
855  : DateTime( sec / DateTime::SECONDS_PER_DAY, 0 ) {}
856 
857  LocalDate( const tm* time )
858  : DateTime( fromTm (*time) )
859  {
860  clearTime();
861  }
862 
864  void setCurrent()
865  {
866  DateTime d = nowLocal();
867  m_date = d.m_date;
868  }
869 };
870 
873 typedef UtcDate UtcDateOnly;
874 
875 typedef std::string STRING;
876 typedef char CHAR;
877 typedef double PRICE;
878 typedef int INT;
879 typedef double AMT;
880 typedef double QTY;
881 typedef std::string CURRENCY;
882 typedef std::string MULTIPLEVALUESTRING;
883 typedef std::string MULTIPLESTRINGVALUE;
884 typedef std::string MULTIPLECHARVALUE;
885 typedef std::string EXCHANGE;
886 typedef UtcTimeStamp UTCTIMESTAMP;
887 typedef bool BOOLEAN;
888 typedef std::string LOCALMKTDATE;
889 typedef std::string DATA;
890 typedef double FLOAT;
891 typedef double PRICEOFFSET;
892 typedef std::string MONTHYEAR;
893 typedef std::string DAYOFMONTH;
894 typedef UtcDate UTCDATE;
897 typedef int NUMINGROUP;
898 typedef double PERCENTAGE;
899 typedef int SEQNUM;
900 typedef int LENGTH;
901 typedef std::string COUNTRY;
902 typedef std::string TZTIMEONLY;
903 typedef std::string TZTIMESTAMP;
904 typedef std::string XMLDATA;
905 typedef std::string LANGUAGE;
906 
907 namespace TYPE
908 {
909 enum Type
910 {
923  UtcTimeStamp,
925  LocalMktDate,
927  Float,
943 };
944 }
945 }
946 
947 #endif //FIX_FIELDTYPES_H
FIX::DateTime
Definition: FieldTypes.h:77
FIX::DateTime::setHour
void setHour(int hour)
Set the hour portion of the time.
Definition: FieldTypes.h:319
FIX::LocalTimeOnly::setCurrent
void setCurrent()
Set to the current time.
Definition: FieldTypes.h:809
FIX::UtcTimeOnly::UtcTimeOnly
UtcTimeOnly(int hour, int minute, int second, int fraction, int precision)
Definition: FieldTypes.h:721
FIX::XMLDATA
std::string XMLDATA
Definition: FieldTypes.h:921
FIX::DateTime::getDay
int getDay() const
Return the day of the month portion of the date.
Definition: FieldTypes.h:138
FIX::PERCENTAGE
double PERCENTAGE
Definition: FieldTypes.h:915
FIX::DateTime::setMinute
void setMinute(int min)
Set the minute portion of the time.
Definition: FieldTypes.h:327
FIX::DateTime::clearTime
void clearTime()
Clear the time portion of the DateTime.
Definition: FieldTypes.h:381
FIX::DateTime::NANOS_PER_SEC
static const int64_t NANOS_PER_SEC
Definition: FieldTypes.h:91
FIX::MULTIPLESTRINGVALUE
std::string MULTIPLESTRINGVALUE
Definition: FieldTypes.h:900
FIX::DateTime::SECONDS_PER_MIN
static const int64_t SECONDS_PER_MIN
Definition: FieldTypes.h:85
FIX::TYPE::LocalMktDate
@ LocalMktDate
Definition: FieldTypes.h:942
FIX::TYPE::SeqNum
@ SeqNum
Definition: FieldTypes.h:953
FIX::UtcTimeOnly::setCurrent
void setCurrent()
Set to the current time.
Definition: FieldTypes.h:751
FIX::DateTime::nowLocal
static DateTime nowLocal()
Return the current wall-clock time as a local DateTime.
Definition: FieldTypes.cpp:66
FIX::TYPE::Percentage
@ Percentage
Definition: FieldTypes.h:952
FIX::time_localtime
tm time_localtime(const time_t *t)
Definition: Utility.cpp:417
FIX::SEQNUM
int SEQNUM
Definition: FieldTypes.h:916
FIX::TYPE::UtcDate
@ UtcDate
Definition: FieldTypes.h:948
FIX::UTCTIMESTAMP
UtcTimeStamp UTCTIMESTAMP
Definition: FieldTypes.h:903
FIX::DateTime::setHMS
void setHMS(int hour, int minute, int second, int millis)
Set the time portion of the DateTime.
Definition: FieldTypes.h:305
FIX::UtcTimeStamp
Date and Time represented in UTC.
Definition: FieldTypes.h:599
FIX::TYPE::PriceOffset
@ PriceOffset
Definition: FieldTypes.h:945
FIX::UtcDate::UtcDate
UtcDate()
Defaults to the current date.
Definition: FieldTypes.h:821
FIX::TYPE::Price
@ Price
Definition: FieldTypes.h:931
FIX::TYPE::Char
@ Char
Definition: FieldTypes.h:930
FIX::LocalTimeStamp::setCurrent
void setCurrent()
Definition: FieldTypes.h:694
FIX::PRICE
double PRICE
Definition: FieldTypes.h:894
FIX::TYPE::NumInGroup
@ NumInGroup
Definition: FieldTypes.h:951
FIX::DateTime::NANOS_PER_DAY
static const int64_t NANOS_PER_DAY
Definition: FieldTypes.h:88
FIX::QTY
double QTY
Definition: FieldTypes.h:897
FIX::TYPE::Int
@ Int
Definition: FieldTypes.h:932
FIX::UTCDATEONLY
UtcDateOnly UTCDATEONLY
Definition: FieldTypes.h:912
FIX::DateTime::getHour
int getHour() const
Return the hour portion of the time (0-23)
Definition: FieldTypes.h:153
FIX::DateTime::set
void set(int date, int64_t time)
Set the internal date and time members.
Definition: FieldTypes.h:387
FIX::NUMINGROUP
int NUMINGROUP
Definition: FieldTypes.h:914
FIX::DateTime::fromUtcTimeT
static DateTime fromUtcTimeT(time_t t, int millis=0)
Convert a time_t and optional milliseconds to a DateTime.
Definition: FieldTypes.h:485
FIX::operator<
bool operator<(const DatabaseConnectionID &lhs, const DatabaseConnectionID &rhs)
Definition: DatabaseConnectionID.h:83
FIX::TYPE::MultipleValueString
@ MultipleValueString
Definition: FieldTypes.h:936
FIX::operator>=
bool operator>=(const StringField &lhs, const char *rhs)
Definition: Field.h:349
FIX::TYPE::DayOfMonth
@ DayOfMonth
Definition: FieldTypes.h:947
FIX::TZTIMESTAMP
std::string TZTIMESTAMP
Definition: FieldTypes.h:920
FIX::DateTime::getFraction
int getFraction(int precision) const
Return the fraction portion of the time.
Definition: FieldTypes.h:189
FIX::FLOAT
double FLOAT
Definition: FieldTypes.h:907
FIX::UtcTimeStamp::UtcTimeStamp
UtcTimeStamp()
Defaults to the current date and time.
Definition: FieldTypes.h:603
FIX::DateTime::NANOS_PER_HOUR
static const int64_t NANOS_PER_HOUR
Definition: FieldTypes.h:89
FIX::DateTime::getTimeT
time_t getTimeT() const
Convert the DateTime to a time_t.
Definition: FieldTypes.h:271
FIX::LocalDate::LocalDate
LocalDate()
Defaults to the current date.
Definition: FieldTypes.h:857
FIX::CHAR
char CHAR
Definition: FieldTypes.h:893
FIX::TYPE::Boolean
@ Boolean
Definition: FieldTypes.h:941
FIX::LENGTH
int LENGTH
Definition: FieldTypes.h:917
FIX::TYPE::TzTimeStamp
@ TzTimeStamp
Definition: FieldTypes.h:957
FIX::BOOLEAN
bool BOOLEAN
Definition: FieldTypes.h:904
FIX::DateTime::getSecond
int getSecond() const
Return the second portion of the time (0-59)
Definition: FieldTypes.h:165
FIX::LocalDate::setCurrent
void setCurrent()
Set to the current time.
Definition: FieldTypes.h:881
FIX::DateTime::~DateTime
virtual ~DateTime()
Definition: FieldTypes.h:119
FIX::operator<=
bool operator<=(const StringField &lhs, const char *rhs)
Definition: Field.h:345
FIX::LocalTimeStamp
Date and Time represented in local time.
Definition: FieldTypes.h:650
FIX::DateTime::m_time
int64_t m_time
Definition: FieldTypes.h:80
FIX::LOCALMKTDATE
std::string LOCALMKTDATE
Definition: FieldTypes.h:905
FIX::DateTime::getMonth
int getMonth() const
Return the month (1-12) portion of the date.
Definition: FieldTypes.h:130
FIX::DateTime::julianDate
static int julianDate(int year, int month, int day)
Helper method to calculate a Julian day number.
Definition: FieldTypes.h:529
FIX::TYPE::Currency
@ Currency
Definition: FieldTypes.h:935
FIX::DateTime::SECONDS_PER_HOUR
static const int64_t SECONDS_PER_HOUR
Definition: FieldTypes.h:84
FIX::TYPE::UtcTimeStamp
@ UtcTimeStamp
Definition: FieldTypes.h:940
FIX::LocalTimeOnly::LocalTimeOnly
LocalTimeOnly(int hour, int minute, int second, int fraction, int precision)
Definition: FieldTypes.h:779
FIX::AMT
double AMT
Definition: FieldTypes.h:896
FIX::UTCDATE
UtcDate UTCDATE
Definition: FieldTypes.h:911
FIX::DateTime::JULIAN_19700101
static const int64_t JULIAN_19700101
Definition: FieldTypes.h:94
int64_t
signed __int64 int64_t
Definition: stdint_msvc.h:90
FIX::TYPE::Language
@ Language
Definition: FieldTypes.h:959
stdint_msvc.h
FIX::EXCHANGE
std::string EXCHANGE
Definition: FieldTypes.h:902
FIX::TYPE::Amt
@ Amt
Definition: FieldTypes.h:933
FIX::TYPE::Float
@ Float
Definition: FieldTypes.h:944
FIX::LocalTimeStamp::LocalTimeStamp
LocalTimeStamp()
Defaults to the current date and time.
Definition: FieldTypes.h:654
FIX::LocalTimeStamp::LocalTimeStamp
LocalTimeStamp(int hour, int minute, int second, int millisecond, int date, int month, int year)
Definition: FieldTypes.h:674
FIX::UtcTimeStamp::setCurrent
void setCurrent()
Definition: FieldTypes.h:643
FIX::operator==
bool operator==(const DatabaseConnectionID &lhs, const DatabaseConnectionID &rhs)
Definition: DatabaseConnectionID.h:108
FIX::DateTime::getMinute
int getMinute() const
Return the minute portion of the time (0-59)
Definition: FieldTypes.h:159
FIX::time_gmtime
tm time_gmtime(const time_t *t)
Definition: Utility.cpp:401
FIX::DateTime::setMillisecond
void setMillisecond(int millis)
Set the millisecond portion of the time.
Definition: FieldTypes.h:343
FIX::DateTime::getHMS
void getHMS(int &hour, int &minute, int &second, int &millis) const
Load the referenced values with the hour, minute, second and millisecond portions of the time in a si...
Definition: FieldTypes.h:235
FIX::MULTIPLECHARVALUE
std::string MULTIPLECHARVALUE
Definition: FieldTypes.h:901
FIX::DateTime::getDate
int getDate() const
Another name for the day of the month.
Definition: FieldTypes.h:147
FIX::TYPE::UtcTimeOnly
@ UtcTimeOnly
Definition: FieldTypes.h:950
FIX::DateTime::MINUTES_PER_HOUR
static const int64_t MINUTES_PER_HOUR
Definition: FieldTypes.h:86
FIX::TYPE::String
@ String
Definition: FieldTypes.h:929
FIX::TYPE::Length
@ Length
Definition: FieldTypes.h:954
FIX::DateTime::getMillisecond
int getMillisecond() const
Return the millisecond portion of the time (0-999)
Definition: FieldTypes.h:171
FIX::DateTime::operator+=
void operator+=(int seconds)
Add a number of seconds to this.
Definition: FieldTypes.h:397
FIX::MULTIPLEVALUESTRING
std::string MULTIPLEVALUESTRING
Definition: FieldTypes.h:899
FIX::TYPE::XmlData
@ XmlData
Definition: FieldTypes.h:958
FIX::DAYOFMONTH
std::string DAYOFMONTH
Definition: FieldTypes.h:910
FIX::MONTHYEAR
std::string MONTHYEAR
Definition: FieldTypes.h:909
FIX::TYPE::Data
@ Data
Definition: FieldTypes.h:943
FIX::PRECISION_FACTOR
static const int PRECISION_FACTOR[10]
Date and Time stored as a Julian day number and number of nanoseconds since midnight.
Definition: FieldTypes.h:75
FIX::TYPE::Exchange
@ Exchange
Definition: FieldTypes.h:939
FIX
Definition: Acceptor.cpp:34
FIX::PRICEOFFSET
double PRICEOFFSET
Definition: FieldTypes.h:908
FIX::INT
int INT
Definition: FieldTypes.h:895
FIX::DateTime::setFraction
void setFraction(int fraction, int precision)
Set the fraction portion of the time.
Definition: FieldTypes.h:367
FIX::UTCTIMEONLY
UtcTimeOnly UTCTIMEONLY
Definition: FieldTypes.h:913
FIX::operator>
bool operator>(const StringField &lhs, const char *rhs)
Definition: Field.h:333
FIX::CURRENCY
std::string CURRENCY
Definition: FieldTypes.h:898
FIX::DateTime::nowUtc
static DateTime nowUtc()
Return the current wall-clock time as a utc DateTime.
Definition: FieldTypes.cpp:51
FIX::UtcTimeStamp::UtcTimeStamp
UtcTimeStamp(int hour, int minute, int second, int millisecond, int date, int month, int year)
Definition: FieldTypes.h:623
FIX::TYPE::MonthYear
@ MonthYear
Definition: FieldTypes.h:946
FIX::UtcTimeOnly::UtcTimeOnly
UtcTimeOnly()
Defaults to the current time.
Definition: FieldTypes.h:705
FIX::DateTime::convertToNanos
static int convertToNanos(int fraction, int precision)
Convert to internal nanos.
Definition: FieldTypes.h:418
FIX::LocalTimeOnly::LocalTimeOnly
LocalTimeOnly()
Defaults to the current time.
Definition: FieldTypes.h:763
FIX::DateTime::DateTime
DateTime()
Default constructor - initializes to zero.
Definition: FieldTypes.h:97
FIX::DateTime::setMicrosecond
void setMicrosecond(int micros)
Set the microsecond portion of the time.
Definition: FieldTypes.h:351
FIX::TYPE::TzTimeOnly
@ TzTimeOnly
Definition: FieldTypes.h:956
FIX::DateTime::getWeekDay
int getWeekDay() const
Calculate the weekday of the date (Sunday is 1, Saturday is 7)
Definition: FieldTypes.h:256
FIX::TZTIMEONLY
std::string TZTIMEONLY
Definition: FieldTypes.h:919
FIX::DateTime::setYMD
void setYMD(int year, int month, int day)
Set the date portion of the DateTime.
Definition: FieldTypes.h:299
FIX::DateTime::m_date
int m_date
Definition: FieldTypes.h:79
FIX::DateTime::getMicroecond
int getMicroecond() const
Return the microsecond portion of the time.
Definition: FieldTypes.h:177
FIX::DateTime::fromLocalTimeT
static DateTime fromLocalTimeT(time_t t, int millis=0)
Definition: FieldTypes.h:491
FIX::UtcDate
Date only represented in UTC.
Definition: FieldTypes.h:817
FIX::DateTime::clearDate
void clearDate()
Clear the date portion of the DateTime.
Definition: FieldTypes.h:375
FIX::DateTime::setNanosecond
void setNanosecond(int nanos)
Set the nanosecond portion of the time.
Definition: FieldTypes.h:359
FIX::TYPE::Unknown
@ Unknown
Definition: FieldTypes.h:928
FIX::operator-
int operator-(const DateTime &lhs, const DateTime &rhs)
Calculate the difference between two DateTime values and return the result as a number of seconds.
Definition: FieldTypes.h:591
FIX::DateTime::setSecond
void setSecond(int sec)
Set the seconds portion of the time.
Definition: FieldTypes.h:335
FIX::TYPE::Qty
@ Qty
Definition: FieldTypes.h:934
FIX::DateTime::getNanosecond
unsigned int getNanosecond() const
Return the nanosecond portion of the time.
Definition: FieldTypes.h:183
uint64_t
unsigned __int64 uint64_t
Definition: stdint_msvc.h:91
FIX::DateTime::fromTm
static DateTime fromTm(const tm &tm, int millis=0)
Convert a tm and optional milliseconds to a DateTime.
Definition: FieldTypes.h:511
FIX::DateTime::SECONDS_PER_DAY
static const int64_t SECONDS_PER_DAY
Magic numbers.
Definition: FieldTypes.h:83
FIX::UtcDateOnly
UtcDate UtcDateOnly
Definition: FieldTypes.h:890
FIX::operator!=
bool operator!=(const DatabaseConnectionID &lhs, const DatabaseConnectionID &rhs)
Definition: DatabaseConnectionID.h:116
FIX::TYPE::Country
@ Country
Definition: FieldTypes.h:955
FIX::COUNTRY
std::string COUNTRY
Definition: FieldTypes.h:918
FIX::LANGUAGE
std::string LANGUAGE
Definition: FieldTypes.h:922
FIX::DateTime::getYMD
void getYMD(int &year, int &month, int &day) const
Load the referenced values with the year, month and day portions of the date in a single operation.
Definition: FieldTypes.h:228
FIX::DateTime::getJulianDate
int getJulianDate() const
Return the internal julian date.
Definition: FieldTypes.h:150
FIX::DateTime::makeHMS
static int64_t makeHMS(int hour, int minute, int second, int nanos)
Helper method to convert a broken down time to a number of nanoseconds since midnight.
Definition: FieldTypes.h:471
FIX::DateTime::getTmUtc
tm getTmUtc() const
Convert the DateTime to a struct tm which is in UTC.
Definition: FieldTypes.h:278
FIX::DateTime::NANOS_PER_MIN
static const int64_t NANOS_PER_MIN
Definition: FieldTypes.h:90
FIX::UtcTimeOnly
Time only represented in UTC.
Definition: FieldTypes.h:701
FIX::DATA
std::string DATA
Definition: FieldTypes.h:906
Utility.h
FIX::TYPE::Type
Type
Definition: FieldTypes.h:926
FIX::UtcDate::setCurrent
void setCurrent()
Set to the current time.
Definition: FieldTypes.h:845
FIX::STRING
std::string STRING
Definition: FieldTypes.h:892
FIX::TYPE::MultipleCharValue
@ MultipleCharValue
Definition: FieldTypes.h:938
FIX::TYPE::MultipleStringValue
@ MultipleStringValue
Definition: FieldTypes.h:937
FIX::DateTime::getYear
int getYear() const
Return the year portion of the date.
Definition: FieldTypes.h:122

Generated on Wed Apr 29 2020 19:41:30 for QuickFIX by doxygen 1.8.17 written by Dimitri van Heesch, © 1997-2001