Index Source Files Annotated Class List Alphabetical Class List Class Hierarchy Graphical Class Hierarchy

# Field.h

Go to the documentation of this file.

    00001 /* -*- C++ -*- */
    00002
    00003 /****************************************************************************
    00004 ** Copyright (c) quickfixengine.org  All rights reserved.
    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_FIELD
    00023 #define FIX_FIELD
    00024
    00025 #ifdef _MSC_VER
    00026 #pragma warning( disable : 4786 )
    00027 #endif
    00028
    00029 #include <sstream>
    00030 #include <numeric>
    00031 #include "FieldNumbers.h"
    00032 #include "FieldConvertors.h"
    00033 #include "FieldTypes.h"
    00034 #include "Utility.h"
    00035
    00036 namespace FIX
    00037 {
    00045 class FieldBase
    00046 {
    00047   friend class Message;
    00048 public:
    00049   FieldBase( int field, const std::string& string )
    00050     : m_field( field ), m_string(string), m_length( 0 ), m_total( 0 ),
    00051       m_calculated( false )
    00052   {}
    00053
    00054   virtual ~FieldBase() {}
    00055
    00056   void setField( int field )
    00057   {
    00058     m_field = field;
    00059     m_calculated = false;
    00060   }
    00061
    00062   void setString( const std::string& string )
    00063   {
    00064     m_string = string;
    00065     m_calculated = false;
    00066   }
    00067
    00069   int getField() const
    00070     { return m_field; }
    00071
    00073   const std::string& getString() const
    00074     { return m_string; }
    00075
    00077   const std::string& getValue() const
    00078   {
    00079     calculate();
    00080     return m_data;
    00081   }
    00082
    00084   int getLength() const
    00085   {
    00086     calculate();
    00087     return m_length;
    00088   }
    00089
    00091   int getTotal() const
    00092   {
    00093     calculate();
    00094     return m_total;
    00095   }
    00096
    00098   bool operator < ( const FieldBase& field ) const
    00099     { return m_field < field.m_field; }
    00100
    00101 private:
    00102   void calculate() const
    00103   {
    00104     if( m_calculated ) return;
    00105
    00106     char buf[64];
    00107
    00108     if( 13 + m_string.length() < sizeof(buf) )
    00109     {
    00110       int tagLength = STRING_SPRINTF( buf, "%d=", m_field );
    00111       m_length = tagLength + m_string.length() + 1;
    00112       memcpy( buf + tagLength, m_string.data(), m_string.length() );
    00113       buf[m_length - 1] = '\001';
    00114       m_data.assign( buf, m_length );
    00115     }
    00116     else
    00117     {
    00118       m_data = IntConvertor::convert(m_field) + "=" + m_string + "\001";
    00119       m_length = m_data.length();
    00120     }
    00121
    00122     const unsigned char* iter =
    00123       reinterpret_cast<const unsigned char*>( m_data.c_str() );
    00124     m_total = std::accumulate( iter, iter + m_length, 0 );
    00125
    00126     m_calculated = true;
    00127   }
    00128
    00129   int m_field;
    00130   std::string m_string;
    00131   mutable std::string m_data;
    00132   mutable int m_length;
    00133   mutable int m_total;
    00134   mutable bool m_calculated;
    00135 };
    00138 inline std::ostream& operator <<
    00139 ( std::ostream& stream, const FieldBase& field )
    00140 {
    00141   stream << field.getString();
    00142   return stream;
    00143 }
    00144
    00149 class StringField : public FieldBase
    00150 {
    00151 public:
    00152   explicit StringField( int field, const std::string& data )
    00153 : FieldBase( field, data ) {}
    00154   StringField( int field )
    00155 : FieldBase( field, "" ) {}
    00156
    00157   void setValue( const std::string& value )
    00158     { setString( value ); }
    00159   const std::string& getValue() const
    00160     { return getString(); }
    00161   operator const std::string&() const
    00162     { return getString(); }
    00163
    00164   bool operator<( const StringField& rhs ) const
    00165     { return getString() < rhs.getString(); }
    00166   bool operator>( const StringField& rhs ) const
    00167     { return getString() > rhs.getString(); }
    00168   bool operator==( const StringField& rhs ) const
    00169     { return getString() == rhs.getString(); }
    00170   bool operator!=( const StringField& rhs ) const
    00171     { return getString() != rhs.getString(); }
    00172   bool operator<=( const StringField& rhs ) const
    00173     { return getString() <= rhs.getString(); }
    00174   bool operator>=( const StringField& rhs ) const
    00175     { return getString() >= rhs.getString(); }
    00176   friend bool operator<( const StringField&, const char* );
    00177   friend bool operator<( const char*, const StringField& );
    00178   friend bool operator>( const StringField&, const char* );
    00179   friend bool operator>( const char*, const StringField& );
    00180   friend bool operator==( const StringField&, const char* );
    00181   friend bool operator==( const char*, const StringField& );
    00182   friend bool operator!=( const StringField&, const char* );
    00183   friend bool operator!=( const char*, const StringField& );
    00184   friend bool operator<=( const StringField&, const char* );
    00185   friend bool operator<=( const char*, const StringField& );
    00186   friend bool operator>=( const StringField&, const char* );
    00187   friend bool operator>=( const char*, const StringField& );
    00188
    00189   friend bool operator<( const StringField&, const std::string& );
    00190   friend bool operator<( const std::string&, const StringField& );
    00191   friend bool operator>( const StringField&, const std::string& );
    00192   friend bool operator>( const std::string&, const StringField& );
    00193   friend bool operator==( const StringField&, const std::string& );
    00194   friend bool operator==( const std::string&, const StringField& );
    00195   friend bool operator!=( const StringField&, const std::string& );
    00196   friend bool operator!=( const std::string&, const StringField& );
    00197   friend bool operator<=( const StringField&, const std::string& );
    00198   friend bool operator<=( const std::string&, const StringField& );
    00199   friend bool operator>=( const StringField&, const std::string& );
    00200   friend bool operator>=( const std::string&, const StringField& );
    00201 };
    00202
    00203 inline bool operator<( const StringField& lhs, const char* rhs )
    00204   { return lhs.getValue() < rhs; }
    00205 inline bool operator<( const char* lhs, const StringField& rhs )
    00206   { return lhs < rhs.getValue(); }
    00207 inline bool operator>( const StringField& lhs, const char* rhs )
    00208   { return lhs.getValue() > rhs; }
    00209 inline bool operator>( const char* lhs, const StringField& rhs )
    00210   { return lhs > rhs.getValue(); }
    00211 inline bool operator==( const StringField& lhs, const char* rhs )
    00212   { return lhs.getValue() == rhs; }
    00213 inline bool operator==( const char* lhs, const StringField& rhs )
    00214   { return lhs == rhs.getValue(); }
    00215 inline bool operator!=( const StringField& lhs, const char* rhs )
    00216   { return lhs.getValue() != rhs; }
    00217 inline bool operator!=( const char* lhs, const StringField& rhs )
    00218   { return lhs != rhs.getValue(); }
    00219 inline bool operator<=( const StringField& lhs, const char* rhs )
    00220   { return lhs.getValue() <= rhs; }
    00221 inline bool operator<=( const char* lhs, const StringField& rhs )
    00222   { return lhs <= rhs.getValue(); }
    00223 inline bool operator>=( const StringField& lhs, const char* rhs )
    00224   { return lhs.getValue() >= rhs; }
    00225 inline bool operator>=( const char* lhs, const StringField& rhs )
    00226   { return lhs >= rhs.getValue(); }
    00227
    00228 inline bool operator<( const StringField& lhs, const std::string& rhs )
    00229   { return lhs.getValue() < rhs; }
    00230 inline bool operator<( const std::string& lhs, const StringField& rhs )
    00231   { return lhs < rhs.getValue(); }
    00232 inline bool operator>( const StringField& lhs, const std::string& rhs )
    00233   { return lhs.getValue() > rhs; }
    00234 inline bool operator>( const std::string& lhs, const StringField& rhs )
    00235   { return lhs > rhs.getValue(); }
    00236 inline bool operator==( const StringField& lhs, const std::string& rhs )
    00237   { return lhs.getValue() == rhs; }
    00238 inline bool operator==( const std::string& lhs, const StringField& rhs )
    00239   { return lhs == rhs.getValue(); }
    00240 inline bool operator!=( const StringField& lhs, const std::string& rhs )
    00241   { return lhs.getValue() != rhs; }
    00242 inline bool operator!=( const std::string& lhs, const StringField& rhs )
    00243   { return lhs != rhs.getValue(); }
    00244 inline bool operator<=( const StringField& lhs, const std::string& rhs )
    00245   { return lhs.getValue() <= rhs; }
    00246 inline bool operator<=( const std::string& lhs, const StringField& rhs )
    00247   { return lhs <= rhs.getValue(); }
    00248 inline bool operator>=( const StringField& lhs, const std::string& rhs )
    00249   { return lhs.getValue() >= rhs; }
    00250 inline bool operator>=( const std::string& lhs, const StringField& rhs )
    00251   { return lhs >= rhs.getValue(); }
    00252
    00254 class CharField : public FieldBase
    00255 {
    00256 public:
    00257   explicit CharField( int field, char data )
    00258 : FieldBase( field, CharConvertor::convert( data ) ) {}
    00259   CharField( int field )
    00260 : FieldBase( field, "" ) {}
    00261
    00262   void setValue( char value )
    00263     { setString( CharConvertor::convert( value ) ); }
    00264   char getValue() const throw ( IncorrectDataFormat )
    00265     { try
    00266       { return CharConvertor::convert( getString() ); }
    00267       catch( FieldConvertError& )
    00268       { throw IncorrectDataFormat( getField(), getString() ); } }
    00269   operator char() const
    00270     { return getValue(); }
    00271 };
    00272
    00274 class DoubleField : public FieldBase
    00275 {
    00276 public:
    00277   explicit DoubleField( int field, double data, int padding = 0 )
    00278 : FieldBase( field, DoubleConvertor::convert( data, padding ) ) {}
    00279   DoubleField( int field )
    00280 : FieldBase( field, "" ) {}
    00281
    00282   void setValue( double value, int padding = 0 )
    00283     { setString( DoubleConvertor::convert( value, padding ) ); }
    00284   double getValue() const throw ( IncorrectDataFormat )
    00285     { try
    00286       { return DoubleConvertor::convert( getString() ); }
    00287       catch( FieldConvertError& )
    00288       { throw IncorrectDataFormat( getField(), getString() ); } }
    00289   operator double() const
    00290     { return getValue(); }
    00291 };
    00292
    00294 class IntField : public FieldBase
    00295 {
    00296 public:
    00297   explicit IntField( int field, int data )
    00298 : FieldBase( field, IntConvertor::convert( data ) ) {}
    00299   IntField( int field )
    00300 : FieldBase( field, "" ) {}
    00301
    00302   void setValue( int value )
    00303     { setString( IntConvertor::convert( value ) ); }
    00304   int getValue() const throw ( IncorrectDataFormat )
    00305     { try
    00306       { return IntConvertor::convert( getString() ); }
    00307       catch( FieldConvertError& )
    00308       { throw IncorrectDataFormat( getField(), getString() ); } }
    00309   operator const int() const
    00310     { return getValue(); }
    00311 };
    00312
    00314 class BoolField : public FieldBase
    00315 {
    00316 public:
    00317   explicit BoolField( int field, bool data )
    00318 : FieldBase( field, BoolConvertor::convert( data ) ) {}
    00319   BoolField( int field )
    00320 : FieldBase( field, "" ) {}
    00321
    00322   void setValue( bool value )
    00323     { setString( BoolConvertor::convert( value ) ); }
    00324   bool getValue() const throw ( IncorrectDataFormat )
    00325     { try
    00326       { return BoolConvertor::convert( getString() ); }
    00327       catch( FieldConvertError& )
    00328       { throw IncorrectDataFormat( getField(), getString() ); } }
    00329   operator bool() const
    00330     { return getValue(); }
    00331 };
    00332
    00334 class UtcTimeStampField : public FieldBase
    00335 {
    00336 public:
    00337   explicit UtcTimeStampField( int field, const UtcTimeStamp& data, bool showMilliseconds = false )
    00338 : FieldBase( field, UtcTimeStampConvertor::convert( data, showMilliseconds ) ) {}
    00339   UtcTimeStampField( int field, bool showMilliseconds = false )
    00340 : FieldBase( field, UtcTimeStampConvertor::convert( UtcTimeStamp(), showMilliseconds ) ) {}
    00341
    00342   void setValue( UtcTimeStamp& value )
    00343     { setString( UtcTimeStampConvertor::convert( value ) ); }
    00344   UtcTimeStamp getValue() const throw ( IncorrectDataFormat )
    00345     { try
    00346       { return UtcTimeStampConvertor::convert( getString() ); }
    00347       catch( FieldConvertError& )
    00348       { throw IncorrectDataFormat( getField(), getString() ); } }
    00349   operator UtcTimeStamp() const
    00350     { return getValue(); }
    00351
    00352   bool operator<( const UtcTimeStampField& rhs ) const
    00353     { return getValue() < rhs.getValue(); }
    00354   bool operator==( const UtcTimeStampField& rhs ) const
    00355     { return getValue() == rhs.getValue(); }
    00356   bool operator!=( const UtcTimeStampField& rhs ) const
    00357     { return getValue() != rhs.getValue(); }
    00358 };
    00359
    00361 class UtcDateField : public FieldBase
    00362 {
    00363 public:
    00364   explicit UtcDateField( int field, const UtcDate& data )
    00365 : FieldBase( field, UtcDateConvertor::convert( data ) ) {}
    00366   UtcDateField( int field )
    00367 : FieldBase( field, UtcDateConvertor::convert( UtcDate() ) ) {}
    00368
    00369   void setValue( UtcDate& value )
    00370     { setString( UtcDateConvertor::convert( value ) ); }
    00371   UtcDate getValue() const throw ( IncorrectDataFormat )
    00372     { try
    00373       { return UtcDateConvertor::convert( getString() ); }
    00374       catch( FieldConvertError& )
    00375       { throw IncorrectDataFormat( getField(), getString() ); } }
    00376   operator UtcDate() const
    00377     { return getValue(); }
    00378
    00379   bool operator<( const UtcDateField& rhs ) const
    00380     { return getValue() < rhs.getValue(); }
    00381   bool operator==( const UtcDateField& rhs ) const
    00382     { return getValue() == rhs.getValue(); }
    00383   bool operator!=( const UtcDateField& rhs ) const
    00384     { return getValue() != rhs.getValue(); }
    00385 };
    00386
    00388 class UtcTimeOnlyField : public FieldBase
    00389 {
    00390 public:
    00391   explicit UtcTimeOnlyField( int field, const UtcTimeOnly& data, bool showMilliseconds = false )
    00392 : FieldBase( field, UtcTimeOnlyConvertor::convert( data, showMilliseconds ) ) {}
    00393   UtcTimeOnlyField( int field, bool showMilliseconds = false )
    00394 : FieldBase( field, UtcTimeOnlyConvertor::convert( UtcTimeOnly(), showMilliseconds ) ) {}
    00395
    00396   void setValue( UtcTimeOnly& value )
    00397     { setString( UtcTimeOnlyConvertor::convert( value ) ); }
    00398   UtcTimeOnly getValue() const throw ( IncorrectDataFormat )
    00399     { try
    00400       { return UtcTimeOnlyConvertor::convert( getString() ); }
    00401       catch( FieldConvertError& )
    00402       { throw IncorrectDataFormat( getField(), getString() ); } }
    00403   operator UtcTimeOnly() const
    00404     { return getValue(); }
    00405
    00406   bool operator<( const UtcTimeOnlyField& rhs ) const
    00407     { return getValue() < rhs.getValue(); }
    00408   bool operator==( const UtcTimeOnlyField& rhs ) const
    00409     { return getValue() == rhs.getValue(); }
    00410   bool operator!=( const UtcTimeOnlyField& rhs ) const
    00411     { return getValue() != rhs.getValue(); }
    00412 };
    00413
    00415 class CheckSumField : public FieldBase
    00416 {
    00417 public:
    00418   explicit CheckSumField( int field, int data )
    00419 : FieldBase( field, CheckSumConvertor::convert( data ) ) {}
    00420   CheckSumField( int field )
    00421 : FieldBase( field, "" ) {}
    00422
    00423   void setValue( int value )
    00424     { setString( CheckSumConvertor::convert( value ) ); }
    00425   int getValue() const throw ( IncorrectDataFormat )
    00426     { try
    00427       { return CheckSumConvertor::convert( getString() ); }
    00428       catch( FieldConvertError& )
    00429       { throw IncorrectDataFormat( getField(), getString() ); } }
    00430   operator const int() const
    00431     { return getValue(); }
    00432 };
    00433
    00434 typedef DoubleField PriceField;
    00435 typedef DoubleField AmtField;
    00436 typedef DoubleField QtyField;
    00437 typedef StringField CurrencyField;
    00438 typedef StringField MultipleValueStringField;
    00439 typedef StringField MultipleStringValueField;
    00440 typedef StringField MultipleCharValueField;
    00441 typedef StringField ExchangeField;
    00442 typedef StringField LocalMktDateField;
    00443 typedef StringField DataField;
    00444 typedef DoubleField FloatField;
    00445 typedef DoubleField PriceOffsetField;
    00446 typedef StringField MonthField;
    00447 typedef StringField MonthYearField;
    00448 typedef StringField DayOfMonthField;
    00449 typedef UtcDateField UtcDateOnlyField;
    00450 typedef IntField LengthField;
    00451 typedef IntField NumInGroupField;
    00452 typedef IntField SeqNumField;
    00453 typedef DoubleField PercentageField;
    00454 typedef StringField CountryField;
    00455 typedef StringField TzTimeOnlyField;
    00456 typedef StringField TzTimeStampField;
    00457 }
    00458
    00459 #define DEFINE_FIELD_CLASS_NUM( NAME, TOK, TYPE, NUM ) \
    00460 class NAME : public TOK##Field { public: \
    00461 NAME() : TOK##Field(NUM) {} \
    00462 NAME(const TYPE& value) : TOK##Field(NUM, value) {} \
    00463 }
    00464
    00465 #define DEFINE_FIELD_CLASS( NAME, TOK, TYPE ) \
    00466 DEFINE_FIELD_CLASS_NUM(NAME, TOK, TYPE, FIELD::NAME)
    00467
    00468 #define DEFINE_DEPRECATED_FIELD_CLASS( NAME, TOK, TYPE ) \
    00469 DEFINE_FIELD_CLASS_NUM(NAME, TOK, TYPE, DEPRECATED_FIELD::NAME)
    00470
    00471 #define DEFINE_FIELD_TIMECLASS_NUM( NAME, TOK, TYPE, NUM ) \
    00472 class NAME : public TOK##Field { public: \
    00473 NAME() : TOK##Field(NUM, false) {} \
    00474 NAME(bool showMilliseconds) : TOK##Field(NUM, showMilliseconds) {} \
    00475 NAME(const TYPE& value) : TOK##Field(NUM, value) {} \
    00476 NAME(const TYPE& value, bool showMilliseconds) : TOK##Field(NUM, value, showMilliseconds) {} \
    00477 }
    00478
    00479 #define DEFINE_FIELD_TIMECLASS( NAME, TOK, TYPE ) \
    00480 DEFINE_FIELD_TIMECLASS_NUM(NAME, TOK, TYPE, FIELD::NAME)
    00481
    00482 #define DEFINE_DEPRECATED_FIELD_TIMECLASS( NAME, TOK, TYPE ) \
    00483 DEFINE_FIELD_TIMECLASS_NUM(NAME, TOK, TYPE, DEPRECATED_FIELD::NAME)
    00484
    00485 #define DEFINE_CHECKSUM( NAME ) \
    00486   DEFINE_FIELD_CLASS(NAME, CheckSum, FIX::INT)
    00487 #define DEFINE_STRING( NAME ) \
    00488   DEFINE_FIELD_CLASS(NAME, String, FIX::STRING)
    00489 #define DEFINE_CHAR( NAME ) \
    00490   DEFINE_FIELD_CLASS(NAME, Char, FIX::CHAR)
    00491 #define DEFINE_PRICE( NAME ) \
    00492   DEFINE_FIELD_CLASS(NAME, Price, FIX::PRICE)
    00493 #define DEFINE_INT( NAME ) \
    00494   DEFINE_FIELD_CLASS(NAME, Int, FIX::INT)
    00495 #define DEFINE_AMT( NAME ) \
    00496   DEFINE_FIELD_CLASS(NAME, Amt, FIX::AMT)
    00497 #define DEFINE_QTY( NAME ) \
    00498   DEFINE_FIELD_CLASS(NAME, Qty, FIX::QTY)
    00499 #define DEFINE_CURRENCY( NAME ) \
    00500   DEFINE_FIELD_CLASS(NAME, Currency, FIX::CURRENCY)
    00501 #define DEFINE_MULTIPLEVALUESTRING( NAME ) \
    00502   DEFINE_FIELD_CLASS(NAME, MultipleValueString, FIX::MULTIPLEVALUESTRING)
    00503 #define DEFINE_MULTIPLESTRINGVALUE( NAME ) \
    00504   DEFINE_FIELD_CLASS(NAME, MultipleStringValue, FIX::MULTIPLESTRINGVALUE)
    00505 #define DEFINE_MULTIPLECHARVALUE( NAME ) \
    00506   DEFINE_FIELD_CLASS(NAME, MultipleCharValue, FIX::MULTIPLECHARVALUE)
    00507 #define DEFINE_EXCHANGE( NAME ) \
    00508   DEFINE_FIELD_CLASS(NAME, Exchange, FIX::EXCHANGE)
    00509 #define DEFINE_UTCTIMESTAMP( NAME ) \
    00510   DEFINE_FIELD_TIMECLASS(NAME, UtcTimeStamp, FIX::UTCTIMESTAMP)
    00511 #define DEFINE_BOOLEAN( NAME ) \
    00512   DEFINE_FIELD_CLASS(NAME, Bool, FIX::BOOLEAN)
    00513 #define DEFINE_LOCALMKTDATE( NAME ) \
    00514   DEFINE_FIELD_CLASS(NAME, String, FIX::LOCALMKTDATE)
    00515 #define DEFINE_DATA( NAME ) \
    00516   DEFINE_FIELD_CLASS(NAME, Data, FIX::DATA)
    00517 #define DEFINE_FLOAT( NAME ) \
    00518   DEFINE_FIELD_CLASS(NAME, Float, FIX::FLOAT)
    00519 #define DEFINE_PRICEOFFSET( NAME ) \
    00520   DEFINE_FIELD_CLASS(NAME, PriceOffset, FIX::PRICEOFFSET)
    00521 #define DEFINE_MONTHYEAR( NAME ) \
    00522   DEFINE_FIELD_CLASS(NAME, MonthYear, FIX::MONTHYEAR)
    00523 #define DEFINE_DAYOFMONTH( NAME ) \
    00524   DEFINE_FIELD_CLASS(NAME, DayOfMonth, FIX::DAYOFMONTH)
    00525 #define DEFINE_UTCDATE( NAME ) \
    00526   DEFINE_FIELD_CLASS(NAME, UtcDate, FIX::UTCDATE)
    00527 #define DEFINE_UTCDATEONLY( NAME ) \
    00528   DEFINE_FIELD_CLASS(NAME, UtcDateOnly, FIX::UTCDATEONLY)
    00529 #define DEFINE_UTCTIMEONLY( NAME ) \
    00530   DEFINE_FIELD_CLASS(NAME, UtcTimeOnly, FIX::UTCTIMEONLY)
    00531 #define DEFINE_NUMINGROUP( NAME ) \
    00532   DEFINE_FIELD_CLASS(NAME, NumInGroup, FIX::NUMINGROUP)
    00533 #define DEFINE_SEQNUM( NAME ) \
    00534   DEFINE_FIELD_CLASS(NAME, SeqNum, FIX::SEQNUM)
    00535 #define DEFINE_LENGTH( NAME ) \
    00536   DEFINE_FIELD_CLASS(NAME, Length, FIX::LENGTH)
    00537 #define DEFINE_PERCENTAGE( NAME ) \
    00538   DEFINE_FIELD_CLASS(NAME, Percentage, FIX::PERCENTAGE)
    00539 #define DEFINE_COUNTRY( NAME ) \
    00540   DEFINE_FIELD_CLASS(NAME, Country, FIX::COUNTRY)
    00541 #define DEFINE_TZTIMEONLY( NAME ) \
    00542   DEFINE_FIELD_CLASS(NAME, String, FIX::TZTIMEONLY)
    00543 #define DEFINE_TZTIMESTAMP( NAME ) \
    00544   DEFINE_FIELD_CLASS(NAME, String, FIX::TZTIMESTAMP)
    00545 #define DEFINE_XMLDATA( NAME ) \
    00546   DEFINE_FIELD_CLASS(NAME, String, FIX::XMLDATA)
    00547 #define DEFINE_LANGUAGE( NAME ) \
    00548   DEFINE_FIELD_CLASS(NAME, String, FIX::LANGUAGE)
    00549
    00550 #define USER_DEFINE_STRING( NAME, NUM ) \
    00551   DEFINE_FIELD_CLASS_NUM(NAME, String, FIX::STRING, NUM)
    00552 #define USER_DEFINE_CHAR( NAME, NUM ) \
    00553   DEFINE_FIELD_CLASS_NUM(NAME, Char, FIX::CHAR, NUM)
    00554 #define USER_DEFINE_PRICE( NAME, NUM ) \
    00555   DEFINE_FIELD_CLASS_NUM(NAME, Price, FIX::PRICE, NUM)
    00556 #define USER_DEFINE_INT( NAME, NUM ) \
    00557   DEFINE_FIELD_CLASS_NUM(NAME, Int, FIX::INT, NUM)
    00558 #define USER_DEFINE_AMT( NAME, NUM ) \
    00559   DEFINE_FIELD_CLASS_NUM(NAME, Amt, FIX::AMT, NUM)
    00560 #define USER_DEFINE_QTY( NAME, NUM ) \
    00561   DEFINE_FIELD_CLASS_NUM(NAME, Qty, FIX::QTY, NUM)
    00562 #define USER_DEFINE_CURRENCY( NAME, NUM ) \
    00563   DEFINE_FIELD_CLASS_NUM(NAME, Currency, FIX::CURRENCY, NUM)
    00564 #define USER_DEFINE_MULTIPLEVALUESTRING( NAME, NUM ) \
    00565   DEFINE_FIELD_CLASS_NUM(NAME, MultipleValueString, FIX::MULTIPLEVALUESTRING, NUM)
    00566 #define USER_DEFINE_MULTIPLESTRINGVALUE( NAME, NUM ) \
    00567   DEFINE_FIELD_CLASS_NUM(NAME, MultipleStringValue, FIX::MULTIPLESTRINGVALUE, NUM)
    00568 #define USER_DEFINE_MULTIPLECHARVALUE( NAME, NUM ) \
    00569   DEFINE_FIELD_CLASS_NUM(NAME, MultipleCharValue, FIX::MULTIPLECHARVALUE, NUM)
    00570 #define USER_DEFINE_EXCHANGE( NAME, NUM ) \
    00571   DEFINE_FIELD_CLASS_NUM(NAME, Exchange, FIX::EXCHANGE, NUM)
    00572 #define USER_DEFINE_UTCTIMESTAMP( NAME, NUM ) \
    00573   DEFINE_FIELD_TIMECLASS_NUM(NAME, UtcTimeStamp, FIX::UTCTIMESTAMP, NUM)
    00574 #define USER_DEFINE_BOOLEAN( NAME, NUM ) \
    00575   DEFINE_FIELD_CLASS_NUM(NAME, Bool, FIX::BOOLEAN, NUM)
    00576 #define USER_DEFINE_LOCALMKTDATE( NAME, NUM ) \
    00577   DEFINE_FIELD_CLASS_NUM(NAME, String, FIX::STRING, NUM)
    00578 #define USER_DEFINE_DATA( NAME, NUM ) \
    00579   DEFINE_FIELD_CLASS_NUM(NAME, Data, FIX::DATA, NUM)
    00580 #define USER_DEFINE_FLOAT( NAME, NUM ) \
    00581   DEFINE_FIELD_CLASS_NUM(NAME, Float, FIX::FLOAT, NUM)
    00582 #define USER_DEFINE_PRICEOFFSET( NAME, NUM ) \
    00583   DEFINE_FIELD_CLASS_NUM(NAME, PriceOffset, FIX::PRICEOFFSET, NUM)
    00584 #define USER_DEFINE_MONTHYEAR( NAME, NUM ) \
    00585   DEFINE_FIELD_CLASS_NUM(NAME, MonthYear, FIX::MONTHYEAR, NUM)
    00586 #define USER_DEFINE_DAYOFMONTH( NAME, NUM ) \
    00587   DEFINE_FIELD_CLASS_NUM(NAME, DayOfMonth, FIX::DAYOFMONTH, NUM)
    00588 #define USER_DEFINE_UTCDATE( NAME, NUM ) \
    00589   DEFINE_FIELD_CLASS_NUM(NAME, UtcDate, FIX::UTCDATE, NUM)
    00590 #define USER_DEFINE_UTCDATEONLY( NAME, NUM ) \
    00591   DEFINE_FIELD_CLASS_NUM(NAME, UtcDateOnly, FIX::UTCDATEONLY, NUM)
    00592 #define USER_DEFINE_UTCTIMEONLY( NAME, NUM ) \
    00593   DEFINE_FIELD_CLASS_NUM(NAME, UtcTimeOnly, FIX::UTCTIMEONLY, NUM)
    00594 #define USER_DEFINE_NUMINGROUP( NAME, NUM ) \
    00595   DEFINE_FIELD_CLASS_NUM(NAME, NumInGroup, FIX::NUMINGROUP, NUM)
    00596 #define USER_DEFINE_SEQNUM( NAME, NUM ) \
    00597   DEFINE_FIELD_CLASS_NUM(NAME, SeqNum, FIX::SEQNUM, NUM)
    00598 #define USER_DEFINE_LENGTH( NAME, NUM ) \
    00599   DEFINE_FIELD_CLASS_NUM(NAME, Length, FIX::LENGTH, NUM)
    00600 #define USER_DEFINE_PERCENTAGE( NAME, NUM ) \
    00601   DEFINE_FIELD_CLASS_NUM(NAME, Percentage, FIX::PERCENTAGE, NUM)
    00602 #define USER_DEFINE_COUNTRY( NAME, NUM ) \
    00603   DEFINE_FIELD_CLASS_NUM(NAME, Country, FIX::COUNTRY, NUM)
    00604 #define USER_DEFINE_TZTIMEONLY( NAME, NUM ) \
    00605   DEFINE_FIELD_CLASS_NUM(NAME, String, FIX::TZTIMEONLY, NUM)
    00606 #define USER_DEFINE_TZTIMESTAMP( NAME, NUM ) \
    00607   DEFINE_FIELD_CLASS_NUM(NAME, String, FIX::TZTIMESTAMP, NUM)
    00608 #define USER_DEFINE_XMLDATA( NAME, NUM ) \
    00609   DEFINE_FIELD_CLASS_NUM(NAME, String, FIX::XMLDATA, NUM)
    00610 #define USER_DEFINE_LANGUAGE( NAME, NUM ) \
    00611   DEFINE_FIELD_CLASS_NUM(NAME, String, FIX::LANGUAGE, NUM)
    00612
    00613 #endif
    00614