tickserver/api/gofix/include/quickfix/FieldConvertors.h

/* -*- C++ -*- */

/****************************************************************************
** 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.
**
****************************************************************************/

#ifndef FIX_FIELDCONVERTORS_H
#define FIX_FIELDCONVERTORS_H

#include "FieldTypes.h"
#include "Exceptions.h"
#include "Utility.h"
#include <string>
#include <sstream>
#include <iomanip>
#include <cstdio>
#include <limits>

namespace FIX
{

typedef int signed_int;
typedef unsigned int unsigned_int;

#define UNSIGNED_VALUE_OF( x ) unsigned_int( x < 0 ? -x : x )

#define IS_SPACE( x ) ( x == ' ' )
#define IS_DIGIT( x ) ( unsigned_int( x - '0' ) < 10 )

inline int number_of_symbols_in( const signed_int value )
{
  unsigned_int number = UNSIGNED_VALUE_OF( value );

  int symbols = 0;

  while( number > 9999 )
  {
    symbols += 4;
    number /= 10000;
  }

  // small tweak to make comparison times consistent
  // always 2 comparisons instead of [1 - 4]
  if( number > 99 )
  {
    if( number > 999 )
      symbols += 4;
    else
      symbols += 3;
  }
  else
  {
    if( number > 9 )
      symbols += 2;
    else
      symbols += 1;
  }

  if( value < 0 )
    symbols += 1;

  return symbols;
}

static const char digit_pairs[201] = {
  "00010203040506070809"
  "10111213141516171819"
  "20212223242526272829"
  "30313233343536373839"
  "40414243444546474849"
  "50515253545556575859"
  "60616263646566676869"
  "70717273747576777879"
  "80818283848586878889"
  "90919293949596979899"
};

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);
  }

  if( number > 9 )
  {
    p -= 2;
    *(short*)(p) = *(short*)(digit_pairs + 2 * number);
  }
  else
  {
    *--p = '0' + char(number);
  }

  if( isNegative )
    *--p = '-';

  return p;
}

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 )
    *--p = paddingChar;
  return p;
}

/// Empty converter is a no-op.
struct EmptyConvertor
{
  static const std::string& convert( const std::string& value )
  { return value; }
};

typedef EmptyConvertor StringConvertor;

/// Converts integer to/from a string
struct IntConvertor
{
  static std::string convert( signed_int value )
  {
    // buffer is big enough for significant digits and extra digit,
    // minus and null
    char buffer[std::numeric_limits<signed_int>::digits10 + 3];
    const char* const start
      = integer_to_string( buffer, sizeof (buffer), value );
    return std::string( start, buffer + sizeof (buffer) - start - 1 );
  }

  static bool convert(     
    std::string::const_iterator str, 
    std::string::const_iterator end, 
    signed_int& result )
  {
    bool isNegative = false;
    signed_int x = 0;

    if( str == end )
      return false;

    if( *str == '-' )
    {
      isNegative = true;
      if( ++str == end )
        return false;
    }

    do
    {
      const unsigned_int c = *str - '0';
      if( c > 9 ) return false;
      x = 10 * x + c;
    } while ( ++str != end );

    if( isNegative )
      x = -x;

    result = x;
    return true;
  }

  static bool convert( const std::string& value, signed_int& result )
  {
    return convert( value.begin(), value.end(), result );
  }

  static signed_int convert( const std::string& value )
  throw( FieldConvertError )
  {
    signed_int result = 0;
    if( !convert( value.begin(), value.end(), result ) )
      throw FieldConvertError(value);
    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
struct CheckSumConvertor
{
  static std::string convert( int value )
  throw( FieldConvertError )
  {
    if ( value > 255 || value < 0 ) throw FieldConvertError();
    char result[4];
    if( integer_to_string_padded(result, sizeof(result), value, 3) != result )
    {
      throw FieldConvertError();
    }
    return std::string( result, 3 );
  }

  static bool convert( const std::string& value, int& result )
  {
    return IntConvertor::convert( value, result );
  }

  static int convert( const std::string& value )
  throw( FieldConvertError )
  {
    return IntConvertor::convert( value );
  }
};

/// Converts double to/from a string
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;

      // 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;
      }
    }

    // Return signed and scaled floating point result.
    return sign * (frac ? (value / scale) : (value * scale));
  }

public:

  static std::string convert( double value, int padding = 0 )
  {
    char result[32];
    char *end = 0;

    int size;
    if( value == 0 || value > 0.0001 || value <= -0.0001 )
    {
      size = STRING_SPRINTF( result, "%.15g", value );

      if( padding > 0 )
      {
        char* point = result;
        end = result + size - 1;
        while( *point != '.' && *point != 0 )
          point++;

        if( *point == 0 )
        {
          end = point;
          *point = '.';
          size++;
        }
        int needed = padding - (int)(end - point);

        while( needed-- > 0 )
        {
          *(++end) = '0';
          size++;
        }
        *(end+1) = 0;
      }
    }
    else
    {
      size = STRING_SPRINTF( result, "%.15f", value );
      // strip trailing 0's
      end = result + size - 1;

      if( padding > 0 )
      {
        int discard = 15 - padding;

        while( (*end == '0') && (discard-- > 0) )
        {
          *(end--) = 0;
          size--;
        }
     }
     else
     {
       while( *end == '0' )
       {
         *(end--) = 0;
         size--;
       }
     }
   }

   return std::string( result, size );
}

static bool convert( const std::string& value, double& result )
{
  const char * i = value.c_str();

  // Catch null strings
  if( !*i ) return false;
  // Eat leading '-' and recheck for null string
  if( *i == '-' && !*++i ) return false;

  bool haveDigit = false;

  if( IS_DIGIT(*i) )
  {
    haveDigit = true;
    while( IS_DIGIT (*++i) );
  }

  if( *i == '.' && IS_DIGIT(*++i) )
  {
    haveDigit = true;
    while( IS_DIGIT (*++i) );
  }

  if( *i || !haveDigit ) return false;
    
  result = fast_atof( value.c_str() );
  return true;
  }

  static double convert( const std::string& value )
  throw( FieldConvertError )
  {
    double result = 0.0;
    if( !convert( value, result ) )
      throw FieldConvertError(value);
    else
      return result;
  }
};

/// Converts character to/from a string
struct CharConvertor
{
  static std::string convert( char value )
  {
    if( value == '\0' ) return "";
    return std::string( 1, value );
  }

  static bool convert( const std::string& value, char& result )
  {
    if( value.size() != 1 ) return false;
    result = value[0];
    return true;
  }

  static char convert( const std::string& value )
  throw( FieldConvertError )
  {
    char result = '\0';
    if( !convert( value, result ) )
      throw FieldConvertError(value);
    else
      return result;
  }
};

/// Converts boolean to/from a string
struct BoolConvertor
{
  static std::string convert( bool value )
  {
    const char ch = value ? 'Y' : 'N';
    return std::string( 1, ch );
  }

  static bool convert( const std::string& value, bool& result )
  {
    if( value.size() != 1 ) return false;
    switch( value[0] )
    {
      case 'Y': result = true; break;
      case 'N': result = false; break;
      default: return false;
    }

    return true;
  }

  static bool convert( const std::string& value )
  throw( FieldConvertError )
  {
    bool result = false;
    if( !convert( value, result ) )
      throw FieldConvertError(value);
    else
      return result;
  }
};

/// Converts a UtcTimeStamp to/from a string
struct UtcTimeStampConvertor
{
  static std::string convert( const UtcTimeStamp& value,
                              bool showMilliseconds = false )
  throw( FieldConvertError )
  {
    char result[ 18+4 ];
    int year, month, day, hour, minute, second, millis;

    value.getYMD( year, month, day );
    value.getHMS( hour, minute, second, millis );

    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 );
    result[8]  = '-';
    integer_to_string_padded( result + 9, 3, hour, 2 );
    result[11] = ':';
    integer_to_string_padded( result + 12, 3, minute, 2 );
    result[14] = ':';
    integer_to_string_padded( result + 15, 3, second, 2 );

    if( showMilliseconds )
    {
      result[17] = '.';
      if( integer_to_string_padded ( result + 18, 4, millis, 3 )
          != result + 18 )
      {
        throw FieldConvertError();
      }
    }

    return result;
  }

  static UtcTimeStamp convert( const std::string& value,
                               bool calculateDays = false )
  throw( FieldConvertError )
  {
    bool haveMilliseconds = false;

    switch( value.size() )
    {
      case 21: haveMilliseconds = true;
      case 17: break;
      default: throw FieldConvertError(value);
    }

    int i = 0;
    int c = 0;
    for( c = 0; c < 8; ++c )
      if( !IS_DIGIT(value[i++]) ) throw FieldConvertError(value);
    if (value[i++] != '-') throw FieldConvertError(value);
    for( c = 0; c < 2; ++c )
      if( !IS_DIGIT(value[i++]) ) throw FieldConvertError(value);
    if( value[i++] != ':' ) throw FieldConvertError(value);
    for( c = 0; c < 2; ++c )
      if( !IS_DIGIT(value[i++]) ) throw FieldConvertError(value);
    if( value[i++] != ':' ) throw FieldConvertError(value);
    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;

    i = 0;

    year = value[i++] - '0';
    year = 10 * year + value[i++] - '0';
    year = 10 * year + value[i++] - '0';
    year = 10 * year + value[i++] - '0';

    mon = value[i++] - '0';
    mon = 10 * mon + value[i++] - '0';
    if( mon < 1 || 12 < mon ) throw FieldConvertError(value);

    mday = value[i++] - '0';
    mday = 10 * mday + value[i++] - '0';
    if( mday < 1 || 31 < mday ) throw FieldConvertError(value);

    ++i; // skip '-'

    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 )
    {
      millis = (100 * (value[i+1] - '0')
                + 10 * (value[i+2] - '0')
                + (value[i+3] - '0'));
    }
    else
      millis = 0;

    return UtcTimeStamp (hour, min, sec, millis,
                         mday, mon, year);
  }
};

/// Converts a UtcTimeOnly to/from a string
struct UtcTimeOnlyConvertor
{
  static std::string convert( const UtcTimeOnly& value,
                              bool showMilliseconds = false)
  throw( FieldConvertError )
  {
    char result[ 9+4 ];
    int hour, minute, second, millis;

    value.getHMS( hour, minute, second, millis );

    integer_to_string_padded ( result, 3, hour, 2 );
    result[2] = ':';
    integer_to_string_padded ( result + 3, 3, minute,  2 );
    result[5] = ':';
    integer_to_string_padded ( result + 6, 3, second,  2 );

    if( showMilliseconds )
    {
      result[8] = '.';
      if( integer_to_string_padded ( result + 9, 4, millis, 3 )
          != result + 9 )
          throw FieldConvertError();
    }

    return result;
  }

  static UtcTimeOnly convert( const std::string& value )
  throw( FieldConvertError )
  {
    bool haveMilliseconds = false;

    switch( value.size() )
    {
      case 12: haveMilliseconds = true;
      case 8: break;
      default: throw FieldConvertError(value);
    }

    int i = 0;
    int c = 0;
    for( c = 0; c < 2; ++c )
      if( !IS_DIGIT(value[i++]) ) throw FieldConvertError(value);
    if( value[i++] != ':' ) throw FieldConvertError(value);
    for( c = 0; c < 2; ++c )
      if( !IS_DIGIT(value[i++]) ) throw FieldConvertError(value);
    if( value[i++] != ':' ) throw FieldConvertError(value);
    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, 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 )
    {
      millis = (100 * (value[i+1] - '0')
                + 10 * (value[i+2] - '0')
                + (value[i+3] - '0'));
    }
    else
      millis = 0;

    return UtcTimeOnly( hour, min, sec, millis );
  }
};

/// Converts a UtcDate to/from a string
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;
  }

  static UtcDate convert( const std::string& value )
  throw( FieldConvertError )
  {
    if( value.size() != 8 ) throw FieldConvertError(value);

    int i = 0;
    for( int c=0; c<8; ++c )
      if( !IS_DIGIT(value[i++]) ) throw FieldConvertError(value);

    int year, mon, mday;

    i = 0;

    year = value[i++] - '0';
    year = 10 * year + value[i++] - '0';
    year = 10 * year + value[i++] - '0';
    year = 10 * year + value[i++] - '0';

    mon = value[i++] - '0';
    mon = 10 * mon + value[i++] - '0';
    if( mon < 1 || 12 < mon )
      throw FieldConvertError(value);

    mday = value[i++] - '0';
    mday = 10 * mday + value[i++] - '0';
    if( mday < 1 || 31 < mday )
      throw FieldConvertError(value);

    return UtcDateOnly( mday, mon, year );
  }
};

typedef UtcDateConvertor UtcDateOnlyConvertor;

typedef StringConvertor STRING_CONVERTOR;
typedef CharConvertor CHAR_CONVERTOR;
typedef DoubleConvertor PRICE_CONVERTOR;
typedef IntConvertor INT_CONVERTOR;
typedef DoubleConvertor AMT_CONVERTOR;
typedef DoubleConvertor QTY_CONVERTOR;
typedef StringConvertor CURRENCY_CONVERTOR;
typedef StringConvertor MULTIPLEVALUESTRING_CONVERTOR;
typedef StringConvertor MULTIPLESTRINGVALUE_CONVERTOR;
typedef StringConvertor MULTIPLECHARVALUE_CONVERTOR;
typedef StringConvertor EXCHANGE_CONVERTOR;
typedef UtcTimeStampConvertor UTCTIMESTAMP_CONVERTOR;
typedef BoolConvertor BOOLEAN_CONVERTOR;
typedef StringConvertor LOCALMKTDATE_CONVERTOR;
typedef StringConvertor DATA_CONVERTOR;
typedef DoubleConvertor FLOAT_CONVERTOR;
typedef DoubleConvertor PRICEOFFSET_CONVERTOR;
typedef StringConvertor MONTHYEAR_CONVERTOR;
typedef StringConvertor DAYOFMONTH_CONVERTOR;
typedef UtcDateConvertor UTCDATE_CONVERTOR;
typedef UtcTimeOnlyConvertor UTCTIMEONLY_CONVERTOR;
typedef IntConvertor NUMINGROUP_CONVERTOR;
typedef DoubleConvertor PERCENTAGE_CONVERTOR;
typedef IntConvertor SEQNUM_CONVERTOR;
typedef IntConvertor LENGTH_CONVERTOR;
typedef StringConvertor COUNTRY_CONVERTOR;
typedef StringConvertor TZTIMEONLY_CONVERTOR;
typedef StringConvertor TZTIMESTAMP_CONVERTOR;
typedef StringConvertor XMLDATA_CONVERTOR;
typedef StringConvertor LANGUAGE_CONVERTOR;
typedef CheckSumConvertor CHECKSUM_CONVERTOR;
}

#endif //FIX_FIELDCONVERTORS_H