FieldConvertors.h
Go to the documentation of this file.
00001 /* -*- C++ -*- */
00002 
00003 /****************************************************************************
00004 ** Copyright (c) 2001-2014
00005 **
00006 ** This file is part of the QuickFIX FIX Engine
00007 **
00008 ** This file may be distributed under the terms of the quickfixengine.org
00009 ** license as defined by quickfixengine.org and appearing in the file
00010 ** LICENSE included in the packaging of this file.
00011 **
00012 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
00013 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
00014 **
00015 ** See http://www.quickfixengine.org/LICENSE for licensing information.
00016 **
00017 ** Contact ask@quickfixengine.org if any conditions of this licensing are
00018 ** not clear to you.
00019 **
00020 ****************************************************************************/
00021 
00022 #ifndef FIX_FIELDCONVERTORS_H
00023 #define FIX_FIELDCONVERTORS_H
00024 
00025 #include "FieldTypes.h"
00026 #include "Exceptions.h"
00027 #include "Utility.h"
00028 #include <string>
00029 #include <sstream>
00030 #include <iomanip>
00031 #include <cstdio>
00032 #include <limits>
00033 
00034 namespace FIX
00035 {
00036 
00037 typedef int signed_int;
00038 typedef unsigned int unsigned_int;
00039 
00040 #define UNSIGNED_VALUE_OF( x ) unsigned_int( x < 0 ? -x : x )
00041 
00042 #define IS_SPACE( x ) ( x == ' ' )
00043 #define IS_DIGIT( x ) ( unsigned_int( x - '0' ) < 10 )
00044 
00045 inline int number_of_symbols_in( const signed_int value )
00046 {
00047   unsigned_int number = UNSIGNED_VALUE_OF( value );
00048 
00049   int symbols = 0;
00050 
00051   while( number > 9999 )
00052   {
00053     symbols += 4;
00054     number /= 10000;
00055   }
00056 
00057   // small tweak to make comparison times consistent
00058   // always 2 comparisons instead of [1 - 4]
00059   if( number > 99 )
00060   {
00061     if( number > 999 )
00062       symbols += 4;
00063     else
00064       symbols += 3;
00065   }
00066   else
00067   {
00068     if( number > 9 )
00069       symbols += 2;
00070     else
00071       symbols += 1;
00072   }
00073 
00074   if( value < 0 )
00075     symbols += 1;
00076 
00077   return symbols;
00078 }
00079 
00080 static const char digit_pairs[201] = {
00081   "00010203040506070809"
00082   "10111213141516171819"
00083   "20212223242526272829"
00084   "30313233343536373839"
00085   "40414243444546474849"
00086   "50515253545556575859"
00087   "60616263646566676869"
00088   "70717273747576777879"
00089   "80818283848586878889"
00090   "90919293949596979899"
00091 };
00092 
00093 inline char* integer_to_string( char* buf, const size_t len, signed_int t )
00094 {
00095   const bool isNegative = t < 0;
00096   char* p = buf + len;
00097 
00098   *--p = '\0';
00099   
00100   unsigned_int number = UNSIGNED_VALUE_OF( t );
00101 
00102   while( number > 99 )
00103   {
00104     unsigned_int pos = number % 100;
00105     number /= 100;
00106     p -= 2;
00107     *(short*)(p) = *(short*)(digit_pairs + 2 * pos);
00108   }
00109 
00110   if( number > 9 )
00111   {
00112     p -= 2;
00113     *(short*)(p) = *(short*)(digit_pairs + 2 * number);
00114   }
00115   else
00116   {
00117     *--p = '0' + char(number);
00118   }
00119 
00120   if( isNegative )
00121     *--p = '-';
00122 
00123   return p;
00124 }
00125 
00126 inline char* integer_to_string_padded
00127 ( char* buf, const size_t len, signed_int t,
00128   const size_t width = 0,
00129   const char paddingChar = '0')
00130 {
00131   char* p = integer_to_string( buf, len, t );
00132   if( !width ) 
00133     return p;
00134 
00135   const char* stop_p = buf + len - width - 1;
00136   if( stop_p < buf ) stop_p = buf;
00137   while( p > stop_p )
00138     *--p = paddingChar;
00139   return p;
00140 }
00141 
00143 struct EmptyConvertor
00144 {
00145   static const std::string& convert( const std::string& value )
00146   { return value; }
00147 };
00148 
00149 typedef EmptyConvertor StringConvertor;
00150 
00152 struct IntConvertor
00153 {
00154   static std::string convert( signed_int value )
00155   {
00156     // buffer is big enough for significant digits and extra digit,
00157     // minus and null
00158     char buffer[std::numeric_limits<signed_int>::digits10 + 3];
00159     const char* const start
00160       = integer_to_string( buffer, sizeof (buffer), value );
00161     return std::string( start, buffer + sizeof (buffer) - start - 1 );
00162   }
00163 
00164   static bool convert(     
00165     std::string::const_iterator str, 
00166     std::string::const_iterator end, 
00167     signed_int& result )
00168   {
00169     bool isNegative = false;
00170     signed_int x = 0;
00171 
00172     if( str == end )
00173       return false;
00174 
00175     if( *str == '-' )
00176     {
00177       isNegative = true;
00178       if( ++str == end )
00179         return false;
00180     }
00181 
00182     do
00183     {
00184       const unsigned_int c = *str - '0';
00185       if( c > 9 ) return false;
00186       x = 10 * x + c;
00187     } while ( ++str != end );
00188 
00189     if( isNegative )
00190       x = -x;
00191 
00192     result = x;
00193     return true;
00194   }
00195 
00196   static bool convert( const std::string& value, signed_int& result )
00197   {
00198     return convert( value.begin(), value.end(), result );
00199   }
00200 
00201   static signed_int convert( const std::string& value )
00202   throw( FieldConvertError )
00203   {
00204     signed_int result = 0;
00205     if( !convert( value.begin(), value.end(), result ) )
00206       throw FieldConvertError(value);
00207     else
00208       return result;
00209   }
00210 
00214   static bool convertPositive( 
00215     std::string::const_iterator str, 
00216     std::string::const_iterator end, 
00217     signed_int& result )
00218   {
00219     const int MAX_VALUE = 2147483647; // max value for 32-bit signed integer
00220     const int HIGH_MARK = MAX_VALUE / 10;
00221     const unsigned_int STOP_SYMBOL = MAX_VALUE % 10;
00222     const std::size_t MAX_DIGITS = 10;     // integer can hold up to 10 digits
00223 
00224     const std::size_t length = std::distance( str, end );
00225     if( length < 1 || length > MAX_DIGITS)
00226       return false;
00227 
00228     if( length == MAX_DIGITS )
00229     {
00230       end = str;
00231       std::advance( end, length - 1 );
00232     }
00233 
00234     const unsigned_int ch = *str - '1';
00235     if( ch > 8 )
00236       return false;
00237 
00238     unsigned_int x = 0;
00239 
00240     do
00241     {
00242       const unsigned_int c = *str - '0';
00243       if( c > 9 ) return false;
00244       x = 10 * x + c;
00245     } while( ++str < end );
00246 
00247     // complete overflow condition check and value calculation
00248     // this saves about 25% of speed when executed out of the main loop
00249     if( length == MAX_DIGITS )
00250     {
00251       if( x > (unsigned int)HIGH_MARK )
00252         return false;
00253 
00254       const unsigned_int c = *str - '0';
00255       if( x == (unsigned int)HIGH_MARK && c > STOP_SYMBOL )
00256         return false;
00257 
00258       x = 10 * x + c;
00259     }
00260 
00261     result = x;
00262     return true;
00263   }
00264 
00265   static signed_int convertPositive( const std::string& value )
00266   throw( FieldConvertError )
00267   {
00268     signed_int result = 0;
00269     if( !convertPositive( value.begin(), value.end(), result ) )
00270       throw FieldConvertError(value);
00271     else
00272       return result;
00273   }
00274 };
00275 
00277 struct CheckSumConvertor
00278 {
00279   static std::string convert( int value )
00280   throw( FieldConvertError )
00281   {
00282     if ( value > 255 || value < 0 ) throw FieldConvertError();
00283     char result[4];
00284     if( integer_to_string_padded(result, sizeof(result), value, 3) != result )
00285     {
00286       throw FieldConvertError();
00287     }
00288     return std::string( result, 3 );
00289   }
00290 
00291   static bool convert( const std::string& value, int& result )
00292   {
00293     return IntConvertor::convert( value, result );
00294   }
00295 
00296   static int convert( const std::string& value )
00297   throw( FieldConvertError )
00298   {
00299     return IntConvertor::convert( value );
00300   }
00301 };
00302 
00304 struct DoubleConvertor
00305 {
00306 
00307 private:
00308 
00309   /*Simple and fast atof (ascii to float) function.
00310   Executes about 5x faster than standard MSCRT library atof().
00311   An attractive alternative if the number of calls is in the millions.
00312   Assumes input is a proper integer, fraction, or scientific format.
00313   Matches library atof() to 15 digits (except at extreme exponents).
00314   Follows atof() precedent of essentially no error checking.
00315   09-May-2009 Tom Van Baak (tvb) www.LeapSecond.com */
00316   static double fast_atof (const char *p)
00317   {
00318     bool frac(false);
00319     double sign(1.), value(0.), scale(1.);
00320 
00321     while (IS_SPACE(*p))
00322       ++p;
00323 
00324     // Get sign, if any.
00325     if (*p == '-')
00326     {
00327       sign = -1.;
00328       ++p;
00329     }
00330     else if (*p == '+')
00331       ++p;
00332 
00333     // Get digits before decimal point or exponent, if any.
00334     while (IS_DIGIT(*p))
00335     {
00336       value = value * 10. + (*p - '0');
00337       ++p;
00338     }
00339 
00340     // Get digits after decimal point, if any.
00341     if (*p == '.')
00342     {
00343       ++p;
00344       double pow10(10.);
00345       while (IS_DIGIT(*p))
00346       {
00347         value += (*p - '0') / pow10;
00348         pow10 *= 10.;
00349         ++p;
00350       }
00351     }
00352 
00353     // Handle exponent, if any.
00354     if (toupper(*p) == 'E')
00355     {
00356       unsigned int expon(0);
00357       ++p;
00358 
00359       // Get sign of exponent, if any.
00360       if (*p == '-')
00361       {
00362         frac = true;
00363         ++p;
00364       }
00365       else if (*p == '+')
00366         ++p;
00367 
00368       // Get digits of exponent, if any.
00369       while (IS_DIGIT(*p))
00370       {
00371         expon = expon * 10 + (*p - '0');
00372         ++p;
00373       }
00374       if (expon > 308)
00375         expon = 308;
00376 
00377       // Calculate scaling factor.
00378       while (expon >= 50)
00379       {
00380         scale *= 1E50;
00381         expon -= 50;
00382       }
00383       while (expon >= 8)
00384       {
00385         scale *= 1E8;
00386         expon -=  8;
00387       }
00388       while (expon > 0)
00389       {
00390         scale *= 10.0;
00391         expon -=  1;
00392       }
00393     }
00394 
00395     // Return signed and scaled floating point result.
00396     return sign * (frac ? (value / scale) : (value * scale));
00397   }
00398 
00399 public:
00400 
00401   static std::string convert( double value, int padding = 0 )
00402   {
00403     char result[32];
00404     char *end = 0;
00405 
00406     int size;
00407     if( value == 0 || value > 0.0001 || value <= -0.0001 )
00408     {
00409       size = STRING_SPRINTF( result, "%.15g", value );
00410 
00411       if( padding > 0 )
00412       {
00413         char* point = result;
00414         end = result + size - 1;
00415         while( *point != '.' && *point != 0 )
00416           point++;
00417 
00418         if( *point == 0 )
00419         {
00420           end = point;
00421           *point = '.';
00422           size++;
00423         }
00424         int needed = padding - (int)(end - point);
00425 
00426         while( needed-- > 0 )
00427         {
00428           *(++end) = '0';
00429           size++;
00430         }
00431         *(end+1) = 0;
00432       }
00433     }
00434     else
00435     {
00436       size = STRING_SPRINTF( result, "%.15f", value );
00437       // strip trailing 0's
00438       end = result + size - 1;
00439 
00440       if( padding > 0 )
00441       {
00442         int discard = 15 - padding;
00443 
00444         while( (*end == '0') && (discard-- > 0) )
00445         {
00446           *(end--) = 0;
00447           size--;
00448         }
00449      }
00450      else
00451      {
00452        while( *end == '0' )
00453        {
00454          *(end--) = 0;
00455          size--;
00456        }
00457      }
00458    }
00459 
00460    return std::string( result, size );
00461 }
00462 
00463 static bool convert( const std::string& value, double& result )
00464 {
00465   const char * i = value.c_str();
00466 
00467   // Catch null strings
00468   if( !*i ) return false;
00469   // Eat leading '-' and recheck for null string
00470   if( *i == '-' && !*++i ) return false;
00471 
00472   bool haveDigit = false;
00473 
00474   if( IS_DIGIT(*i) )
00475   {
00476     haveDigit = true;
00477     while( IS_DIGIT (*++i) );
00478   }
00479 
00480   if( *i == '.' && IS_DIGIT(*++i) )
00481   {
00482     haveDigit = true;
00483     while( IS_DIGIT (*++i) );
00484   }
00485 
00486   if( *i || !haveDigit ) return false;
00487     
00488   result = fast_atof( value.c_str() );
00489   return true;
00490   }
00491 
00492   static double convert( const std::string& value )
00493   throw( FieldConvertError )
00494   {
00495     double result = 0.0;
00496     if( !convert( value, result ) )
00497       throw FieldConvertError(value);
00498     else
00499       return result;
00500   }
00501 };
00502 
00504 struct CharConvertor
00505 {
00506   static std::string convert( char value )
00507   {
00508     if( value == '\0' ) return "";
00509     return std::string( 1, value );
00510   }
00511 
00512   static bool convert( const std::string& value, char& result )
00513   {
00514     if( value.size() != 1 ) return false;
00515     result = value[0];
00516     return true;
00517   }
00518 
00519   static char convert( const std::string& value )
00520   throw( FieldConvertError )
00521   {
00522     char result = '\0';
00523     if( !convert( value, result ) )
00524       throw FieldConvertError(value);
00525     else
00526       return result;
00527   }
00528 };
00529 
00531 struct BoolConvertor
00532 {
00533   static std::string convert( bool value )
00534   {
00535     const char ch = value ? 'Y' : 'N';
00536     return std::string( 1, ch );
00537   }
00538 
00539   static bool convert( const std::string& value, bool& result )
00540   {
00541     if( value.size() != 1 ) return false;
00542     switch( value[0] )
00543     {
00544       case 'Y': result = true; break;
00545       case 'N': result = false; break;
00546       default: return false;
00547     }
00548 
00549     return true;
00550   }
00551 
00552   static bool convert( const std::string& value )
00553   throw( FieldConvertError )
00554   {
00555     bool result = false;
00556     if( !convert( value, result ) )
00557       throw FieldConvertError(value);
00558     else
00559       return result;
00560   }
00561 };
00562 
00564 struct UtcTimeStampConvertor
00565 {
00566   static std::string convert( const UtcTimeStamp& value,
00567                               bool showMilliseconds = false )
00568   throw( FieldConvertError )
00569   {
00570     char result[ 18+4 ];
00571     int year, month, day, hour, minute, second, millis;
00572 
00573     value.getYMD( year, month, day );
00574     value.getHMS( hour, minute, second, millis );
00575 
00576     integer_to_string_padded( result, 5, year, 4 );
00577     integer_to_string_padded( result + 4, 3, month, 2 );
00578     integer_to_string_padded( result + 6, 3, day, 2 );
00579     result[8]  = '-';
00580     integer_to_string_padded( result + 9, 3, hour, 2 );
00581     result[11] = ':';
00582     integer_to_string_padded( result + 12, 3, minute, 2 );
00583     result[14] = ':';
00584     integer_to_string_padded( result + 15, 3, second, 2 );
00585 
00586     if( showMilliseconds )
00587     {
00588       result[17] = '.';
00589       if( integer_to_string_padded ( result + 18, 4, millis, 3 )
00590           != result + 18 )
00591       {
00592         throw FieldConvertError();
00593       }
00594     }
00595 
00596     return result;
00597   }
00598 
00599   static UtcTimeStamp convert( const std::string& value,
00600                                bool calculateDays = false )
00601   throw( FieldConvertError )
00602   {
00603     bool haveMilliseconds = false;
00604 
00605     switch( value.size() )
00606     {
00607       case 21: haveMilliseconds = true;
00608       case 17: break;
00609       default: throw FieldConvertError(value);
00610     }
00611 
00612     int i = 0;
00613     int c = 0;
00614     for( c = 0; c < 8; ++c )
00615       if( !IS_DIGIT(value[i++]) ) throw FieldConvertError(value);
00616     if (value[i++] != '-') throw FieldConvertError(value);
00617     for( c = 0; c < 2; ++c )
00618       if( !IS_DIGIT(value[i++]) ) throw FieldConvertError(value);
00619     if( value[i++] != ':' ) throw FieldConvertError(value);
00620     for( c = 0; c < 2; ++c )
00621       if( !IS_DIGIT(value[i++]) ) throw FieldConvertError(value);
00622     if( value[i++] != ':' ) throw FieldConvertError(value);
00623     for( c = 0; c < 2; ++c )
00624       if( !IS_DIGIT(value[i++]) ) throw FieldConvertError(value);
00625 
00626     if( haveMilliseconds )
00627     {
00628       if( value[i++] != '.' ) throw FieldConvertError(value);
00629       for( c = 0; c < 3; ++c )
00630         if( !IS_DIGIT(value[i++]) ) throw FieldConvertError(value);
00631     }
00632 
00633     int year, mon, mday, hour, min, sec, millis;
00634 
00635     i = 0;
00636 
00637     year = value[i++] - '0';
00638     year = 10 * year + value[i++] - '0';
00639     year = 10 * year + value[i++] - '0';
00640     year = 10 * year + value[i++] - '0';
00641 
00642     mon = value[i++] - '0';
00643     mon = 10 * mon + value[i++] - '0';
00644     if( mon < 1 || 12 < mon ) throw FieldConvertError(value);
00645 
00646     mday = value[i++] - '0';
00647     mday = 10 * mday + value[i++] - '0';
00648     if( mday < 1 || 31 < mday ) throw FieldConvertError(value);
00649 
00650     ++i; // skip '-'
00651 
00652     hour = value[i++] - '0';
00653     hour = 10 * hour + value[i++] - '0';
00654     // No check for >= 0 as no '-' are converted here
00655     if( 23 < hour ) throw FieldConvertError(value);
00656 
00657     ++i; // skip ':'
00658 
00659     min = value[i++] - '0';
00660     min = 10 * min + value[i++] - '0';
00661     // No check for >= 0 as no '-' are converted here
00662     if( 59 < min ) throw FieldConvertError(value);
00663 
00664     ++i; // skip ':'
00665 
00666     sec = value[i++] - '0';
00667     sec = 10 * sec + value[i++] - '0';
00668 
00669     // No check for >= 0 as no '-' are converted here
00670     if( 60 < sec ) throw FieldConvertError(value);
00671 
00672     if( haveMilliseconds )
00673     {
00674       millis = (100 * (value[i+1] - '0')
00675                 + 10 * (value[i+2] - '0')
00676                 + (value[i+3] - '0'));
00677     }
00678     else
00679       millis = 0;
00680 
00681     return UtcTimeStamp (hour, min, sec, millis,
00682                          mday, mon, year);
00683   }
00684 };
00685 
00687 struct UtcTimeOnlyConvertor
00688 {
00689   static std::string convert( const UtcTimeOnly& value,
00690                               bool showMilliseconds = false)
00691   throw( FieldConvertError )
00692   {
00693     char result[ 9+4 ];
00694     int hour, minute, second, millis;
00695 
00696     value.getHMS( hour, minute, second, millis );
00697 
00698     integer_to_string_padded ( result, 3, hour, 2 );
00699     result[2] = ':';
00700     integer_to_string_padded ( result + 3, 3, minute,  2 );
00701     result[5] = ':';
00702     integer_to_string_padded ( result + 6, 3, second,  2 );
00703 
00704     if( showMilliseconds )
00705     {
00706       result[8] = '.';
00707       if( integer_to_string_padded ( result + 9, 4, millis, 3 )
00708           != result + 9 )
00709           throw FieldConvertError();
00710     }
00711 
00712     return result;
00713   }
00714 
00715   static UtcTimeOnly convert( const std::string& value )
00716   throw( FieldConvertError )
00717   {
00718     bool haveMilliseconds = false;
00719 
00720     switch( value.size() )
00721     {
00722       case 12: haveMilliseconds = true;
00723       case 8: break;
00724       default: throw FieldConvertError(value);
00725     }
00726 
00727     int i = 0;
00728     int c = 0;
00729     for( c = 0; c < 2; ++c )
00730       if( !IS_DIGIT(value[i++]) ) throw FieldConvertError(value);
00731     if( value[i++] != ':' ) throw FieldConvertError(value);
00732     for( c = 0; c < 2; ++c )
00733       if( !IS_DIGIT(value[i++]) ) throw FieldConvertError(value);
00734     if( value[i++] != ':' ) throw FieldConvertError(value);
00735     for( c = 0; c < 2; ++c )
00736       if( !IS_DIGIT(value[i++]) ) throw FieldConvertError(value);
00737 
00738     if( haveMilliseconds )
00739     {
00740       // ++i instead of i++ skips the '.' separator
00741       for( c = 0; c < 3; ++c )
00742         if( !IS_DIGIT(value[++i]) ) throw FieldConvertError(value);
00743     }
00744 
00745     int hour, min, sec, millis;
00746  
00747     i = 0;
00748 
00749     hour = value[i++] - '0';
00750     hour = 10 * hour + value[i++] - '0';
00751     // No check for >= 0 as no '-' are converted here
00752     if( 23 < hour ) throw FieldConvertError(value);
00753     ++i; // skip ':'
00754 
00755     min = value[i++] - '0';
00756     min = 10 * min + value[i++] - '0';
00757     // No check for >= 0 as no '-' are converted here
00758     if( 59 < min ) throw FieldConvertError(value);
00759     ++i; // skip ':'
00760 
00761     sec = value[i++] - '0';
00762     sec = 10 * sec + value[i++] - '0';
00763     // No check for >= 0 as no '-' are converted here
00764     if( 60 < sec ) throw FieldConvertError(value);
00765 
00766     if( haveMilliseconds )
00767     {
00768       millis = (100 * (value[i+1] - '0')
00769                 + 10 * (value[i+2] - '0')
00770                 + (value[i+3] - '0'));
00771     }
00772     else
00773       millis = 0;
00774 
00775     return UtcTimeOnly( hour, min, sec, millis );
00776   }
00777 };
00778 
00780 struct UtcDateConvertor
00781 {
00782   static std::string convert( const UtcDate& value )
00783   throw( FieldConvertError )
00784   {
00785     char result[ 9 ];
00786     int year, month, day;
00787 
00788     value.getYMD( year, month, day );
00789 
00790     integer_to_string_padded( result, 5, year, 4 );
00791     integer_to_string_padded( result + 4, 3, month, 2 );
00792     integer_to_string_padded( result + 6, 3, day, 2 );
00793     return result;
00794   }
00795 
00796   static UtcDate convert( const std::string& value )
00797   throw( FieldConvertError )
00798   {
00799     if( value.size() != 8 ) throw FieldConvertError(value);
00800 
00801     int i = 0;
00802     for( int c=0; c<8; ++c )
00803       if( !IS_DIGIT(value[i++]) ) throw FieldConvertError(value);
00804 
00805     int year, mon, mday;
00806 
00807     i = 0;
00808 
00809     year = value[i++] - '0';
00810     year = 10 * year + value[i++] - '0';
00811     year = 10 * year + value[i++] - '0';
00812     year = 10 * year + value[i++] - '0';
00813 
00814     mon = value[i++] - '0';
00815     mon = 10 * mon + value[i++] - '0';
00816     if( mon < 1 || 12 < mon )
00817       throw FieldConvertError(value);
00818 
00819     mday = value[i++] - '0';
00820     mday = 10 * mday + value[i++] - '0';
00821     if( mday < 1 || 31 < mday )
00822       throw FieldConvertError(value);
00823 
00824     return UtcDateOnly( mday, mon, year );
00825   }
00826 };
00827 
00828 typedef UtcDateConvertor UtcDateOnlyConvertor;
00829 
00830 typedef StringConvertor STRING_CONVERTOR;
00831 typedef CharConvertor CHAR_CONVERTOR;
00832 typedef DoubleConvertor PRICE_CONVERTOR;
00833 typedef IntConvertor INT_CONVERTOR;
00834 typedef DoubleConvertor AMT_CONVERTOR;
00835 typedef DoubleConvertor QTY_CONVERTOR;
00836 typedef StringConvertor CURRENCY_CONVERTOR;
00837 typedef StringConvertor MULTIPLEVALUESTRING_CONVERTOR;
00838 typedef StringConvertor MULTIPLESTRINGVALUE_CONVERTOR;
00839 typedef StringConvertor MULTIPLECHARVALUE_CONVERTOR;
00840 typedef StringConvertor EXCHANGE_CONVERTOR;
00841 typedef UtcTimeStampConvertor UTCTIMESTAMP_CONVERTOR;
00842 typedef BoolConvertor BOOLEAN_CONVERTOR;
00843 typedef StringConvertor LOCALMKTDATE_CONVERTOR;
00844 typedef StringConvertor DATA_CONVERTOR;
00845 typedef DoubleConvertor FLOAT_CONVERTOR;
00846 typedef DoubleConvertor PRICEOFFSET_CONVERTOR;
00847 typedef StringConvertor MONTHYEAR_CONVERTOR;
00848 typedef StringConvertor DAYOFMONTH_CONVERTOR;
00849 typedef UtcDateConvertor UTCDATE_CONVERTOR;
00850 typedef UtcTimeOnlyConvertor UTCTIMEONLY_CONVERTOR;
00851 typedef IntConvertor NUMINGROUP_CONVERTOR;
00852 typedef DoubleConvertor PERCENTAGE_CONVERTOR;
00853 typedef IntConvertor SEQNUM_CONVERTOR;
00854 typedef IntConvertor LENGTH_CONVERTOR;
00855 typedef StringConvertor COUNTRY_CONVERTOR;
00856 typedef StringConvertor TZTIMEONLY_CONVERTOR;
00857 typedef StringConvertor TZTIMESTAMP_CONVERTOR;
00858 typedef StringConvertor XMLDATA_CONVERTOR;
00859 typedef StringConvertor LANGUAGE_CONVERTOR;
00860 typedef CheckSumConvertor CHECKSUM_CONVERTOR;
00861 }
00862 
00863 #endif //FIX_FIELDCONVERTORS_H

Generated on Mon Jun 23 2014 23:49:37 for QuickFIX by doxygen 1.7.6.1 written by Dimitri van Heesch, © 1997-2001