quickfix_ruby 1.14.3.1 → 1.15.1

data/ext/quickfix/Dictionary.cpp

@@ -87,7 +87,7 @@ throw( ConfigError, FieldConvertError )
   try
   {
     std::string value = getString(key);
-    if( value.size() < 2 ) throw FieldConvertError(0);
+    if( value.size() < 2 ) throw FieldConvertError();
     std::string abbr = value.substr(0, 2);
     std::transform( abbr.begin(), abbr.end(), abbr.begin(), tolower );
     if( abbr == "su" ) return 1;
@@ -97,7 +97,6 @@ throw( ConfigError, FieldConvertError )
     if( abbr == "th" ) return 5;
     if( abbr == "fr" ) return 6;
     if( abbr == "sa" ) return 7;
-    if( value.size() < 2 ) throw FieldConvertError(0);
   }
   catch ( FieldConvertError& )
   {

data/ext/quickfix/Exceptions.h

@@ -250,22 +250,20 @@ struct SocketException : public Exception
   SocketException( const std::string& what )
     : Exception( "Socket Error", what ) {}
 
-  std::string errorToWhat()
+  static std::string errorToWhat()
   {
 #ifdef _MSC_VER
-    error = WSAGetLastError();
+    int error = WSAGetLastError();
     char buffer[2048];
     FormatMessageA( FORMAT_MESSAGE_FROM_SYSTEM, NULL, error,
                    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                    buffer, 2048, NULL );
     return buffer;
 #else
-    error = errno;
+    int error = errno;
     return strerror( error );
 #endif
   }
-
-  int error;
 };
 
 /// Socket send operation failed

data/ext/quickfix/Field.h

@@ -33,6 +33,10 @@
 #include "FieldTypes.h"
 #include "Utility.h"
 
+#if defined(__SUNPRO_CC)
+#include <algorithm>
+#endif
+
 namespace FIX
 {
 /**
@@ -73,30 +77,62 @@ class FieldBase
   friend class Message;
 
   /// Constructor which also calculates field metrics
-  FieldBase( int field, 
+  FieldBase( int tag, 
              std::string::const_iterator valueStart, 
              std::string::const_iterator valueEnd,
              std::string::const_iterator tagStart, 
              std::string::const_iterator tagEnd )
-    : m_field( field )
+    : m_tag( tag )
     , m_string( valueStart, valueEnd )
     , m_metrics( calculateMetrics( tagStart, tagEnd ) )
   {}
 
 public:
-  FieldBase( int field, const std::string& string )
-    : m_field( field ), m_string(string), m_metrics( no_metrics() )
+  FieldBase( int tag, const std::string& string )
+    : m_tag( tag ), m_string(string), m_metrics( no_metrics() )
   {}
 
   virtual ~FieldBase() {}
 
-  void setField( int field )
+  FieldBase( const FieldBase& rhs )
+  : m_tag( rhs.getTag() )
+  , m_string( rhs.m_string )
+  , m_metrics( rhs.m_metrics )
+  {
+
+  }
+
+  FieldBase& operator=( const FieldBase& rhs)
+  {
+    m_tag = rhs.getTag();
+    m_string = rhs.m_string;
+    m_metrics = rhs.m_metrics;
+    m_data.clear();
+
+    return *this;
+  }
+
+  void swap( FieldBase& rhs )
   {
-    m_field = field;
+    std::swap( m_tag, rhs.m_tag );
+    std::swap( m_metrics, rhs.m_metrics );
+    m_string.swap( rhs.m_string );
+    m_data.swap( rhs.m_data );
+  }
+
+  void setTag( int tag )
+  {
+    m_tag = tag;
     m_metrics = no_metrics();
     m_data.clear();
   }
 
+  /// @deprecated Use setTag
+  void setField( int field )
+  {
+    setTag( field );
+  }
+
   void setString( const std::string& string )
   {
     m_string = string;
@@ -105,8 +141,12 @@ public:
   }
 
   /// Get the fields integer tag.
+  int getTag() const
+  { return m_tag; }
+
+  /// @deprecated Use getTag
   int getField() const
-  { return m_field; }
+  { return getTag(); }
 
   /// Get the string representation of the fields value.
   const std::string& getString() const
@@ -137,7 +177,7 @@ public:
 
   /// Compares fields based on their tag numbers
   bool operator < ( const FieldBase& field ) const
-  { return m_field < field.m_field; }
+  { return m_tag < field.m_tag; }
 
 private:
 
@@ -151,16 +191,16 @@ private:
   /// Serializes string representation of the Field to input string
   void encodeTo( std::string& result ) const
   {
-    size_t tagLength = FIX::number_of_symbols_in( m_field ) + 1;
-    size_t totalLength = tagLength + m_string.length() + 1;
+    size_t tagLength = FIX::number_of_symbols_in( m_tag );
+    size_t totalLength = tagLength + m_string.length() + 2;
 
     result.resize( totalLength );
 
     char * buf = (char*)result.c_str();
-    FIX::integer_to_string( buf, tagLength, m_field );
+    FIX::integer_to_string( buf, tagLength, m_tag );
 
-    buf[tagLength - 1] = '=';
-    memcpy( buf + tagLength, m_string.data(), m_string.length() );
+    buf[tagLength] = '=';
+    memcpy( buf + tagLength + 1, m_string.data(), m_string.length() );
     buf[totalLength - 1] = '\001';
   }
 
@@ -178,7 +218,13 @@ private:
     for ( std::string::const_iterator str = start; str != end; ++str )
       checksum += (unsigned char)( *str );
 
+#if defined(__SUNPRO_CC)
+    std::ptrdiff_t d;
+    std::distance(start, end, d);
+    return field_metrics( d, checksum );
+#else
     return field_metrics( std::distance( start, end ), checksum );
+#endif
   }
 
   static field_metrics calculateMetrics( const std::string& field )
@@ -186,7 +232,7 @@ private:
     return calculateMetrics( field.begin(), field.end() );
   }
 
-  int m_field;
+  int m_tag;
   std::string m_string;
   mutable std::string m_data;
   mutable field_metrics m_metrics;
@@ -200,6 +246,11 @@ inline std::ostream& operator <<
   return stream;
 }
 
+inline void swap( FieldBase& lhs, FieldBase& rhs )
+{
+  lhs.swap( rhs );
+}
+
 /**
  * MSC doesn't support partial template specialization so we have this.
  * this is here to provide equality checking against native char arrays.
@@ -323,7 +374,7 @@ public:
     { try
       { return CharConvertor::convert( getString() ); }
       catch( FieldConvertError& )
-      { throw IncorrectDataFormat( getField(), getString() ); } }
+      { throw IncorrectDataFormat( getTag(), getString() ); } }
   operator char() const
     { return getValue(); }
 };
@@ -343,7 +394,7 @@ public:
     { try
       { return DoubleConvertor::convert( getString() ); }
       catch( FieldConvertError& )
-      { throw IncorrectDataFormat( getField(), getString() ); } }
+      { throw IncorrectDataFormat( getTag(), getString() ); } }
   operator double() const
     { return getValue(); }
 };
@@ -363,7 +414,7 @@ public:
     { try
       { return IntConvertor::convert( getString() ); }
       catch( FieldConvertError& )
-      { throw IncorrectDataFormat( getField(), getString() ); } }
+      { throw IncorrectDataFormat( getTag(), getString() ); } }
   operator const int() const
     { return getValue(); }
 };
@@ -383,7 +434,7 @@ public:
     { try
       { return BoolConvertor::convert( getString() ); }
       catch( FieldConvertError& )
-      { throw IncorrectDataFormat( getField(), getString() ); } }
+      { throw IncorrectDataFormat( getTag(), getString() ); } }
   operator bool() const
     { return getValue(); }
 };
@@ -392,10 +443,10 @@ public:
 class UtcTimeStampField : public FieldBase
 {
 public:
-  explicit UtcTimeStampField( int field, const UtcTimeStamp& data, bool showMilliseconds = false )
-: FieldBase( field, UtcTimeStampConvertor::convert( data, showMilliseconds ) ) {}
-  UtcTimeStampField( int field, bool showMilliseconds = false )
-: FieldBase( field, UtcTimeStampConvertor::convert( UtcTimeStamp(), showMilliseconds ) ) {}
+  explicit UtcTimeStampField( int field, const UtcTimeStamp& data, int precision = 0 )
+: FieldBase( field, UtcTimeStampConvertor::convert( data, precision ) ) {}
+  UtcTimeStampField( int field, int precision = 0 )
+: FieldBase( field, UtcTimeStampConvertor::convert( UtcTimeStamp(), precision ) ) {}
 
   void setValue( const UtcTimeStamp& value )
     { setString( UtcTimeStampConvertor::convert( value ) ); }
@@ -403,7 +454,7 @@ public:
     { try
       { return UtcTimeStampConvertor::convert( getString() ); }
       catch( FieldConvertError& )
-      { throw IncorrectDataFormat( getField(), getString() ); } }
+      { throw IncorrectDataFormat( getTag(), getString() ); } }
   operator UtcTimeStamp() const
     { return getValue(); }
 
@@ -430,7 +481,7 @@ public:
     { try
       { return UtcDateConvertor::convert( getString() ); }
       catch( FieldConvertError& )
-      { throw IncorrectDataFormat( getField(), getString() ); } }
+      { throw IncorrectDataFormat( getTag(), getString() ); } }
   operator UtcDate() const
     { return getValue(); }
 
@@ -446,10 +497,10 @@ public:
 class UtcTimeOnlyField : public FieldBase
 {
 public:
-  explicit UtcTimeOnlyField( int field, const UtcTimeOnly& data, bool showMilliseconds = false )
-: FieldBase( field, UtcTimeOnlyConvertor::convert( data, showMilliseconds ) ) {}
-  UtcTimeOnlyField( int field, bool showMilliseconds = false )
-: FieldBase( field, UtcTimeOnlyConvertor::convert( UtcTimeOnly(), showMilliseconds ) ) {}
+  explicit UtcTimeOnlyField( int field, const UtcTimeOnly& data, int precision = 0 )
+: FieldBase( field, UtcTimeOnlyConvertor::convert( data, precision ) ) {}
+  UtcTimeOnlyField( int field, int precision = 0 )
+: FieldBase( field, UtcTimeOnlyConvertor::convert( UtcTimeOnly(), precision ) ) {}
 
   void setValue( const UtcTimeOnly& value )
     { setString( UtcTimeOnlyConvertor::convert( value ) ); }
@@ -457,7 +508,7 @@ public:
     { try
       { return UtcTimeOnlyConvertor::convert( getString() ); }
       catch( FieldConvertError& )
-      { throw IncorrectDataFormat( getField(), getString() ); } }
+      { throw IncorrectDataFormat( getTag(), getString() ); } }
   operator UtcTimeOnly() const
     { return getValue(); }
 
@@ -484,7 +535,7 @@ public:
     { try
       { return CheckSumConvertor::convert( getString() ); }
       catch( FieldConvertError& )
-      { throw IncorrectDataFormat( getField(), getString() ); } }
+      { throw IncorrectDataFormat( getTag(), getString() ); } }
   operator const int() const
     { return getValue(); }
 };
@@ -529,9 +580,9 @@ DEFINE_FIELD_CLASS_NUM(NAME, TOK, TYPE, DEPRECATED_FIELD::NAME)
 #define DEFINE_FIELD_TIMECLASS_NUM( NAME, TOK, TYPE, NUM ) \
 class NAME : public TOK##Field { public: \
 NAME() : TOK##Field(NUM, false) {} \
-NAME(bool showMilliseconds) : TOK##Field(NUM, showMilliseconds) {} \
+NAME(int precision) : TOK##Field(NUM, precision) {} \
 NAME(const TYPE& value) : TOK##Field(NUM, value) {} \
-NAME(const TYPE& value, bool showMilliseconds) : TOK##Field(NUM, value, showMilliseconds) {} \
+NAME(const TYPE& value, int precision) : TOK##Field(NUM, value, precision) {} \
 }
 
 #define DEFINE_FIELD_TIMECLASS( NAME, TOK, TYPE ) \

data/ext/quickfix/FieldConvertors.cpp

@@ -0,0 +1,93 @@
+/****************************************************************************
+** Copyright (c) 2001-2014
+**
+** This file is part of the QuickFIX FIX Engine
+**
+** This file may be distributed under the terms of the quickfixengine.org
+** license as defined by quickfixengine.org and appearing in the file
+** LICENSE included in the packaging of this file.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.quickfixengine.org/LICENSE for licensing information.
+**
+** Contact ask@quickfixengine.org if any conditions of this licensing are
+** not clear to you.
+**
+****************************************************************************/
+
+#ifdef _MSC_VER
+#include "stdafx.h"
+#else
+#include "config.h"
+#endif
+
+#include <math.h>
+#include "FieldConvertors.h"
+#include <math.h>
+
+namespace FIX
+{
+
+// we include "double-conversion" project in FIX namespace
+// to avoid linking errors if quickfix is linked statically
+// and "double-conversion" is already used by target project
+
+#include "double-conversion/diy-fp.cc"
+#include "double-conversion/fixed-dtoa.cc"
+#include "double-conversion/bignum.cc"
+#include "double-conversion/bignum-dtoa.cc"
+#include "double-conversion/cached-powers.cc"
+#include "double-conversion/fast-dtoa.cc"
+#include "double-conversion/strtod.cc"
+#include "double-conversion/double-conversion.cc"
+
+  static double_conversion::DoubleToStringConverter g_dtoa_converter(
+    double_conversion::DoubleToStringConverter::NO_FLAGS,
+    "INF",
+    "NAN",
+    'e',
+    -DoubleConvertor::SIGNIFICANT_DIGITS,
+    DoubleConvertor::SIGNIFICANT_DIGITS,
+    DoubleConvertor::SIGNIFICANT_DIGITS - 1,
+    0);
+
+  static double_conversion::StringToDoubleConverter g_atod_converter(
+	  double_conversion::StringToDoubleConverter::NO_FLAGS,
+	  std::numeric_limits<double>::quiet_NaN(),
+	  std::numeric_limits<double>::quiet_NaN(),
+	  "INF",
+	  "NAN");
+
+  double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
+  {
+	  return g_atod_converter.StringToDouble( buffer, size, processed_chars );
+  }
+
+  int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
+  {
+    double_conversion::StringBuilder builder( buffer, size );
+    if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
+    {
+      builder.Reset();
+      return 0;
+    }
+
+    builder.TrimTrailingZeros();
+    return builder.position();
+  }
+
+  int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
+  {
+    double_conversion::StringBuilder builder( buffer, size );
+    if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
+    {
+      builder.Reset();
+      return 0;
+    }
+
+    return builder.position();
+  }
+
+}

data/ext/quickfix/FieldConvertors.h

@@ -22,14 +22,20 @@
 #ifndef FIX_FIELDCONVERTORS_H
 #define FIX_FIELDCONVERTORS_H
 
+#ifdef _MSC_VER
+#pragma warning( disable: 4146 )
+#endif
+
 #include "FieldTypes.h"
 #include "Exceptions.h"
 #include "Utility.h"
+#include "config-all.h"
 #include <string>
 #include <sstream>
 #include <iomanip>
 #include <cstdio>
 #include <limits>
+#include <iterator>
 
 namespace FIX
 {
@@ -37,7 +43,7 @@ namespace FIX
 typedef int signed_int;
 typedef unsigned int unsigned_int;
 
-#define UNSIGNED_VALUE_OF( x ) unsigned_int( x < 0 ? -x : x )
+#define UNSIGNED_VALUE_OF( x ) ( ( x < 0 ) ? -unsigned_int(x) : unsigned_int(x) )
 
 #define IS_SPACE( x ) ( x == ' ' )
 #define IS_DIGIT( x ) ( unsigned_int( x - '0' ) < 10 )
@@ -95,22 +101,21 @@ inline char* integer_to_string( char* buf, const size_t len, signed_int t )
   const bool isNegative = t < 0;
   char* p = buf + len;
 
-  *--p = '\0';
-  
   unsigned_int number = UNSIGNED_VALUE_OF( t );
 
   while( number > 99 )
   {
     unsigned_int pos = number % 100;
     number /= 100;
-    p -= 2;
-    *(short*)(p) = *(short*)(digit_pairs + 2 * pos);
+
+    *--p = digit_pairs[2 * pos + 1];
+    *--p = digit_pairs[2 * pos];
   }
 
   if( number > 9 )
   {
-    p -= 2;
-    *(short*)(p) = *(short*)(digit_pairs + 2 * number);
+    *--p = digit_pairs[2 * number + 1];
+    *--p = digit_pairs[2 * number];
   }
   else
   {
@@ -125,16 +130,10 @@ inline char* integer_to_string( char* buf, const size_t len, signed_int t )
 
 inline char* integer_to_string_padded
 ( char* buf, const size_t len, signed_int t,
-  const size_t width = 0,
   const char paddingChar = '0')
 {
   char* p = integer_to_string( buf, len, t );
-  if( !width ) 
-    return p;
-
-  const char* stop_p = buf + len - width - 1;
-  if( stop_p < buf ) stop_p = buf;
-  while( p > stop_p )
+  while( p > buf )
     *--p = paddingChar;
   return p;
 }
@@ -155,10 +154,10 @@ struct IntConvertor
   {
     // buffer is big enough for significant digits and extra digit,
     // minus and null
-    char buffer[std::numeric_limits<signed_int>::digits10 + 3];
+    char buffer[std::numeric_limits<signed_int>::digits10 + 2];
     const char* const start
       = integer_to_string( buffer, sizeof (buffer), value );
-    return std::string( start, buffer + sizeof (buffer) - start - 1 );
+    return std::string( start, buffer + sizeof (buffer) - start );
   }
 
   static bool convert(     
@@ -187,7 +186,7 @@ struct IntConvertor
     } while ( ++str != end );
 
     if( isNegative )
-      x = -x;
+      x = -unsigned_int(x);
 
     result = x;
     return true;
@@ -207,70 +206,6 @@ struct IntConvertor
     else
       return result;
   }
-
-  /// Converts only positive number e.g. FIX field ID: [1 ... 2147483647]
-  /// No leading whitespace/zero/plus/sign symbols allowed
-  /// Value is fixed to not make difference between 32bit and 64bit code
-  static bool convertPositive( 
-    std::string::const_iterator str, 
-    std::string::const_iterator end, 
-    signed_int& result )
-  {
-    const int MAX_VALUE = 2147483647; // max value for 32-bit signed integer
-    const int HIGH_MARK = MAX_VALUE / 10;
-    const unsigned_int STOP_SYMBOL = MAX_VALUE % 10;
-    const std::size_t MAX_DIGITS = 10;     // integer can hold up to 10 digits
-
-    const std::size_t length = std::distance( str, end );
-    if( length < 1 || length > MAX_DIGITS)
-      return false;
-
-    if( length == MAX_DIGITS )
-    {
-      end = str;
-      std::advance( end, length - 1 );
-    }
-
-    const unsigned_int ch = *str - '1';
-    if( ch > 8 )
-      return false;
-
-    unsigned_int x = 0;
-
-    do
-    {
-      const unsigned_int c = *str - '0';
-      if( c > 9 ) return false;
-      x = 10 * x + c;
-    } while( ++str < end );
-
-    // complete overflow condition check and value calculation
-    // this saves about 25% of speed when executed out of the main loop
-    if( length == MAX_DIGITS )
-    {
-      if( x > (unsigned int)HIGH_MARK )
-        return false;
-
-      const unsigned_int c = *str - '0';
-      if( x == (unsigned int)HIGH_MARK && c > STOP_SYMBOL )
-        return false;
-
-      x = 10 * x + c;
-    }
-
-    result = x;
-    return true;
-  }
-
-  static signed_int convertPositive( const std::string& value )
-  throw( FieldConvertError )
-  {
-    signed_int result = 0;
-    if( !convertPositive( value.begin(), value.end(), result ) )
-      throw FieldConvertError(value);
-    else
-      return result;
-  }
 };
 
 /// Converts checksum to/from a string
@@ -280,12 +215,12 @@ struct CheckSumConvertor
   throw( FieldConvertError )
   {
     if ( value > 255 || value < 0 ) throw FieldConvertError();
-    char result[4];
-    if( integer_to_string_padded(result, sizeof(result), value, 3) != result )
+    char result[3];
+    if( integer_to_string_padded(result, sizeof(result), value) != result )
     {
       throw FieldConvertError();
     }
-    return std::string( result, 3 );
+    return std::string( result, sizeof( result ) );
   }
 
   static bool convert( const std::string& value, int& result )
@@ -306,107 +241,28 @@ struct DoubleConvertor
 
 private:
 
-  /*Simple and fast atof (ascii to float) function.
-  Executes about 5x faster than standard MSCRT library atof().
-  An attractive alternative if the number of calls is in the millions.
-  Assumes input is a proper integer, fraction, or scientific format.
-  Matches library atof() to 15 digits (except at extreme exponents).
-  Follows atof() precedent of essentially no error checking.
-  09-May-2009 Tom Van Baak (tvb) www.LeapSecond.com */
-  static double fast_atof (const char *p)
-  {
-    bool frac(false);
-    double sign(1.), value(0.), scale(1.);
-
-    while (IS_SPACE(*p))
-      ++p;
-
-    // Get sign, if any.
-    if (*p == '-')
-    {
-      sign = -1.;
-      ++p;
-    }
-    else if (*p == '+')
-      ++p;
-
-    // Get digits before decimal point or exponent, if any.
-    while (IS_DIGIT(*p))
-    {
-      value = value * 10. + (*p - '0');
-      ++p;
-    }
-
-    // Get digits after decimal point, if any.
-    if (*p == '.')
-    {
-      ++p;
-      double pow10(10.);
-      while (IS_DIGIT(*p))
-      {
-        value += (*p - '0') / pow10;
-        pow10 *= 10.;
-        ++p;
-      }
-    }
-
-    // Handle exponent, if any.
-    if (toupper(*p) == 'E')
-    {
-      unsigned int expon(0);
-      ++p;
-
-      // Get sign of exponent, if any.
-      if (*p == '-')
-      {
-        frac = true;
-        ++p;
-      }
-      else if (*p == '+')
-        ++p;
-
-      // Get digits of exponent, if any.
-      while (IS_DIGIT(*p))
-      {
-        expon = expon * 10 + (*p - '0');
-        ++p;
-      }
-      if (expon > 308)
-        expon = 308;
+  static double fast_strtod( const char * buffer, int size, int * processed_chars );
 
-      // Calculate scaling factor.
-      while (expon >= 50)
-      {
-        scale *= 1E50;
-        expon -= 50;
-      }
-      while (expon >= 8)
-      {
-        scale *= 1E8;
-        expon -=  8;
-      }
-      while (expon > 0)
-      {
-        scale *= 10.0;
-        expon -=  1;
-      }
-    }
+  static int fast_dtoa( char * buffer, int size, double value );
 
-    // Return signed and scaled floating point result.
-    return sign * (frac ? (value / scale) : (value * scale));
-  }
+  static int fast_fixed_dtoa( char * buffer, int size, double value ); 
 
 public:
 
+  static const int SIGNIFICANT_DIGITS = 15;
+  static const int BUFFFER_SIZE = 32;
+
   static std::string convert( double value, int padding = 0 )
   {
-    char result[32];
+    char result[BUFFFER_SIZE];
     char *end = 0;
 
     int size;
-    if( value == 0 || value > 0.0001 || value <= -0.0001 )
+    if( value == 0 || value > 0.0001 || value < -0.0001 )
     {
-      size = STRING_SPRINTF( result, "%.15g", value );
+      size = fast_dtoa( result, BUFFFER_SIZE, value ); 
+      if( size == 0 )
+        return std::string();
 
       if( padding > 0 )
       {
@@ -419,42 +275,44 @@ public:
         {
           end = point;
           *point = '.';
-          size++;
+          ++size;
         }
         int needed = padding - (int)(end - point);
 
-        while( needed-- > 0 )
+        if( needed > 0 )
         {
-          *(++end) = '0';
-          size++;
+          memset( ++end, '0', needed );
+          size += needed;
         }
-        *(end+1) = 0;
       }
     }
     else
     {
-      size = STRING_SPRINTF( result, "%.15f", value );
+      size = fast_fixed_dtoa( result, BUFFFER_SIZE, value );
+      if( size == 0 )
+        return std::string();
+
       // strip trailing 0's
       end = result + size - 1;
 
       if( padding > 0 )
       {
-        int discard = 15 - padding;
+        int discard = SIGNIFICANT_DIGITS - padding;
 
         while( (*end == '0') && (discard-- > 0) )
         {
-          *(end--) = 0;
-          size--;
+          --end;
+          --size;
+        }
+      }
+      else
+      {
+        while( *end == '0' )
+        {
+          --end;
+          --size;
         }
-     }
-     else
-     {
-       while( *end == '0' )
-       {
-         *(end--) = 0;
-         size--;
-       }
-     }
+      }
    }
 
    return std::string( result, size );
@@ -485,10 +343,20 @@ static bool convert( const std::string& value, double& result )
 
   if( *i || !haveDigit ) return false;
     
-  result = fast_atof( value.c_str() );
-  return true;
+  int processed_chars;
+  const int total_length = value.length();
+  const double val = fast_strtod( value.c_str(), total_length, &processed_chars);
+
+  if ( processed_chars != total_length ||
+     val != val /*test for quite NaN*/ )
+  {
+    return false;
   }
 
+  result = val;
+  return true;
+}
+
   static double convert( const std::string& value )
   throw( FieldConvertError )
   {
@@ -564,52 +432,45 @@ struct BoolConvertor
 struct UtcTimeStampConvertor
 {
   static std::string convert( const UtcTimeStamp& value,
-                              bool showMilliseconds = false )
+                              int precision = 0 )
   throw( FieldConvertError )
   {
-    char result[ 18+4 ];
-    int year, month, day, hour, minute, second, millis;
+    char result[ 17+10 ]; // Maximum
+    int year, month, day, hour, minute, second, fraction;
 
     value.getYMD( year, month, day );
-    value.getHMS( hour, minute, second, millis );
+    value.getHMS( hour, minute, second, fraction, precision );
 
-    integer_to_string_padded( result, 5, year, 4 );
-    integer_to_string_padded( result + 4, 3, month, 2 );
-    integer_to_string_padded( result + 6, 3, day, 2 );
+    integer_to_string_padded( result, 4, year);
+    integer_to_string_padded( result + 4, 2, month );
+    integer_to_string_padded( result + 6, 2, day );
     result[8]  = '-';
-    integer_to_string_padded( result + 9, 3, hour, 2 );
+    integer_to_string_padded( result + 9, 2, hour);
     result[11] = ':';
-    integer_to_string_padded( result + 12, 3, minute, 2 );
+    integer_to_string_padded( result + 12, 2, minute);
     result[14] = ':';
-    integer_to_string_padded( result + 15, 3, second, 2 );
+    integer_to_string_padded( result + 15, 2, second);
 
-    if( showMilliseconds )
+    if( precision )
     {
       result[17] = '.';
-      if( integer_to_string_padded ( result + 18, 4, millis, 3 )
+      if( integer_to_string_padded ( result + 18, precision, fraction )
           != result + 18 )
       {
         throw FieldConvertError();
       }
     }
 
-    return result;
+    return std::string(result, precision ? (17 + 1 + precision) : 17);
   }
 
-  static UtcTimeStamp convert( const std::string& value,
-                               bool calculateDays = false )
+  static UtcTimeStamp convert( const std::string& value )
   throw( FieldConvertError )
   {
-    bool haveMilliseconds = false;
+    size_t len = value.size();
+    if (len < 17 || len > 27) throw FieldConvertError(value);
 
-    switch( value.size() )
-    {
-      case 21: haveMilliseconds = true;
-      case 17: break;
-      default: throw FieldConvertError(value);
-    }
-
-    int i = 0;
+    size_t i = 0;
     int c = 0;
     for( c = 0; c < 8; ++c )
       if( !IS_DIGIT(value[i++]) ) throw FieldConvertError(value);
@@ -623,14 +484,7 @@ struct UtcTimeStampConvertor
     for( c = 0; c < 2; ++c )
       if( !IS_DIGIT(value[i++]) ) throw FieldConvertError(value);
 
-    if( haveMilliseconds )
-    {
-      if( value[i++] != '.' ) throw FieldConvertError(value);
-      for( c = 0; c < 3; ++c )
-        if( !IS_DIGIT(value[i++]) ) throw FieldConvertError(value);
-    }
-
-    int year, mon, mday, hour, min, sec, millis;
+    int year, mon, mday, hour, min, sec;
 
     i = 0;
 
@@ -669,17 +523,22 @@ struct UtcTimeStampConvertor
     // No check for >= 0 as no '-' are converted here
     if( 60 < sec ) throw FieldConvertError(value);
 
-    if( haveMilliseconds )
+    if (len == 17)
+      return UtcTimeStamp (hour, min, sec, 0,
+                           mday, mon, year);
+
+    if( value[i++] != '.' ) throw FieldConvertError(value);
+
+    int fraction = 0;
+    for (; i < len; ++i)
     {
-      millis = (100 * (value[i+1] - '0')
-                + 10 * (value[i+2] - '0')
-                + (value[i+3] - '0'));
+      char ch = value[i];
+      if( !IS_DIGIT(ch)) throw FieldConvertError(value);
+      fraction = (fraction * 10) + ch - '0';
     }
-    else
-      millis = 0;
 
-    return UtcTimeStamp (hour, min, sec, millis,
-                         mday, mon, year);
+    return UtcTimeStamp (hour, min, sec, fraction,
+                         mday, mon, year, len - 17 - 1);
   }
 };
 
@@ -687,44 +546,38 @@ struct UtcTimeStampConvertor
 struct UtcTimeOnlyConvertor
 {
   static std::string convert( const UtcTimeOnly& value,
-                              bool showMilliseconds = false)
+                              int precision = 0 )
   throw( FieldConvertError )
   {
-    char result[ 9+4 ];
-    int hour, minute, second, millis;
+    char result[ 8+10 ]; // Maximum
+    int hour, minute, second, fraction;
 
-    value.getHMS( hour, minute, second, millis );
+    value.getHMS( hour, minute, second, fraction, precision );
 
-    integer_to_string_padded ( result, 3, hour, 2 );
+    integer_to_string_padded ( result, 2, hour );
     result[2] = ':';
-    integer_to_string_padded ( result + 3, 3, minute,  2 );
+    integer_to_string_padded ( result + 3, 2, minute );
     result[5] = ':';
-    integer_to_string_padded ( result + 6, 3, second,  2 );
+    integer_to_string_padded ( result + 6, 2, second );
 
-    if( showMilliseconds )
+    if( precision )
     {
       result[8] = '.';
-      if( integer_to_string_padded ( result + 9, 4, millis, 3 )
+      if( integer_to_string_padded ( result + 9, precision, fraction )
           != result + 9 )
           throw FieldConvertError();
     }
 
-    return result;
+    return std::string(result, precision ? (8 + 1 + precision) : 8);
   }
 
-  static UtcTimeOnly convert( const std::string& value )
+  static UtcTimeOnly convert( const std::string& value)
   throw( FieldConvertError )
   {
-    bool haveMilliseconds = false;
+    size_t len = value.size();
+    if (len < 8 || len > 18) throw FieldConvertError(value);
 
-    switch( value.size() )
-    {
-      case 12: haveMilliseconds = true;
-      case 8: break;
-      default: throw FieldConvertError(value);
-    }
-
-    int i = 0;
+    size_t i = 0;
     int c = 0;
     for( c = 0; c < 2; ++c )
       if( !IS_DIGIT(value[i++]) ) throw FieldConvertError(value);
@@ -735,44 +588,44 @@ struct UtcTimeOnlyConvertor
     for( c = 0; c < 2; ++c )
       if( !IS_DIGIT(value[i++]) ) throw FieldConvertError(value);
 
-    if( haveMilliseconds )
-    {
-      // ++i instead of i++ skips the '.' separator
-      for( c = 0; c < 3; ++c )
-        if( !IS_DIGIT(value[++i]) ) throw FieldConvertError(value);
-    }
+    int hour, min, sec;
 
-    int hour, min, sec, millis;
- 
     i = 0;
 
     hour = value[i++] - '0';
     hour = 10 * hour + value[i++] - '0';
     // No check for >= 0 as no '-' are converted here
     if( 23 < hour ) throw FieldConvertError(value);
+
     ++i; // skip ':'
 
     min = value[i++] - '0';
     min = 10 * min + value[i++] - '0';
     // No check for >= 0 as no '-' are converted here
     if( 59 < min ) throw FieldConvertError(value);
+
     ++i; // skip ':'
 
     sec = value[i++] - '0';
     sec = 10 * sec + value[i++] - '0';
+
     // No check for >= 0 as no '-' are converted here
     if( 60 < sec ) throw FieldConvertError(value);
 
-    if( haveMilliseconds )
+    if (len == 8)
+      return UtcTimeOnly (hour, min, sec, 0);
+
+    if( value[i++] != '.' ) throw FieldConvertError(value);
+
+    int fraction = 0;
+    for (; i < len; ++i)
     {
-      millis = (100 * (value[i+1] - '0')
-                + 10 * (value[i+2] - '0')
-                + (value[i+3] - '0'));
+      char ch = value[i];
+      if( !IS_DIGIT(ch)) throw FieldConvertError(value);
+      fraction = (fraction * 10) + ch - '0';
     }
-    else
-      millis = 0;
 
-    return UtcTimeOnly( hour, min, sec, millis );
+    return UtcTimeOnly (hour, min, sec, fraction, len - 8 - 1);
   }
 };
 
@@ -782,15 +635,16 @@ struct UtcDateConvertor
   static std::string convert( const UtcDate& value )
   throw( FieldConvertError )
   {
-    char result[ 9 ];
     int year, month, day;
-
     value.getYMD( year, month, day );
 
-    integer_to_string_padded( result, 5, year, 4 );
-    integer_to_string_padded( result + 4, 3, month, 2 );
-    integer_to_string_padded( result + 6, 3, day, 2 );
-    return result;
+    char result[ 8 ];
+
+    integer_to_string_padded( result, 4, year );
+    integer_to_string_padded( result + 4, 2, month );
+    integer_to_string_padded( result + 6, 2, day );
+
+    return std::string( result, sizeof( result ) );
   }
 
   static UtcDate convert( const std::string& value )