FieldConvertors.h
Go to the documentation of this file.
/* -*- 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
#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
{
typedef int signed_int;
typedef unsigned int unsigned_int;
#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 )
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;
unsigned_int number = UNSIGNED_VALUE_OF( t );
while( number > 99 )
{
unsigned_int pos = number % 100;
number /= 100;
*--p = digit_pairs[2 * pos + 1];
*--p = digit_pairs[2 * pos];
}
if( number > 9 )
{
*--p = digit_pairs[2 * number + 1];
*--p = 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 char paddingChar = '0')
{
char* p = integer_to_string( buf, len, t );
while( p > buf )
*--p = paddingChar;
return p;
}
struct EmptyConvertor
{
static const std::string& convert( const std::string& value )
{ return value; }
};
typedef EmptyConvertor StringConvertor;
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 + 2];
const char* const start
= integer_to_string( buffer, sizeof (buffer), value );
return std::string( start, buffer + sizeof (buffer) - start );
}
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 = -unsigned_int(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;
}
};
struct CheckSumConvertor
{
static std::string convert( int value )
throw( FieldConvertError )
{
if ( value > 255 || value < 0 ) throw FieldConvertError();
char result[3];
if( integer_to_string_padded(result, sizeof(result), value) != result )
{
throw FieldConvertError();
}
return std::string( result, sizeof( result ) );
}
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 );
}
};
struct DoubleConvertor
{
private:
static double fast_strtod( const char * buffer, int size, int * processed_chars );
static int fast_dtoa( char * buffer, int size, double value );
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[BUFFFER_SIZE];
char *end = 0;
int size;
if( value == 0 || value > 0.0001 || value < -0.0001 )
{
size = fast_dtoa( result, BUFFFER_SIZE, value );
if( size == 0 )
return std::string();
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);
if( needed > 0 )
{
memset( ++end, '0', needed );
size += needed;
}
}
}
else
{
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 = SIGNIFICANT_DIGITS - padding;
while( (*end == '0') && (discard-- > 0) )
{
--end;
--size;
}
}
else
{
while( *end == '0' )
{
--end;
--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;
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 )
{
double result = 0.0;
if( !convert( value, result ) )
throw FieldConvertError(value);
else
return result;
}
};
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;
}
};
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;
}
};
struct UtcTimeStampConvertor
{
static std::string convert( const UtcTimeStamp& value,
int precision = 0 )
throw( FieldConvertError )
{
char result[ 17+10 ]; // Maximum
int year, month, day, hour, minute, second, fraction;
value.getYMD( year, month, day );
value.getHMS( hour, minute, second, fraction, precision );
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, 2, hour);
result[11] = ':';
integer_to_string_padded( result + 12, 2, minute);
result[14] = ':';
integer_to_string_padded( result + 15, 2, second);
if( precision )
{
result[17] = '.';
if( integer_to_string_padded ( result + 18, precision, fraction )
!= result + 18 )
{
throw FieldConvertError();
}
}
return std::string(result, precision ? (17 + 1 + precision) : 17);
}
static UtcTimeStamp convert( const std::string& value )
throw( FieldConvertError )
{
size_t len = value.size();
if (len < 17 || len > 27) throw FieldConvertError(value);
size_t 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);
int year, mon, mday, hour, min, sec;
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 (len == 17)
return UtcTimeStamp (hour, min, sec, 0,
mday, mon, year);
if( value[i++] != '.' ) throw FieldConvertError(value);
int fraction = 0;
for (; i < len; ++i)
{
char ch = value[i];
if( !IS_DIGIT(ch)) throw FieldConvertError(value);
fraction = (fraction * 10) + ch - '0';
}
return UtcTimeStamp (hour, min, sec, fraction,
mday, mon, year, len - 17 - 1);
}
};
struct UtcTimeOnlyConvertor
{
static std::string convert( const UtcTimeOnly& value,
int precision = 0 )
throw( FieldConvertError )
{
char result[ 8+10 ]; // Maximum
int hour, minute, second, fraction;
value.getHMS( hour, minute, second, fraction, precision );
integer_to_string_padded ( result, 2, hour );
result[2] = ':';
integer_to_string_padded ( result + 3, 2, minute );
result[5] = ':';
integer_to_string_padded ( result + 6, 2, second );
if( precision )
{
result[8] = '.';
if( integer_to_string_padded ( result + 9, precision, fraction )
!= result + 9 )
throw FieldConvertError();
}
return std::string(result, precision ? (8 + 1 + precision) : 8);
}
static UtcTimeOnly convert( const std::string& value)
throw( FieldConvertError )
{
size_t len = value.size();
if (len < 8 || len > 18) throw FieldConvertError(value);
size_t 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);
int hour, min, sec;
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 (len == 8)
return UtcTimeOnly (hour, min, sec, 0);
if( value[i++] != '.' ) throw FieldConvertError(value);
int fraction = 0;
for (; i < len; ++i)
{
char ch = value[i];
if( !IS_DIGIT(ch)) throw FieldConvertError(value);
fraction = (fraction * 10) + ch - '0';
}
return UtcTimeOnly (hour, min, sec, fraction, len - 8 - 1);
}
};
struct UtcDateConvertor
{
static std::string convert( const UtcDate& value )
throw( FieldConvertError )
{
int year, month, day;
value.getYMD( year, month, day );
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 )
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
Exceptions.h
IS_DIGIT
#define IS_DIGIT(x)
Definition: FieldConvertors.h:49
UNSIGNED_VALUE_OF
#define UNSIGNED_VALUE_OF(x)
Definition: FieldConvertors.h:46
FieldTypes.h
Utility.h
FIX::UtcDate
Date only represented in UTC.
Definition: FieldTypes.h:801
FIX::UtcTimeOnly
Time only represented in UTC.
Definition: FieldTypes.h:685
FIX::UtcTimeStamp
Date and Time represented in UTC.
Definition: FieldTypes.h:583
config-all.h
FIX::TYPE::UtcTimeOnly
@ UtcTimeOnly
Definition: FieldTypes.h:933
FIX::TYPE::UtcTimeStamp
@ UtcTimeStamp
Definition: FieldTypes.h:923
FIX
Definition: Acceptor.cpp:35
FIX::integer_to_string
char * integer_to_string(char *buf, const size_t len, signed_int t)
Definition: FieldConvertors.h:99
FIX::unsigned_int
unsigned int unsigned_int
Definition: FieldConvertors.h:44
FIX::LOCALMKTDATE_CONVERTOR
StringConvertor LOCALMKTDATE_CONVERTOR
Definition: FieldConvertors.h:697
FIX::INT_CONVERTOR
IntConvertor INT_CONVERTOR
Definition: FieldConvertors.h:687
FIX::integer_to_string_padded
char * integer_to_string_padded(char *buf, const size_t len, signed_int t, const char paddingChar='0')
Definition: FieldConvertors.h:132
FIX::digit_pairs
static const char digit_pairs[201]
Definition: FieldConvertors.h:86
FIX::MULTIPLECHARVALUE_CONVERTOR
StringConvertor MULTIPLECHARVALUE_CONVERTOR
Definition: FieldConvertors.h:693
FIX::EXCHANGE_CONVERTOR
StringConvertor EXCHANGE_CONVERTOR
Definition: FieldConvertors.h:694
FIX::MULTIPLESTRINGVALUE_CONVERTOR
StringConvertor MULTIPLESTRINGVALUE_CONVERTOR
Definition: FieldConvertors.h:692
FIX::CHECKSUM_CONVERTOR
CheckSumConvertor CHECKSUM_CONVERTOR
Definition: FieldConvertors.h:714
FIX::FLOAT_CONVERTOR
DoubleConvertor FLOAT_CONVERTOR
Definition: FieldConvertors.h:699
FIX::QTY_CONVERTOR
DoubleConvertor QTY_CONVERTOR
Definition: FieldConvertors.h:689
FIX::MULTIPLEVALUESTRING_CONVERTOR
StringConvertor MULTIPLEVALUESTRING_CONVERTOR
Definition: FieldConvertors.h:691
FIX::PRICE_CONVERTOR
DoubleConvertor PRICE_CONVERTOR
Definition: FieldConvertors.h:686
FIX::signed_int
int signed_int
Definition: FieldConvertors.h:43
FIX::StringConvertor
EmptyConvertor StringConvertor
Definition: FieldConvertors.h:148
FIX::UtcDateOnlyConvertor
UtcDateConvertor UtcDateOnlyConvertor
Definition: FieldConvertors.h:682
FIX::XMLDATA_CONVERTOR
StringConvertor XMLDATA_CONVERTOR
Definition: FieldConvertors.h:712
FIX::COUNTRY_CONVERTOR
StringConvertor COUNTRY_CONVERTOR
Definition: FieldConvertors.h:709
FIX::TZTIMEONLY_CONVERTOR
StringConvertor TZTIMEONLY_CONVERTOR
Definition: FieldConvertors.h:710
FIX::STRING_CONVERTOR
StringConvertor STRING_CONVERTOR
Definition: FieldConvertors.h:684
FIX::CHAR_CONVERTOR
CharConvertor CHAR_CONVERTOR
Definition: FieldConvertors.h:685
FIX::UTCTIMESTAMP_CONVERTOR
UtcTimeStampConvertor UTCTIMESTAMP_CONVERTOR
Definition: FieldConvertors.h:695
FIX::NUMINGROUP_CONVERTOR
IntConvertor NUMINGROUP_CONVERTOR
Definition: FieldConvertors.h:705
FIX::CURRENCY_CONVERTOR
StringConvertor CURRENCY_CONVERTOR
Definition: FieldConvertors.h:690
FIX::PRICEOFFSET_CONVERTOR
DoubleConvertor PRICEOFFSET_CONVERTOR
Definition: FieldConvertors.h:700
FIX::TZTIMESTAMP_CONVERTOR
StringConvertor TZTIMESTAMP_CONVERTOR
Definition: FieldConvertors.h:711
FIX::MONTHYEAR_CONVERTOR
StringConvertor MONTHYEAR_CONVERTOR
Definition: FieldConvertors.h:701
FIX::DATA_CONVERTOR
StringConvertor DATA_CONVERTOR
Definition: FieldConvertors.h:698
FIX::BOOLEAN_CONVERTOR
BoolConvertor BOOLEAN_CONVERTOR
Definition: FieldConvertors.h:696
FIX::DAYOFMONTH_CONVERTOR
StringConvertor DAYOFMONTH_CONVERTOR
Definition: FieldConvertors.h:702
FIX::PERCENTAGE_CONVERTOR
DoubleConvertor PERCENTAGE_CONVERTOR
Definition: FieldConvertors.h:706
FIX::LENGTH_CONVERTOR
IntConvertor LENGTH_CONVERTOR
Definition: FieldConvertors.h:708
FIX::AMT_CONVERTOR
DoubleConvertor AMT_CONVERTOR
Definition: FieldConvertors.h:688
FIX::number_of_symbols_in
int number_of_symbols_in(const signed_int value)
Definition: FieldConvertors.h:51
FIX::SEQNUM_CONVERTOR
IntConvertor SEQNUM_CONVERTOR
Definition: FieldConvertors.h:707
FIX::UTCTIMEONLY_CONVERTOR
UtcTimeOnlyConvertor UTCTIMEONLY_CONVERTOR
Definition: FieldConvertors.h:704
FIX::LANGUAGE_CONVERTOR
StringConvertor LANGUAGE_CONVERTOR
Definition: FieldConvertors.h:713
FIX::UtcDateOnly
UtcDate UtcDateOnly
Definition: FieldTypes.h:873
FIX::UTCDATE_CONVERTOR
UtcDateConvertor UTCDATE_CONVERTOR
Definition: FieldConvertors.h:703
FIX::BoolConvertor
Converts boolean to/from a string.
Definition: FieldConvertors.h:400
FIX::BoolConvertor::convert
static bool convert(const std::string &value, bool &result)
Definition: FieldConvertors.h:407
FIX::BoolConvertor::convert
static bool convert(const std::string &value)
Definition: FieldConvertors.h:420
FIX::BoolConvertor::convert
static std::string convert(bool value)
Definition: FieldConvertors.h:401
FIX::CharConvertor
Converts character to/from a string.
Definition: FieldConvertors.h:373
FIX::CharConvertor::convert
static char convert(const std::string &value)
Definition: FieldConvertors.h:387
FIX::CharConvertor::convert
static bool convert(const std::string &value, char &result)
Definition: FieldConvertors.h:380
FIX::CharConvertor::convert
static std::string convert(char value)
Definition: FieldConvertors.h:374
FIX::CheckSumConvertor
Converts checksum to/from a string.
Definition: FieldConvertors.h:213
FIX::CheckSumConvertor::convert
static int convert(const std::string &value)
Definition: FieldConvertors.h:231
FIX::CheckSumConvertor::convert
static bool convert(const std::string &value, int &result)
Definition: FieldConvertors.h:226
FIX::CheckSumConvertor::convert
static std::string convert(int value)
Definition: FieldConvertors.h:214
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:211
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:218
FIX::DoubleConvertor
Converts double to/from a string.
Definition: FieldConvertors.h:240
FIX::DoubleConvertor::fast_fixed_dtoa
static int fast_fixed_dtoa(char *buffer, int size, double value)
Definition: FieldConvertors.cpp:81
FIX::DoubleConvertor::BUFFFER_SIZE
static const int BUFFFER_SIZE
Definition: FieldConvertors.h:253
FIX::DoubleConvertor::fast_strtod
static double fast_strtod(const char *buffer, int size, int *processed_chars)
Definition: FieldConvertors.cpp:63
FIX::DoubleConvertor::fast_dtoa
static int fast_dtoa(char *buffer, int size, double value)
Definition: FieldConvertors.cpp:68
FIX::DoubleConvertor::convert
static bool convert(const std::string &value, double &result)
Definition: FieldConvertors.h:321
FIX::DoubleConvertor::convert
static double convert(const std::string &value)
Definition: FieldConvertors.h:360
FIX::DoubleConvertor::convert
static std::string convert(double value, int padding=0)
Definition: FieldConvertors.h:255
FIX::DoubleConvertor::SIGNIFICANT_DIGITS
static const int SIGNIFICANT_DIGITS
Definition: FieldConvertors.h:252
FIX::EmptyConvertor
Empty converter is a no-op.
Definition: FieldConvertors.h:143
FIX::EmptyConvertor::convert
static const std::string & convert(const std::string &value)
Definition: FieldConvertors.h:144
FIX::FieldConvertError
Unable to convert field into its native format.
Definition: Exceptions.h:67
FIX::IntConvertor
Converts integer to/from a string.
Definition: FieldConvertors.h:152
FIX::IntConvertor::convert
static bool convert(std::string::const_iterator str, std::string::const_iterator end, signed_int &result)
Definition: FieldConvertors.h:163
FIX::IntConvertor::convert
static bool convert(const std::string &value, signed_int &result)
Definition: FieldConvertors.h:195
FIX::IntConvertor::convert
static std::string convert(signed_int value)
Definition: FieldConvertors.h:153
FIX::IntConvertor::convert
static signed_int convert(const std::string &value)
Definition: FieldConvertors.h:200
FIX::UtcDateConvertor
Converts a UtcDate to/from a string.
Definition: FieldConvertors.h:634
FIX::UtcDateConvertor::convert
static UtcDate convert(const std::string &value)
Definition: FieldConvertors.h:650
FIX::UtcDateConvertor::convert
static std::string convert(const UtcDate &value)
Definition: FieldConvertors.h:635
FIX::UtcTimeOnlyConvertor
Converts a UtcTimeOnly to/from a string.
Definition: FieldConvertors.h:547
FIX::UtcTimeOnlyConvertor::convert
static std::string convert(const UtcTimeOnly &value, int precision=0)
Definition: FieldConvertors.h:548
FIX::UtcTimeOnlyConvertor::convert
static UtcTimeOnly convert(const std::string &value)
Definition: FieldConvertors.h:574
FIX::UtcTimeStampConvertor
Converts a UtcTimeStamp to/from a string.
Definition: FieldConvertors.h:433
FIX::UtcTimeStampConvertor::convert
static UtcTimeStamp convert(const std::string &value)
Definition: FieldConvertors.h:467
FIX::UtcTimeStampConvertor::convert
static std::string convert(const UtcTimeStamp &value, int precision=0)
Definition: FieldConvertors.h:434