quickfix_ruby 1.14.3.1 → 1.15.1

data/ext/quickfix/FieldTypes.cpp

@@ -33,14 +33,14 @@ namespace FIX {
 
 DateTime DateTime::nowUtc()
 {
-#if defined( HAVE_FTIME )
+#if defined( _POSIX_SOURCE ) || defined(HAVE_GETTIMEOFDAY)
+    struct timeval tv;
+    gettimeofday (&tv, 0);
+    return fromUtcTimeT( tv.tv_sec, tv.tv_usec, 6 );
+#elif defined( HAVE_FTIME )
     timeb tb;
     ftime (&tb);
     return fromUtcTimeT (tb.time, tb.millitm);
-#elif defined( _POSIX_SOURCE )
-    struct timeval tv;
-    gettimeofday (&tv, 0);
-    return fromUtcTimeT( tv.tv_sec, tv.tv_usec / 1000 );
 #else
     return fromUtcTimeT( ::time (0), 0 );
 #endif
@@ -48,14 +48,14 @@ DateTime DateTime::nowUtc()
 
 DateTime DateTime::nowLocal()
 {
-#if defined( HAVE_FTIME )
+#if defined( _POSIX_SOURCE ) || defined(HAVE_GETTIMEOFDAY)
+    struct timeval tv;
+    gettimeofday (&tv, 0);
+    return fromLocalTimeT( tv.tv_sec, tv.tv_usec, 6 );
+#elif defined( HAVE_FTIME )
     timeb tb;
     ftime (&tb);
     return fromLocalTimeT( tb.time, tb.millitm );
-#elif defined( _POSIX_SOURCE )
-    struct timeval tv;
-    gettimeofday (&tv, 0);
-    return fromLocalTimeT( tv.tv_sec, tv.tv_usec / 1000 );
 #else
     return fromLocalTimeT( ::time (0), 0 );
 #endif

data/ext/quickfix/FieldTypes.h

@@ -26,6 +26,12 @@
 #pragma warning( disable : 4503 4355 4786 4290 )
 #endif
 
+#if defined(_MSC_VER) && (_MSC_VER < 1600)
+ #include "stdint_msvc.h"
+#else
+ #include <stdint.h> /* integer types int8_t .. uint64_t, intptr_t */
+#endif
+
 #include "Utility.h"
 #include <string>
 #include <time.h>
@@ -37,7 +43,7 @@ namespace FIX
  */
 
 /// Date and Time stored as a Julian day number and number of
-/// milliseconds since midnight.  Does not perform any timezone
+/// nanoseconds since midnight.  Does not perform any timezone
 /// calculations.  All magic numbers and related calculations
 /// have been taken from:
 ///
@@ -47,40 +53,50 @@ namespace FIX
 /// \sa http://scienceworld.wolfram.com/astronomy/Weekday.html
 ///
 /// \author Caleb Epstein <caleb.epstein at gmail dot com>
+
+// Precision factor of timestamp. [0] - second, [9] - nanosecond
+static const int PRECISION_FACTOR[10] = {1000000000, 100000000, 10000000, 1000000, 100000, 10000, 1000, 100, 10, 1};
+
 struct DateTime 
 {
   int m_date;
-  int m_time;
+  int64_t m_time;
 
   /// Magic numbers
-  enum 
-  {
-    SECONDS_PER_DAY = 86400,
-    SECONDS_PER_HOUR = 3600,
-    SECONDS_PER_MIN = 60,
-    MINUTES_PER_HOUR = 60,
+  static const int64_t  SECONDS_PER_DAY = 86400;
+  static const int64_t  SECONDS_PER_HOUR = 3600;
+  static const int64_t  SECONDS_PER_MIN = 60;
+  static const int64_t  MINUTES_PER_HOUR = 60;
 
-    MILLIS_PER_DAY = 86400000,
-    MILLIS_PER_HOUR = 3600000,
-    MILLIS_PER_MIN = 60000,
-    MILLIS_PER_SEC = 1000,
+  static const int64_t  NANOS_PER_DAY = 86400000000000;
+  static const int64_t  NANOS_PER_HOUR = 3600000000000;
+  static const int64_t  NANOS_PER_MIN = 60000000000;
+  static const int64_t  NANOS_PER_SEC = 1000000000;
 
-    // time_t epoch (1970-01-01) as a Julian date
-    JULIAN_19700101 = 2440588
-  };
+  // time_t epoch (1970-01-01) as a Julian date
+  static const int64_t  JULIAN_19700101 = 2440588;
 
   /// Default constructor - initializes to zero
   DateTime () : m_date (0), m_time (0) {}
 
   /// Construct from a Julian day number and time in millis
-  DateTime (int date, int time) : m_date (date), m_time (time) {}
+  DateTime (int date, int64_t time) : m_date (date), m_time (time) {}
 
   /// Construct from the specified components
   DateTime( int year, int month, int day,
             int hour, int minute, int second, int millis ) 
   {
     m_date = julianDate( year, month, day );
-    m_time = makeHMS( hour, minute, second, millis );
+    m_time = makeHMS( hour, minute, second, millis * PRECISION_FACTOR[3] );
+  }
+
+  /// Construct from the specified components
+  DateTime( int year, int month, int day,
+            int hour, int minute, int second, int fraction, int precision )
+  {
+    m_date = julianDate( year, month, day );
+    int nanos = convertToNanos(fraction, precision);
+    m_time = makeHMS( hour, minute, second, nanos );
   }
 
   virtual ~DateTime() {}
@@ -117,27 +133,77 @@ struct DateTime
   inline int getJulianDate() const { return m_date; }
 
   /// Return the hour portion of the time (0-23)
-  inline int getHour() const 
+  inline int getHour() const
   {
-    return m_time / MILLIS_PER_HOUR;
+    return (int)(m_time / NANOS_PER_HOUR);
   }
 
   /// Return the minute portion of the time (0-59)
-  inline int getMinute() const 
+  inline int getMinute() const
   {
-    return (m_time / MILLIS_PER_MIN) % MINUTES_PER_HOUR;
+    return (m_time / NANOS_PER_MIN) % MINUTES_PER_HOUR;
   }
 
   /// Return the second portion of the time (0-59)
-  inline int getSecond() const 
+  inline int getSecond() const
+  {
+    return (m_time / NANOS_PER_SEC) % SECONDS_PER_MIN;
+  }
+
+  /// Return the millisecond portion of the time (0-999)
+  inline int getMillisecond() const
   {
-    return (m_time / MILLIS_PER_SEC) % SECONDS_PER_MIN;
+    return (getNanosecond() / PRECISION_FACTOR[3]);
   }
 
-  /// Return the millisecond portion of the time
-  inline int getMillisecond() const 
+  /// Return the microsecond portion of the time
+  inline int getMicroecond() const
   {
-    return m_time % MILLIS_PER_SEC;
+    return (getNanosecond() / PRECISION_FACTOR[6]);
+  }
+
+  /// Return the nanosecond portion of the time
+  inline unsigned int getNanosecond() const
+  {
+    return static_cast<uint64_t>(m_time) % NANOS_PER_SEC;
+  }
+
+  /// Return the fraction portion of the time
+  inline int getFraction(int precision) const
+  {
+    switch (precision)
+    {
+    case 0:
+       return (getNanosecond() / PRECISION_FACTOR[0]);
+
+    case 1:
+      return (getNanosecond() / PRECISION_FACTOR[1]);
+
+    case 2:
+      return (getNanosecond() / PRECISION_FACTOR[2]);
+
+    case 3:
+     return (getNanosecond() / PRECISION_FACTOR[3]);
+
+    case 4:
+      return (getNanosecond() / PRECISION_FACTOR[4]);
+
+    case 5:
+      return (getNanosecond() / PRECISION_FACTOR[5]);
+
+    case 6:
+      return (getNanosecond() / PRECISION_FACTOR[6]);
+
+    case 7:
+      return (getNanosecond() / PRECISION_FACTOR[7]);
+
+    case 8:
+      return (getNanosecond() / PRECISION_FACTOR[8]);
+
+    case 9:
+    default:
+      return (getNanosecond() / PRECISION_FACTOR[9]);
+    }
   }
 
   /// Load the referenced values with the year, month and day
@@ -151,11 +217,22 @@ struct DateTime
   /// millisecond portions of the time in a single operation
   inline void getHMS( int& hour, int& minute, int& second, int& millis ) const 
   {
-    int ticks = m_time / MILLIS_PER_SEC;
+    int ticks = (int)(m_time / NANOS_PER_SEC);
+    hour = ticks / SECONDS_PER_HOUR;
+    minute = (ticks / SECONDS_PER_MIN) % MINUTES_PER_HOUR;
+    second = ticks % SECONDS_PER_MIN;
+    millis = getMillisecond();
+  }
+
+  /// Load the referenced values with the hour, minute, second and
+  /// fraction portions of the time in a single operation
+  inline void getHMS( int& hour, int& minute, int& second, int& fraction, int precision ) const
+  {
+    int ticks = (int)(m_time / NANOS_PER_SEC);
     hour = ticks / SECONDS_PER_HOUR;
     minute = (ticks / SECONDS_PER_MIN) % MINUTES_PER_HOUR;
     second = ticks % SECONDS_PER_MIN;
-    millis = m_time % MILLIS_PER_SEC;
+    fraction = getFraction(precision);
   }
 
   /// Calculate the weekday of the date (Sunday is 1, Saturday is 7)
@@ -177,7 +254,7 @@ struct DateTime
   inline time_t getTimeT() const 
   {
     return (SECONDS_PER_DAY * (m_date - JULIAN_19700101) +
-            m_time / MILLIS_PER_SEC);
+            m_time / NANOS_PER_SEC);
   }
 
   /// Convert the DateTime to a struct tm which is in UTC
@@ -210,7 +287,15 @@ struct DateTime
   /// Set the time portion of the DateTime
   void setHMS( int hour, int minute, int second, int millis )
   {
-    m_time = makeHMS( hour, minute, second, millis );
+    m_time = makeHMS( hour, minute, second, millis * PRECISION_FACTOR[3] );
+  }
+
+  /// Set the time portion of the DateTime
+  void setHMS( int hour, int minute, int second, int fraction, int precision )
+  {
+    int nanos = convertToNanos(fraction, precision);
+
+    m_time = makeHMS( hour, minute, second,  nanos);
   }
 
   /// Set the hour portion of the time
@@ -245,6 +330,30 @@ struct DateTime
     setHMS( hour, min, sec, millis );
   }
 
+  /// Set the microsecond portion of the time
+  void setMicrosecond( int micros )
+  {
+    int hour, min, sec, old_nanos;
+    getHMS( hour, min, sec, old_nanos, 9 );
+    setHMS( hour, min, sec, micros, 6 );
+  }
+
+  /// Set the nanosecond portion of the time
+  void setNanosecond( int nanos )
+  {
+    int hour, min, sec, old_nanos;
+    getHMS( hour, min, sec, old_nanos, 9 );
+    setHMS( hour, min, sec, nanos, 9 );
+  }
+
+  /// Set the fraction portion of the time
+  void setFraction( int fraction, int precision )
+  {
+    int hour, min, sec, old_nanos;
+    getHMS( hour, min, sec, old_nanos, 9 );
+    setHMS( hour, min, sec, fraction, precision );
+  }
+
   /// Clear the date portion of the DateTime
   void clearDate() 
   {
@@ -258,7 +367,7 @@ struct DateTime
   }
 
   /// Set the internal date and time members
-  void set( int date, int time ) { m_date = date; m_time = time; }
+  void set( int date, int64_t time ) { m_date = date; m_time = time; }
 
   /// Initialize from another DateTime
   void set( const DateTime& other ) 
@@ -268,33 +377,85 @@ struct DateTime
   }
 
   /// Add a number of seconds to this
-  void operator+=( int seconds ) 
+  void operator+=( int seconds )
   {
     int d = seconds / SECONDS_PER_DAY;
     int s = seconds % SECONDS_PER_DAY;
 
     m_date += d;
-    m_time += s * MILLIS_PER_SEC;
+    m_time += s * NANOS_PER_SEC;
 
-    if( m_time > MILLIS_PER_DAY )
+    if( m_time > NANOS_PER_DAY )
     {
       m_date++;
-      m_time %= MILLIS_PER_DAY;
+      m_time %= NANOS_PER_DAY;
     }
     else if( m_time < 0 )
     {
       m_date--;
-      m_time += MILLIS_PER_DAY;
+      m_time += NANOS_PER_DAY;
+    }
+  }
+
+  /// Convert to internal nanos
+  static int convertToNanos(int fraction, int precision)
+  {
+    int nanos;
+
+    switch (precision)
+    {
+    case 0:
+      nanos = fraction * PRECISION_FACTOR[0];
+      break;
+
+    case 1:
+      nanos = fraction * PRECISION_FACTOR[1];
+      break;
+
+    case 2:
+      nanos = fraction * PRECISION_FACTOR[2];
+      break;
+
+    case 3:
+      nanos = fraction * PRECISION_FACTOR[3];
+      break;
+
+    case 4:
+      nanos = fraction * PRECISION_FACTOR[4];
+      break;
+
+    case 5:
+      nanos = fraction * PRECISION_FACTOR[5];
+      break;
+
+    case 6:
+      nanos = fraction * PRECISION_FACTOR[6];
+      break;
+
+    case 7:
+      nanos = fraction * PRECISION_FACTOR[7];
+      break;
+
+    case 8:
+      nanos = fraction * PRECISION_FACTOR[8];
+      break;
+
+    case 9:
+    default:
+      nanos = fraction * PRECISION_FACTOR[9];
+      break;
     }
+
+    return nanos;
   }
 
   /// Helper method to convert a broken down time to a number of
-  /// milliseconds since midnight
-  static int makeHMS( int hour, int minute, int second, int millis )
+  /// nanoseconds since midnight
+  static int64_t makeHMS( int hour, int minute, int second, int nanos )
   {
-    return MILLIS_PER_SEC * (SECONDS_PER_HOUR * hour +
-                             SECONDS_PER_MIN * minute +
-                             second) + millis;
+    return NANOS_PER_SEC * (SECONDS_PER_HOUR * hour +
+                            SECONDS_PER_MIN * minute +
+                            second) + nanos;
   }
 
   /// Return the current wall-clock time as a utc DateTime
@@ -316,13 +477,35 @@ struct DateTime
     return fromTm( tm, millis );
   }
 
+  static DateTime fromUtcTimeT( time_t t, int fraction, int precision )
+  {
+    struct tm tm = time_gmtime( &t );
+    return fromTm( tm, fraction, precision );
+  }
+
+  static DateTime fromLocalTimeT( time_t t, int fraction, int precision )
+  {
+    struct tm tm = time_localtime( &t );
+    return fromTm( tm, fraction, precision );
+  }
+
   /// Convert a tm and optional milliseconds to a DateTime.  \note
   /// the tm structure is assumed to contain a date specified in UTC
   static DateTime fromTm( const tm& tm, int millis = 0 )
   {
     return DateTime ( julianDate(tm.tm_year + 1900, tm.tm_mon + 1,
                                  tm.tm_mday),
-                     makeHMS(tm.tm_hour, tm.tm_min, tm.tm_sec, millis) );
+                     makeHMS(tm.tm_hour, tm.tm_min, tm.tm_sec, millis * PRECISION_FACTOR[3]) );
+  }
+
+  /// Convert a tm and optional milliseconds to a DateTime.  \note
+  /// the tm structure is assumed to contain a date specified in UTC
+  static DateTime fromTm( const tm& tm, int fraction, int precision )
+  {
+    int nanos = convertToNanos(fraction, precision);
+    return DateTime ( julianDate(tm.tm_year + 1900, tm.tm_mon + 1,
+                                 tm.tm_mday),
+                     makeHMS(tm.tm_hour, tm.tm_min, tm.tm_sec, nanos) );
   }
 
   /// Helper method to calculate a Julian day number.
@@ -391,8 +574,8 @@ inline bool operator>=( const DateTime& lhs, const DateTime& rhs )
 inline int operator-( const DateTime& lhs, const DateTime& rhs )
 {
   return (DateTime::SECONDS_PER_DAY * (lhs.m_date - rhs.m_date) +
-          // Truncate the millis before subtracting
-          lhs.m_time / 1000 - rhs.m_time / 1000);
+          // Truncate the nanos before subtracting
+          (int)(lhs.m_time / DateTime::NANOS_PER_SEC) - (int)(rhs.m_time / DateTime::NANOS_PER_SEC));
 }
 
 /// Date and Time represented in UTC.
@@ -410,6 +593,12 @@ public:
     setHMS( hour, minute, second, millisecond );
   }
 
+  UtcTimeStamp( int hour, int minute, int second, int fraction, int precision )
+  : DateTime( DateTime::nowUtc() )
+  {
+    setHMS( hour, minute, second, fraction, precision );
+  }
+
   UtcTimeStamp( int hour, int minute, int second,
                 int date, int month, int year )
   : DateTime( year, month, date, hour, minute, second, 0 ) {}
@@ -418,12 +607,22 @@ public:
                 int date, int month, int year )
   : DateTime( year, month, date, hour, minute, second, millisecond ) {}
 
+  UtcTimeStamp( int hour, int minute, int second, int fraction,
+                int date, int month, int year, int precision )
+  : DateTime( year, month, date, hour, minute, second, fraction, precision ) {}
+
   explicit UtcTimeStamp( time_t time, int millisecond = 0 )
   : DateTime( fromUtcTimeT (time, millisecond) ) {}
 
+  UtcTimeStamp( time_t time, int fraction, int precision )
+    : DateTime( fromUtcTimeT (time, fraction, precision) ) {}
+
   UtcTimeStamp( const tm* time, int millisecond = 0 )
   : DateTime( fromTm (*time, millisecond) ) {}
 
+  UtcTimeStamp( const tm* time, int fraction, int precision )
+  : DateTime( fromTm (*time, fraction, precision) ) {}
+
   void setCurrent() 
   {
     set( DateTime::nowUtc() );
@@ -445,6 +644,12 @@ public:
     setHMS( hour, minute, second, millisecond );
   }
 
+  LocalTimeStamp( int hour, int minute, int second, int fraction, int precision )
+  : DateTime( DateTime::nowLocal() )
+  {
+    setHMS( hour, minute, second, fraction, precision );
+  }
+
   LocalTimeStamp( int hour, int minute, int second,
                 int date, int month, int year )
   : DateTime( year, month, date, hour, minute, second, 0 ) {}
@@ -453,12 +658,22 @@ public:
                 int date, int month, int year )
   : DateTime( year, month, date, hour, minute, second, millisecond ) {}
 
+  LocalTimeStamp( int hour, int minute, int second, int fraction,
+                int date, int month, int year, int precision )
+  : DateTime( year, month, date, hour, minute, second, fraction, precision ) {}
+
   explicit LocalTimeStamp( time_t time, int millisecond = 0 )
   : DateTime( fromLocalTimeT (time, millisecond) ) {}
 
+  LocalTimeStamp( time_t time, int fraction, int precision )
+    : DateTime( fromLocalTimeT (time, fraction, precision) ) {}
+
   LocalTimeStamp( const tm* time, int millisecond = 0 )
   : DateTime( fromTm (*time, millisecond) ) {}
 
+  LocalTimeStamp( const tm* time, int fraction, int precision )
+  : DateTime( fromTm (*time, fraction, precision) ) {}
+
   void setCurrent() 
   {
     set( DateTime::nowLocal() );
@@ -486,18 +701,35 @@ public:
     setHMS( hour, minute, second, millisecond );
   }
 
+  UtcTimeOnly( int hour, int minute, int second, int fraction, int precision )
+  {
+    setHMS( hour, minute, second, fraction, precision );
+  }
+
   explicit UtcTimeOnly( time_t time, int millisecond = 0 )
   : DateTime( fromUtcTimeT (time, millisecond) )
   {
     clearDate();
   }
 
+  UtcTimeOnly( time_t time, int fraction, int precision )
+    : DateTime( fromUtcTimeT (time, fraction, precision) )
+  {
+    clearDate();
+  }
+
   UtcTimeOnly( const tm* time, int millisecond = 0 )
   : DateTime( fromTm (*time, millisecond) )
   {
     clearDate();
   }
 
+  UtcTimeOnly( const tm* time, int fraction, int precision )
+  : DateTime( fromTm (*time, fraction, precision) )
+  {
+    clearDate();
+  }
+
   /// Set to the current time.
   void setCurrent()
   {
@@ -527,18 +759,35 @@ public:
     setHMS( hour, minute, second, millisecond );
   }
 
+  LocalTimeOnly( int hour, int minute, int second, int fraction, int precision )
+  {
+    setHMS( hour, minute, second, fraction, precision );
+  }
+
   explicit LocalTimeOnly( time_t time, int millisecond = 0 )
   : DateTime( fromLocalTimeT (time, millisecond) )
   {
     clearDate();
   }
 
+  LocalTimeOnly( time_t time, int fraction, int precision )
+    : DateTime( fromLocalTimeT (time, fraction, precision) )
+  {
+    clearDate();
+  }
+
   LocalTimeOnly( const tm* time, int millisecond = 0 )
   : DateTime( fromTm (*time, millisecond) )
   {
     clearDate();
   }
 
+  LocalTimeOnly( const tm* time, int fraction, int precision )
+  : DateTime( fromTm (*time, fraction, precision) )
+  {
+    clearDate();
+  }
+
   /// Set to the current time.
   void setCurrent()
   {