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 

Generated on Mon Apr 5 20:59:50 2010 for QuickFIX by doxygen 1.6.1 written by Dimitri van Heesch, © 1997-2001