ProgrammersGuide.h

Go to the documentation of this file.

/*! \mainpage FIXForge C++ FIX Engine - Programmer's Guide

\section Content Content

<ul>
      <li>\ref Introduction </li>
      <li>\ref SystemRequirements</li>
<li>\ref GettingStarted
        <ul>
              <li>\ref Error-reporting</li>
              <li>\ref Engine</li>
              <li>\ref Version</li>
                <li>\ref Message
                    <ul>
                    <li>\ref Fields</li>
                    </ul>
                </li>
                <li>\ref Session    
                <ul>
                  <li>\ref MessageExchange</li> 
                  <li>\ref SequenceNumbers</li>
                </ul>
                </li> 
        </ul>
</li>
<li>\ref Administration 
        <ul>
            <li>\ref LicenseFile</li>
            <li>\ref PersistentMessagesStorage</li>
          <li>\ref Settings</li> 
        </ul>
</li>
<li>\ref Advanced
    <ul>
      <li>\ref RepeatingGroup</li> 
      <li>\ref SessionStates</li> 
      <li>\ref SessionEvents</li> 
      <li>\ref CustomLogonMessage</li> 
      <li>\ref Dialects</li> 
      <li>\ref ResendRequestProcessing</li>
      <li>\ref AcceptingFixSessionWithoutCreationSessionObject</li>
    </ul>
</li> 
<li>\ref SslEncryption</li>
<li>\ref FAST</li>
<li>\ref FrequentlyAskedQuestions</li> 
<li>\ref Glossary</li> 
<li>\ref Resources</li> 
</ul>

\section Introduction Introduction

<a href="http://www.onixs.biz/">Onix Solutions</a> FIXForge C++ FIX Engine is a C++ library that will FIX-enable applications written in C++.
The FIX Engine provides the following services:
 <ul> 
    <li>manages a network connection</li> 
    <li>manages the session layer (for the delivery of application messages)</li> 
    <li>manages the application layer (defines business related data content)</li> 
    <li>creates (outgoing) messages</li> 
    <li>parses (incoming) messages</li> 
    <li>validates messages</li> 
    <li>persists messages (the ability to log data to a flat file)</li> 
    <li>session recovery in accordance with the FIX state model</li> 
  </ul> 
\subsection SystemRequirements System Requirements

 \subsubsection DevelopmentEnvironment Development environment:
  <ul> 
    <li>Microsoft Visual Studio .NET 2003</li> 
    <li>Microsoft Visual Studio .NET 2005</li>
    <li>Microsoft Visual Studio .NET 2008</li>
    <li>Linux Kernel 2.6, gcc</li>
    <li>Sun Solaris, Sun Studio 12</li>
  </ul> 
  \subsubsection DeploymentEnvironment Deployment environment:
  <ul> 
    <li>Microsoft Windows NT 4.0 (Service Pack 6 recommended), Windows 2000, Windows XP, Windows Server 2003, Windows Vista.</li> 
    <li>Linux Kernel 2.6</li>
    <li>Sun Solaris</li>
  </ul> 

 \section GettingStarted Getting Started 
  All FIX Engine classes are located in the FIXForge::FIX namespace, header files are assembled in the FIXForge_FIXEngine.h header file. 
  The typical way of using the Engine is as follows: 
  <ol start=1 type=1> 
    <li>Initialize the \ref Engine .</li> 
    <li>Create the \ref Session object.</li> 
    <li>Establish the \ref FIX_Session "FIX session" as \ref Initiator "Initiator" or \ref Acceptor "Acceptor".</li> 
    <li>Send and receive application-level \ref Message "FIX messages".</li> 
    <li>Disconnect the session.</li> 
    <li>Shutdown the Engine.</li> 
  </ol> 

   \subsection Error-reporting Error-reporting 

  Exception handling is used as a fundamental error-reporting mechanism. In the event of any errors arising the
 FIXForge::FIX::EngineException is thrown.
 
\subsubsection Engine Engine 

  To initialize the FIX Engine class library one of the FIXForge::FIX::Engine::init methods is used. 
\warning This method must be called before all other FIX Engine library methods.

  The FIXForge::FIX::Engine::init(const std::string& configFile) method is used to specify the \ref Settings "configuration file". 

  To shutdown the Engine the FIXForge::FIX::Engine::shutdown method is used.
  \warning No other FIX Engine library methods must be called after this method.

 Example: 
\code 
#include <FIXForge_FIXEngine.h>

using namespace FIXForge::FIX;

try{
    Engine::init();

    // Session-related logic...

    Engine::shutdown();
}catch(const EngineException& ex){
    clog << "Exception: " << ex.what() << endl;
}
\endcode

\subsubsection Version FIX Version 

As the FIX protocol evolves its new versions will be released to you to extend the current functionality.  
  Supported FIX versions are: FIX 4.0, FIX 4.1, FIX 4.2, FIX 4.3 and FIX 4.4. The FIXForge::FIX::Version enum is used to identify them. 

Example: 
\code
Version currentFixVersion = FIX_44;
\endcode

Each FIX version has its own namespace that contains objects that are unique for the version, e.g.: 
\code
using namespace FIXForge::FIX::FIX40;
\endcode

\subsubsection Message Message 
  The general format of a FIX message is a stream of <tag=value> fields with a \ref DelimiterCharacter "field delimiter (SOH)" 
     between fields in the stream (so-called "tag=value FIX format"). 

  Below is an example of a FIX message:   
  \image html FIXMessage.gif

  It is represented with the FIXForge::FIX::Message class. 

  <strong>To create a message</strong> the FIXForge::FIX::Message(const std::string& type, FIXForge::FIX::Version version) constructor is used. 

  <strong>To parse a message</strong> in the raw (tag=value) FIX format the FIXForge::FIX::Message(const std::string& rawMessage) constructor is used. 

  <strong>To validate a message</strong> the FIXForge::FIX::Message::validate method is used. 
    This method checks for the presence of \ref RequiredFields "required fields". 

  There are several overloaded methods FIXForge::FIX::Message::toString() to simplify debugging and monitoring.
  To update the <a href="http://www.onixs.biz/fixdictionary/4.2/tagNum_9.html">BodyLength (9)</a> 
  and <a href="http://www.onixs.biz/fixdictionary/4.2/tagNum_10.html">CheckSum (10)</a> fields 
  the FIXForge::FIX::Message::updateCheckSum() method is used. 

  Example:
\code
#include <FIXForge_FIXEngine.h>

using namespace FIXForge::FIX;

{
    Message order("D", FIX_42); // New Order - Single (MsgType = D)
    order.updateCheckSum();
    clog << "Order" << order << endl;
}

{
    string rawMsg = "8=FIX.4.0\0x019=86\0x0135=D\0x0149=0\0x0156=0\0x0134=1\0x0152=99990909-17:17:17\0x0111=90001008\0x0121=1\0x0155=IBM\0x0154=1\0x0138=10\0x0140=1\0x0159=0\0x0110=191\0x01";
    Message order(rawMsg);
    order.validate();

    clog << order.toString() << endl;
    clog << order.toString(' ') << endl;
    clog << order.toString(Message::TAG_NAME | Message::TAG_NUMBER) << endl;
}
\endcode

\subsubsection Fields Fields 

<strong>To set a field value</strong> the FIXForge::FIX::Message::set method is used. 

<strong>To get a field value</strong> the FIXForge::FIX::Message::get method is used. 

Example: 
\code
#include <FIXForge_FIXEngine.h>

using namespace FIXForge::FIX;
using namespace FIXForge::FIX::FIX40;

Message order("D", FIX_40); // New Order - Single

order.set(11, "Unique identifier of execution message");
string ClOrdID = order.get(11);
\endcode

<strong>To remove a field</strong> the FIXForge::FIX::Message::remove method is used. 

The FIXForge::FIX::FIX42::Tags class contains the constants for the tag values. This class is defined for each FIX version namespace. 
    The use of these constants makes the source code more readable.  

Example: 
\code
#include <FIXForge_FIXEngine.h>

using namespace FIXForge::FIX;
using namespace FIXForge::FIX::FIX40;

Message order("D", FIX_40); // New Order - Single
order.set(Tags::ClOrdID, "90001008");
order.set(Tags::Side, "1");
order.set(Tags::TimeInForce, "0");
\endcode

\see \ref RepeatingGroup "Repeating Group".

\subsubsection Session Session 

A FIX session is defined as a bi-directional stream of ordered messages between two parties within a continuous sequence number series. 
It is represented by the FIXForge::FIX::Session class. 

To create a session the FIXForge::FIX::Session's constructors are used. 

To terminate the session the FIXForge::FIX::Session::shutdown method is used. 

A session has one of two possible roles: <strong>Acceptor</strong> or <strong>Initiator</strong>. 

<strong>Acceptor</strong> is the receiving party of the FIX session. It listens for the incoming connection on the pre-defined port. 
    The acceptor has responsibility to perform first level authentication and formally declare the connection request "accepted" through transmission of an acknowledgment <i>Logon</i> message.
 
<strong>Initiator</strong> establishes the telecommunications link and initiates the session via transmission of the initial 
<a href="http://onixs.biz/fixdictionary/4.3/msgType_A_65.html">Logon</a> message. 

To obtain the current role the FIXForge::FIX::Session::getRole method is used. 

To establish the session as Acceptor the FIXForge::FIX::Session::logonAsAcceptor method is used. 

To establish the session as Initiator the FIXForge::FIX::Session::logonAsInitiator method is used. 

To disconnect the session the FIXForge::FIX::Session::logout method is used. 

Example: 
\code
#include <FIXForge_FIXEngine.h>

using namespace FIXForge::FIX; 
using namespace FIXForge::FIX::FIX40;

const string SENDER_COMP_ID = "SenderCompID";
const string TARGET_COMP_ID = "TargetCompID";
const Version VERSION = FIX_40;
const string HOST = "Localhost";
int ACCEPTOR_PORT = Engine::instance()->getListenPort();

ISessionListener listener;

Session acceptor(SENDER_COMP_ID, TARGET_COMP_ID, VERSION, &listener);
Session initiator(TARGET_COMP_ID, SENDER_COMP_ID, VERSION, &listener);

acceptor.logonAsAcceptor(); 
initiator.logonAsInitiator(HOST, ACCEPTOR_PORT); // Sends the Logon message and waits for the acknowledgment Logon

// Message exchange and processing ...

acceptor.logout(); // Sends the Logout message and waits for the confirming Logout
initiator.logout();

acceptor.shutdown(); // Free resources
initiator.shutdown(); // Free resources
\endcode

\see \ref SessionStates, \ref CustomLogonMessage, \ref SequenceNumbers. 

\subsubsection MessageExchange Message Exchange 

To send a message to counterparty the FIXForge::FIX::Session::send method is used. 
  As soon as a session is created it is possible to start sending messages via the session. 
   If the session is not established, the messages will be sent when the connection is established with the counterparty. 

To receive incoming application-level messages it is necessary to override the 
FIXForge::FIX::ISessionListener::onInboundApplicationMsg method. 

Example: 
\code
#include <FIXForge_FIXEngine.h>

using namespace FIXForge::FIX;
using namespace FIXForge::FIX::FIX42;

class SessionListener : public ISessionListener{
    public:
    
    virtual void onInboundApplicationMsg(const Message& msg, Session* sn){
        clog << "Incoming application-level message: " << msg << endl;
        // processing of the application-level incoming message...
    }
};

const string SENDER_COMP_ID = "AcceptorAndInitiator_SND";
const string TARGET_COMP_ID = "AcceptorAndInitiator_TRG";

const Version VERSION = FIX_42;

const string ACCEPTOR_HOST = "localhost";
int ACCEPTOR_PORT = Engine::instance()->getListenPort();

SessionListener listener;

Session acceptor(SENDER_COMP_ID, TARGET_COMP_ID, VERSION, &listener);
acceptor.logonAsAcceptor();

Session initiator(TARGET_COMP_ID, SENDER_COMP_ID, VERSION, &listener);
initiator.logonAsInitiator(ACCEPTOR_HOST, ACCEPTOR_PORT);

Message order("D", VERSION); 

order.set(Tags::ClOrdID, "Unique identifier for Order as assigned by the buy-side");
order.set(Tags::HandlInst, "1");
order.set(Tags::Symbol, "Ticker symbol");
order.set(Tags::Side, "1");
order.set(Tags::TransactTime, "20051012-22:10:11");
order.set(Tags::OrdType, "1");

order.validate();

acceptor.send(&order);

// continue the message exchange...

acceptor.logout();
initiator.logout();

acceptor.shutdown(); 
initiator.shutdown();
\endcode

\subsubsection SequenceNumbers Sequence Numbers 

All FIX messages are identified by a unique sequence number (the FIXForge::FIX::Message::getSeqNum() method).  

  Sequence numbers are initialized at the start of each \ref FIX_Session "FIX Session" starting at 1 (one) and increment throughout the session.
Each session establishes an independent incoming and outgoing sequence series. 
  A single FIX session can exist across multiple sequential (not concurrent) physical connections. 
Parties can connect and disconnect multiple times while maintaining a single FIX session.

In other words, FIX Session is comprised of one or more \ref FIX_Connection "FIX Connections". 

  Resetting the inbound and outbound sequence numbers back to 1, for whatever reason, constitutes the beginning of a new FIX session. 
  Monitoring sequence numbers enables parties to gracefully synchronize applications when reconnecting during a FIX session.  

  To get or set the expected sequence number of the next incoming message the FIXForge::FIX::Session::getInSeqNum(), 
  FIXForge::FIX::Session::setInSeqNum() methods are used. 

  To get or set the sequence number of the next outgoing message the FIXForge::FIX::Session::getOutSeqNum(), FIXForge::FIX::Session::setOutSeqNum() methods are used. 

  To disconnect the FIX Connection while maintaining a single FIX Session the FIXForge::FIX::Session::logout() method is used. 

    It is possible to continue the session later using the FIXForge::FIX::Session::logonAsAcceptor() 
    or FIXForge::FIX::Session::logonAsInitiator() methods again.
 
  To terminate a FIX Session the FIXForge::FIX::Session::shutdown() method is used. 
   
  The Engine automatically synchronizes sequence numbers when reconnecting during a FIX session on the base of the information previously stored in log files.

  To synchronize sequence numbers manually FIXForge::FIX::Session::setInSeqNum() and FIXForge::FIX::Session::setOutSeqNum() methods 
  are used (<strong>before</strong> FIXForge::FIX::Session::logonAsAcceptor() or 
        FIXForge::FIX::Session::logonAsInitiator() method calls). 

        \image html SequenceNumbers.gif

  Some implementations of FIX protocol (\ref FIX_Dialect "FIX Dialects") expect that the \ref FIX_Session "FIX Session" coincides with 
    \ref FIX_Connection "FIX Connection", in other words that the sequence numbers are reset back to 1 after the Logout messages exchange.  
  To interact with such FIX dialects, the keepSequenceNumbersAfterLogout parameter of 
    FIXForge::FIX::Session's constructor should be set to <var>false</var>.

In this case after FIXForge::FIX::Session::shutdown() method sequence numbers are set back to 1. Next time when the FIXForge::FIX::Session object is created incoming and outgoing sequence numbers will start from 1 (in other words, a new FIX Session will be created). 

\section Administration Administration 

\subsection LicenseFile License File

 The license file (FIXForge.Cpp.FIX.Engine.lic) is taken from the current directory. 
 
 It is possible to specify the absolute path to the license file using the \ref Settings_LicenseFile "LicenseFile" configuration setting.

\subsection PersistentMessagesStorage Persistent message storage and the log files

  The MsgStorage folder must be created for storing log data. 
   Incoming and outgoingmessages, session's state data and the FIX Engine log file (FixEngineLog.txt) are stored in this folder.
   
  For each FIX session two files are created: 
<ul>
   <li>SESSION_NAME.summary - contains both inbound and outbound FIX messages.</li>
  <li>SESSION_NAME.state - contains session state data.</li> 
</ul>
  SESSION_NAME is formed on the base of \ref SenderCompID_field "SenderCompID", \ref TargetCompID_field "TargetCompID" and a timestamp. 

  When the FIXForge::FIX::Session object is created anew after the Engine's restart, FIX Session's state (the sequence numbers of last received and sent messages, previously sent messages, etc) is restored from these files.  

  To start a FIX session as a new one (so called "clean start"), it is necessary to remove the log files from the previous runs. 

  Connecting parties must bi-laterally agree as to when sessions are to be started/stopped and log files are backed up based upon individual system and time zone requirements.

  When the FIX session is finished, the log files are not needed anymore. They can be backed up and later a new FIX session with the same SenderCompID and TargetCompID will start 
  sequence numbers from 1. The usual practice is to backup the log files at the end of each business day (so called "End Of Day procedure") 
to start the sequence numbers from 1 at the beginning of the next day. 

  \see 
  \ref Settings_Log_Directory "Log.Directory", 
  \ref Settings_Log_FlushFileAfterEachMessage "Log.FlushFileAfterEachMessage",
  \ref Settings_Log_InboundMessages "Log.InboundMessages",
  \ref SequenceNumbers.

\subsubsection Settings Settings 

The default values of FIX Engine settings can be changed using the configuration file that is given as a parameter of 
FIXForge::FIX::Engine::init(const std::string& configFile) method.

  Example: 
\code
<?xml version="1.0" encoding="utf-8" ?>
<configuration>

    <configSections>
        <section name="FixEngine" type="System.Configuration.NameValueSectionHandler"/>
    </configSections>

    <FixEngine>
        <add key="Dialect" value="LavaDialect.xml"/> 
        <add key="ListenPort" value="4500"/>
        <add key="Log.InboundMessages" value="true"/>
        <add key="Validate.NumberOfRepeatingGroupInstances" value="false"/> 
        <add key="Validate.RequiredFields" value="true"/>
        <add key="Resending.QueueSize" value="2500"/>
        <add key="Validate.UnknownFields" value="true"/>
        <add key="Validate.UnknownMessages" value="true"/>
    </FixEngine> 
</configuration>
\endcode

<table border=1 cellspacing=0 cellpadding=0> 
    <caption>FIX Engine configuration settings</caption>
    <tr> 
      <th>Setting</th> 
      <th>Description</th> 
      <th>Default value</th> 
    </tr> 

    <tr> 
      <td>\anchor Settings_ConnectionRetries_Number ConnectionRetries.Number</td> 
      <td>Number of attempts to restore the telecommunication link.</td> 
      <td class="constant">3</td> 
    </tr> 

    <tr> 
      <td>\anchor Settings_ConnectionRetries_Interval ConnectionRetries.Interval</td> 
      <td>The time interval between the attempts to restore the telecommunication link (in seconds).</td> 
      <td class="constant">30</td> 
    </tr> 

    <tr> 
      <td>Dialect</td> 
      <td>Specify the path to the XML file with the description of the \ref Dialects "FIX Dialect".</td> 
      <td>Empty</td> 
    </tr>

    <tr> 
      <td>\anchor Settings_LicenseFile LicenseFile</td> 
      <td>Specify the path to the license file.</td> 
      <td>FIXForge.Cpp.FIX.Engine.lic</td> 
    </tr>

    <tr>
      <td>ListenPort</td>
      <td>FIX Engine listens on this port for incoming connections. <br>
        &nbsp;&nbsp;&nbsp;If '0' then only session-initiators can be created. <br>
      &nbsp;&nbsp;&nbsp;If '-1' then the telecommunication level is disabled and only message parsing/assembling can be used.</td>
      <td class="constant">0</td>
    </tr> 
    <tr> 
      <td>\anchor Settings_Log_Directory Log.Directory</td> 
      <td> Inbound and outboundmessages, session's state data and the FIX Engine log file (FixEngine.log) are stored in this directory.</td> 
      <td class="fileSystem">MsgStorage</td> 
    </tr> 
    <tr> 
      <td>\anchor Settings_Log_FlushFileAfterEachMessage Log.FlushFileAfterEachMessage</td> 
      <td>Option to flush output files after each logged message.</td> 
      <td class="constant">True</td> 
    </tr> 
    <tr> 
      <td>\anchor Settings_Log_InboundMessages Log.InboundMessages</td>
        <td>Option to log inbound messages.</td>
        <td class="constant">True</td> 
    </tr> 

    <tr> 
      <td>\anchor Settings_Log_SessionSummary Log.SessionSummary</td>
        <td>Option to create a summary log file with inbound and outbound messages (in *.summary file).</td>
        <td class="constant">True</td> 
    </tr> 

 <tr> 
      <td>Resending.QueueSize</td> 
      <td>Number of sent messages that are available for resending on counterparty's <a href="http://www.onixs.biz/fixdictionary/4.0/msgType_2_2.html">Resend Request <2></a> message. </td> 
      <td class="constant">1000</td> 
    </tr>

     <tr> 
      <td>\anchor SslCertificateFile SSL.CertificateFile</td> 
      <td>The path to the SSL certificate file in (Privacy Enhanced Mail) Base64 encoded (.pem) format.</td> 
      <td class="constant">Empty</td> 
    </tr>     

    <tr> 
      <td>SSL.ListenPort</td> 
      <td>FIX Engine listens on this port for incoming SSL connections. If it is set to '0' then only SSL-based session-initiators can be created. If '-1' then the SSL encryption is disabled. 
</td> 
      <td class="constant">0</td> 
    </tr>     

     <tr> 
      <td>\anchor SslPrivateKeyFile SSL.PrivateKeyFile</td> 
      <td>The path to the SSL private key file in (Privacy Enhanced Mail) Base64 encoded (.pem) format.</td> 
      <td class="constant">Empty</td> 
    </tr>    

    <tr> 
      <td>SSL.PrivateKeyPassword</td> 
      <td>The password to load private keys that are protected by a password.</td> 
      <td class="constant">Empty</td> 
    </tr>   

    <tr> 
      <td>SSL.VerifyPeer</td> 
      <td>Option to request client certificates and perform the certificate verification.</td> 
      <td class="constant">False</td> 
    </tr>   

    <tr> 
      <td>Validate.NumberOfRepeatingGroupInstances</td> 
      <td>Option to validate that the declared number of \ref RepeatingGroup instances is equal to the actual one.</td> 
      <td class="constant">True</td> 
    </tr> 
    <tr> 
      <td>Validate.RequiredFields</td> 
      <td>Option to validate the presence of \ref RequiredFields "required fields" in inbound and outbound messages.</td> 
      <td class="constant">False</td> 
    </tr> 
    <tr> 
      <td>Validate.UnknownFields</td> 
      <td>Option to validate the presence of unknown fields (fields that do not belong to the message in accordance with 
      the FIX protocol or its \ref FIX_Dialect "FIX Dialect".</td> 
      <td class="constant">False</td> 
    </tr> 

    <tr> 
      <td>Validate.UnknownMessages</td> 
      <td>Option to validate the presence of unknown FIX messages (messages that do not belong to the message in accordance with 
      the FIX protocol  or its \ref FIX_Dialect "FIX Dialect".</td> 
      <td class="constant">False</td> 
    </tr> 

  </table> 

  \see \ref Engine

\section Advanced Advanced

\subsection RepeatingGroup Repeating Group 

 It is permissible for fields to be repeated in the same message within a repeating group. 
For example, <pre>"215=2<SOH></a>216=2<SOH>217=Dest_1<SOH>216=4<SOH>217=Dest_2<SOH>"</pre>
 represents a repeating group with two repeating instances "delimited" by tag <strong>216</strong> (first field in the repeating group.). 
  The NoRoutingIDs<215> field specifies the number of repeating group instances (2 in this case). This is so called <strong>NumberOfInstances field</strong>. 
    The NumberOfInstances field must immediately precede the repeating group contents (repeating group instances). 

 \image html RepeatingGroup.gif

The FIX repeating group is represented with the FIXForge::FIX::Group class. 

To get the Group object that represents the existing repeating group of the message the 
FIXForge::FIX::Message::getGroup(int numberOfInstancesTag) method is used.  

To create a new repeating group or modify the number of instances in the existing one the 
FIXForge::FIX::Message::setGroup(int numberOfInstancesTag, int numberOfInstances) method is used. 

To remove a repeating group method FIXForge::FIX::Message::remove(int numberOfInstancesTag) is used. 

The FIXForge::FIX::Group class works with fields and embedded repeating groups in the same manner as the FIXForge::FIX::Message class, 
but each method has an additional parameter that defines the index of the repeating group instance (starting from 0). 

<strong>Note:</strong> To avoid memory leaks call FIXForge::FIX::Group::release().

  Example: 
\code
#include <FIXForge_FIXEngine.h>

using namespace FIXForge::FIX;
using namespace FIXForge::FIX::FIX42;

Message request("V", FIX_42);

request.set(Tags::MDReqID, "ABSD");
request.set(Tags::SubscriptionRequestType, 1);
request.set(Tags::MarketDepth, 1);
request.set(Tags::MDUpdateType, 1);
request.set(Tags::AggregatedBook, "N");

// create a repeating group NoMDEntryTypes with two instances
Group* groupMDEntryTypes = request.setGroup(Tags::NoMDEntryTypes, 2);

groupMDEntryTypes->set(Tags::MDEntryType, 0, "EntryType_1"); // first instance
groupMDEntryTypes->set(Tags::MDEntryType, 1, "EntryType_2"); // second instance

groupMDEntryTypes->release(); // to free resources

// create a repeating group NoRelatedSym with two instances
Group* groupRelatedSym = request.setGroup(Tags::NoRelatedSym, 2);

groupRelatedSym->set(Tags::Symbol, 0, "EURUSD_0"); // first instance
groupRelatedSym->set(Tags::Symbol, 1, "EURUSD_1"); // second instance

groupRelatedSym->release(); // to free resources

request.validate();

clog << request << endl;
\endcode

\subsection SessionStates Session States 

To obtain the current session state the FIXForge::FIX::Session::getState() method is used. 

  The states of the FIX session are listed below. 
  <table  border=1 cellspacing=0 cellpadding=0> 
    <caption>FIX Session states</caption>
    <tr> 
      <th width=190 rowspan=2>State</th> 
      <th width=489 colspan=2>Description</th> 
    </tr> 
    <tr> 
      <td width=237>Role == <strong>Acceptor</strong></td> 
      <td width=252>Role == <strong>Initiator</strong></td> 
    </tr> 
    <tr> 
      <td width=190>DISCONNECTED</td> 
      <td width=489 colspan=2>The session is disconnected.</td> 
    </tr> 
    <tr> 
      <td width=190>\anchor State_LOGON_IN_PROGRESS  LOGON_IN_PROGRESS</td> 
      <td width=237> The session is waiting for the initial <i>Logon</i> message.</td> 
      <td width=252> The initial <i>Logon</i> message was sent and the session is waiting for the acknowledgment <i>Logon</i> message.</td> 
    </tr> 
    <tr> 
      <td width=190> ACTIVE</td> 
      <td width=489 colspan=2> The session is fully established (after the successful <i>Logon</i> exchange).</td> 
    </tr> 
    <tr> 
      <td width=190>\anchor State_RECONNECTING RECONNECTING</td> 
      <td width=237>N/A (only session-initiator can be in this state).</td> 
      <td width=252> Session-initiator is trying to restore the telecommunication link.</td> 
    </tr> 
    <tr> 
      <td width=190> LOGOUT_IN_PROGRESS</td> 
      <td width=489 colspan=2> The initial Logout message was sent and the session is waiting for the acknowledgment Logout message.</td> 
    </tr> 
  </table> 

  To be notified about the changes in the session stateoverwrite the FIXForge::FIX::ISessionListener::onStateChange method. 
  
Example:
\code
class Listener : public ISessionListener{
public :
    virtual void Listener::onStateChange(Session::State newState, Session::State prevState, Session* sn){       
        clog << "\nSession's state is changed, prevState=" << Session::state2string(prevState) 
             << ", newState=" << Session::state2string(newState) << endl;
    }
};
\endcode

\subsection SessionEvents Session Events 

To be notified about session events overwrite the FIXForge::FIX::ISessionListener class methods. 

The methods of the FIXForge::FIX::ISessionListener class are listed below.

<table border=1 cellspacing=0 cellpadding=0> 
    <caption>Session events</caption>
    <tr> 
      <th width=367>Method (Event handler)</th> 
      <th width=367>Description</th> 
    </tr> 
    <tr> 
      <td width=367>onStateChange</td> 
      <td width=367>Session state is changed.</td> 
    </tr> 
    <tr> 
      <td width=367>onError</td> 
      <td width=367>Error condition is detected.</td> 
    </tr> 
    <tr> 
      <td width=367>onInboundApplicationMsg</td> 
      <td width=367>Application-level message is received from the counterparty.</td> 
    </tr> 
    <tr> 
      <td width=367>onInboundSessionMsg</td> 
      <td width=367>Session-level message is received from the counterparty.</td> 
    </tr> 
    <tr> 
      <td width=367>onOutboundApplicationMsg</td> 
      <td width=367>Application-level message will be sent to the counterparty.</td> 
    </tr> 
    <tr> 
      <td width=367>onOutboundSessionMsg</td> 
      <td width=367>Session-level message will be sent to the counterparty.</td> 
    </tr> 

    <tr> 
      <td width=367>onResendRequest</a></td> 
      <td width=367>Sent application-level message is about to be resent to the counterparty.</td> 
    </tr> 
    <tr> 
      <td width=367>onWarning</td> 
      <td width=367>Warning condition is detected.</td> 
    </tr> 
</table> 

  \warning It is important not perform time-consuming tasks inside event handlers. 

\subsection CustomLogonMessage Custom Logon Message 

Sometime there is need to set additional fields (e.g. <a href="http://onixs.biz/fixdictionary/5.0/tagNum_553.html">Username (553)</a>,
<a href="http://onixs.biz/fixdictionary/5.0/tagNum_554.html">Password (554)</a>) in the initiation 
<a href="http://onixs.biz/fixdictionary/4.1/msgType_A_65.html">Logon</a> message. 
In this case the FIXForge::FIX::Session::logonAsInitiator(const std::string &host, int port, int heartBtInt, Message *customLogonMsg) method must be used.
 
Example: 
\code
#include <FIXForge_FIXEngine.h>

using namespace FIXForge::FIX;
using namespace FIXForge::FIX::FIX43;

const string SENDER_COMP_ID = "CustomLogonMessage_SND";
const string TARGET_COMP_ID = "CustomLogonMessage_TRG";

const Version VERSION = FIX_43;

const int HBI = 30;
const string USERNAME = "USER_NAME";
const string PASSWORD = "PASSWORD";

int port = Engine::instance()->getListenPort();

ISessionListener listener;

Session acceptor(SENDER_COMP_ID, TARGET_COMP_ID, VERSION, &listener);
acceptor.logonAsAcceptor();
Session initiator(TARGET_COMP_ID, SENDER_COMP_ID, VERSION, &listener);

Message customLogonMsg("A", FIX_43);

customLogonMsg.set(Tags::Username, USERNAME);
customLogonMsg.set(Tags::Password, PASSWORD);

initiator.logonAsInitiator("localhost", port, HBI, &customLogonMsg);

// message exchange and processing ...

acceptor.logout();
initiator.logout();

acceptor.shutdown();
initiator.shutdown();
\endcode

\subsection Dialects FIX Dialects 

It is not uncommon for firms to implement slightly different interpretations of the FIX protocol (dialects), 
so sometime there is need to validate that such messages confirm to a particular FIX dialect. 
 
The FixEngine.Dialect \ref Settings "configuration setting" specifies the description of such dialects in XML format. 
This description must confirm to the <a href="Dialect.xsd">Dialect.xsd</a> XML Schema file. 

<strong>To add a new user-defined field to a FIX Message </strong>add the corresponding Field entity to the FIX Dialect description.
For example: 

\code
<FIX version="4.0">
    <Message type="D">
        <Field tag="526" name="SecondaryClOrdID"/> <!-- Does not belong to Standard FIX 4.0 --> 
    </Message> 
</FIX>
\endcode

<strong>To add a new user-defined repeating group to a FIX Message </strong>add the corresponding Group entity to the FIX Dialect description.
For example: 
\code 
<FIX version="4.0">
    <Message type="D">
        <Group numberOfInstancesTag="78" name="NoAllocs"> <!-- Number of repeating groups for pre-trade allocation, does not belong to Standard FIX 4.0 -->
            <Field tag="79" name="AllocAccount"/> <!--  Does not belong to Standard FIX 4.0 --> 
            <Field tag="661" name="AllocAcctIDSource"/> <!--  Does not belong to Standard FIX 4.0 --> 
            <Field tag="736" name="AllocSettlCurrency"/> <!--  Does not belong to Standard FIX 4.0 --> 
            <!-- Other group fields -->
        </Group>
    </Message> 
</FIX>
\endcode

<strong>To make a field, which is required according to the FIX Protocol specification, optional, and visa-versa,
</strong> add  the corresponding Field entity to the FIX Dialect description and set the isRequired attribute accordingly. 
For example:
\code
  
<FIX version="4.0">
    <Message type="D">
        <Field tag="21" isRequired="false" name="HandlInst"/> <!-- Required in Standard FIX 4.0, but optional in this FIX dialect --> 
        <Field tag="109" isRequired="true" name="ClientID"/> <!-- Optional in Standard FIX 4.0, but required in this FIX dialect --> 
    </Message> 
</FIX>
\endcode

<strong>To define a User Defined Message</strong> add the corresponding Message entity to the FIX Dialect description.
For example: 
\code  
<FIX version="4.0">
    <Message type="UserDefinedMessage_1">
        <Field tag="100"/> 
        <Field tag="101"/> 
    </Message> 
</FIX>
\endcode

Such a user-defined message can be used exactly the same way as the standard FIX Message:
\code
Message udm_1("UserDefinedMessage_1", FIX_43);

udm_1.set(100, "Field 100");
udm_1.set(101, "Field 101");

udm_1.validate();

clog << "UDM: " << udm_1 << endl;
\endcode

Example of a FIX Dialect description file:
\code
<?xml version="1.0" encoding="utf-8"?>
<Dialect xmlns="http://tempuri.org/Dialect.xsd" name="Lava">

<FIX version="4.2"> 
    <Message type="N">      
        <Group numberOfInstancesTag="73" name="RefAllocID">
            <!-- An additional field in the existing repeating group -->
            <Field tag="37" name="OrderID"/>            
        </Group>
    </Message>
</FIX>
    
<FIX version="4.3">
    <Message type="y">
        <Group numberOfInstancesTag="146" name="NoRelatedSym">
            <!-- An additional field in the existing repeating group -->
            <Field tag="64" isRequired="true" name="FutSettDate"/>
        </Group>
    </Message>
        
    <Message type="W">
        <Group numberOfInstancesTag="268" name="NoMDEntries">
            <!-- An additional field in the existing repeating group -->
            <Field tag="278" name="MDEntryID"/>
        </Group>
        <Field tag="64" name="FutSettDate"/>
    </Message>
  
    <Message type="X">
        <!-- An additional field -->
        <Field tag="55" name="Symbol"/>

        <!-- An additional field -->
        <Field tag="64" name="FutSettDate"/>
    </Message>
</FIX>
</Dialect>
\endcode

 \subsection ResendRequestProcessing Resend Request processing 

When the <a href="http://www.onixs.biz/fixdictionary/4.0/msgType_2_2.html">Resend Request (4)</a> message is received 
from the counterparty and the application has overridden
the FIXForge::FIX::ISessionListener::onResendRequest() method, this method is called. 
Otherwise the sent application-level message is  re-sent immediately.

If the sent application-level message should not be resent to the counterparty (e.g. an aged order) then the FIXForge::FIX::ISessionListener::onResendRequest() method should return false. In this case the <a href="http://www.onixs.biz/fixdictionary/4.0/msgType_4_4.html">Sequence Reset-GapFill (4)</a> message will be sent instead.

\subsection AcceptingFixSessionWithoutCreationSessionObject Accepting FIX Session without the prior creation of the Session object

Sometimes it is required to accept an incoming FIX session 'on the fly', without the prior creation of the FIXForge::FIX::Session object and connecting it as Acceptor 
(for example, when the <a href="http://www.onixs.biz/fixdictionary/5.0/tagNum_49.html">SenderCompID</a> or 
<a href="http://www.onixs.biz/fixdictionary/5.0/tagNum_56.html">TargetCompID</a> of the incoming session is not known in advance). 

To perform this task, inherit from the FIXForge::FIX::IEngineListener class, overwrite the FIXForge::FIX::IEngineListener::onUnknownIncomingConnection method 
and register your listener object with the FIXForge::FIX::Engine instance using the FIXForge::FIX::Engine::registerListener method.

An automatically created FIXForge::FIX::Session object that corresponds to the incoming FIX connection is available via the <code>session</code> parameter of the FIXForge::FIX::IEngineListener::onUnknownIncomingConnection callback method.

To accept the incoming connection, set the <code>acceptConnection</code> parameter of the FIXForge::FIX::IEngineListener::onUnknownIncomingConnection callback method to <code>true</code>.  
To listen to incoming messsages register your class inhereted from from the FIXForge::FIX::ISessionListener using the FIXForge::FIX::Session::registerListener method.

Otherwise the incoming connection will be rejected and the created FIXForge::FIX::Session object will be disposed by the FIX Engine. 

To send the <a href="http://www.onixs.biz/fixdictionary/5.0/msgType_5_5.html">Logout</a> message before closing the rejected connection set the <code>rejectReason</code> parameter of the FIXForge::FIX::IEngineListener::onUnknownIncomingConnection callback method to the rejection description.

For example:

\code

class MyListener : public FIXForge::FIX::IEngineListener, public FIXForge::FIX::ISessionListener
{
    public:
        MyListener(bool acceptConnection, const string& rejectReason)
            : acceptConnection_(acceptConnection), rejectReason_(rejectReason), session_(NULL){;}

        ~MyListener()
        {
            delete session_;
        }       

        virtual void onUnknownIncomingConnection(const Message& incomingLogon, Session* session, bool* acceptConnection, std::string* rejectReason)
        {           
            *acceptConnection = acceptConnection_;

            if(acceptConnection_)
            {
                session_ = session;
                session_->registerListener(this); // To listen to incoming messsages.
            }
            else
            {
                *rejectReason = rejectReason_; // To send the Logout message before closing the rejected connection.
            }
        }

        virtual void onInboundApplicationMsg(const Message& message, Session* sn)
        {
            // ...
        }               

    private:
        FIXForge::FIX::Session* session_;
        bool acceptConnection_;     
};

// ...

MyListener listener(true, "");

Engine::instance()->registerListener(&listener);

\endcode

\section SslEncryption SSL encryption

To use the Ssl (Secure Sockets Layer) connectivity the following steps should be taken:

<ol>
<li>If the counterparty requires client-side SSL certificate set the \ref SslCertificateFile "SSL.CertificateFile" and \ref SslPrivateKeyFile "SSL.PrivateKeyFile" 
FIX Engine configuration settings. They can refer to the same file if it contains both the SSL certificate and the private key. </li>
<li>Set the encryption to FIXForge::FIX::Session::SSL using the FIXForge::FIX::Session::setEncryptionMethod() method right after the creation of the FIXForge::FIX::Session object. </li>
<li>Establish the FIX Connection \ref Session "as usual". </li>
</ol>

For example:
\code

ISessionListener listener;      

Session initiator("SenderCompIDValue", "TargetCompIDValue", FIX_42, &listener);
initiator.setEncryptionMethod(Session::SSL);
        
initiator.logonAsInitiator("localhost", 443, true);

// Message exchange ... 
                
initiator.logout("SSL connection is finished.");
initiator.shutdown();   

\endcode

\subsection FormatOfSslCertificates Format of SSL certificates

Only the (Privacy Enhanced Mail) Base 64 Encoded (<b>.pem</b>) SSL certificates are supported. 

To convert into this format from other format types, the openssl command-line tool could be used (http://www.openssl.org).

For example, to convert from "Personal Information Exchange - PKCS#12" (<b>.pfx</b>) to "Base64 Encoded" (<b>.pem</b>), the following command is run on the PFX file: 

\code
openssl pkcs12 -in <file_name>.pfx -out <file_name>.pem -nodes 
\endcode

\subsection PerSessionSslSettings Per-session SSL settings
Per-session SSL settings ara available via FIXForge::FIX::Session::setSslCertificateFile() and FIXForge::FIX::Session::setSslPrivateKeyFile() methods. 

For example:

\code
const string targetCompID = "CNX"; 
const string host = "TargetHost"; 

{ // Stream FIX Session 

    const string streamSenderCompID = "str"; 
    ISessionListener listener;  
    Session streamSession(streamSenderCompID, targetCompID, FIX_42, &listener); 
    streamSession.setEncryptionMethod(Session::SSL); 

    const string streamSslCertificateAndPrivateKeyFile = "str.pem"; 
    // If your counterpart performs the verification of your SSL certificate you need to set both SSL Certificate File and SSL Private Key File. 
    streamSession.setSslCertificateFile(streamSslCertificateAndPrivateKeyFile);
    streamSession.setSslPrivateKeyFile(streamSslCertificateAndPrivateKeyFile);

    const int streamPort = 442;
    streamSession.logonAsInitiator(host, streamPort, 30, true);

    clog << "Stream session is established" << endl;

    streamSession.logout();
}

{ // Trading FIX Session 

    const string tradingSenderCompID = "tr"; 
    ISessionListener listener;  
    Session tradingSession(tradingSenderCompID, targetCompID, FIX_42, &listener);
    tradingSession.setEncryptionMethod(Session::SSL); 

    const string tradingSslCertificateAndPrivateKeyFile = "tr.pem";
    // If your counterpart performs the verification of your SSL certificate you need to set both SSL Certificate File and SSL Private Key File.
    tradingSession.setSslCertificateFile(tradingSslCertificateAndPrivateKeyFile);
    tradingSession.setSslPrivateKeyFile(tradingSslCertificateAndPrivateKeyFile);

    const int tradingPort = 443;
    tradingSession.logonAsInitiator(host, tradingPort, 30, true);

    clog << "Trading session is established" << endl;

    tradingSession.logout();
}
\endcode

\section FAST FAST encoding and decoding

FAST (FIX Adapted for Streaming) is a binary encoding method for message oriented data streams.

FAST-related classes can be found in the FIXForge::FIX::FAST_1_1 namespace.

To encode a FIX message into a FAST stream the FIXForge::FIX::FAST_1_1::Encoder class is used.

For example:
\code
string xmlFastTemplate = readTextFile("UdpFastTemplate.xml");
const bool encodeEachMessageIndependently = true;
Encoder encoder(xmlFastTemplate, sourceFixMessage.getVersion(), encodeEachMessageIndependently);

const int fastTemplateID = 36;      
const size_t bufferSize = 1024;
char fastStreamChunk[bufferSize];
size_t chunkSize = encoder.encode(sourceFixMessage, fastTemplateID, fastStreamChunk, bufferSize);
\endcode

To decode a part of a FAST stream back into a FIX message the FIXForge::FIX::FAST_1_1::Decoder class is used.

For example:
\code
const bool decodeEachMessageIndependently = true;
Decoder decoder(xmlFastTemplate, sourceFixMessage.getVersion(), decodeEachMessageIndependently);

const Message& decodedMessage = decoder.decode(fastStreamChunk, chunkSize);
\endcode

\subsection FastTemplate FAST Template
Both FIXForge::FIX::FAST_1_1::Encoder and FIXForge::FIX::FAST_1_1::Decoder constructors require the string that contains XML-based FAST templates.

A FAST Template specifies the encoding and decoding rules in accordance with the FAST specification.

For example:
\code
<?xml version="1.0" encoding="utf-8"?>
<templates>
    <template name="Market Data - Incremental Refresh (X)" id="88">
        <uInt32 name="BodyLength" id="9"/>
        <string name="MessageType" id="35">
            <constant value="X" />
        </string>
        <string name="SenderCompID" id="49">
            <copy/>
        </string>
        <string name="TargetCompID" id="56">
            <copy/>
        </string>
        <uInt64 name="MsgSeqNum" id="34">
            <increment value="1"/>
        </uInt64>
        <string name="SendingTime" id="52">
            <tail/>
        </string>
        <string name="PosDupFlag" id="43" presence="optional">
            <default/>
        </string>
        <sequence name="MDEntries">
            <length name="NoMDEntries" id="268"/>
            <string name="MDUpdateAction" id="279"/>
            <string name="Symbol" id="55"/>
        </sequence>
        <string name="CheckSum" id="10"/>
    </template>
<templates>
\endcode

\subsection FieldTypes Field Types
The following field types are supported:

<table align="center"  width="100%" border="0" cellspacing="1" cellpadding="2">
<tr>
<td class="white"><table  width="100%"  border="1" cellspacing="1" cellpadding="5" class="white">
<tr class="th">
<th>Field</th>
<th>Example</th>
<th>Notes</th>
</tr>
<tr class="tr1">
<td valign="top"><strong>Signed 32-bit Integer</strong></td>
<td valign="top" class="keyWord">&lt;<span class="constant">int32</span> <span class="attribute">name</span>=&quot;MDEntrySize&quot; <span class="attribute">id</span>=&quot;271&quot; <span class="attribute">presence</span>=&quot;optional&quot;&gt;</td>
<td valign="top">Min value: -2147483648<br>Max value: 2147483647</td>
</tr>
<tr class="tr2">
<td valign="top"><strong>Unsigned 32-bit Integer</strong></td>
<td valign="top" class="keyWord">&lt;<span class="constant">uInt32</span> <span class="attribute">name</span>=&quot;BodyLength&quot; <span class="attribute">id</span>=&quot;9&quot;/&gt;</td>
<td valign="top">Min value: 0<br>Max value: 4294967295</td>
</tr>
<tr class="tr1">
<td valign="top"><strong>Signed 64-bit Integer</strong></td>
<td valign="top" class="keyWord">&lt;<span class="constant">int64</span> <span class="attribute">name</span>=&quot;MinQty&quot; <span class="attribute">id</span>=&quot;110&quot;/&gt;</td>
<td valign="top">Min value: -9223372036854775808<br>Max value: 9223372036854775807</td>
</tr>
<tr class="tr2">
<td valign="top"><strong>Unsigned 64-bit Integer</strong></td>
<td valign="top" class="keyWord">&lt;<span class="constant">uInt64</span> <span class="attribute">name</span>=&quot;MsgSeqNum&quot; <span class="attribute">id</span>=&quot;34&quot;/&gt;</td>
<td valign="top">Min value: 0<br>Max value: 18446744073709551615</td>
</tr>
<tr class="tr1">
<td valign="top"><strong>String</strong></td>
<td valign="top" class="keyWord">&lt;<span class="constant">string</span> <span class="attribute">name</span>=&quot;SenderCompID&quot; <span class="attribute">id</span>=&quot;49&quot;/&gt;</td>
<td valign="top">An optional charset attribute can be used to indicate the character set used in the string (&quot;ascii&quot; or &quot;unicode&quot;).</td>
</tr>
<tr class="tr2">
<td valign="top"><strong>Decimal</strong></td>
<td valign="top" class="keyWord">&lt;<span class="constant">decimal</span> <span class="attribute">name</span>=&quot;MDEntryPx&quot; <span class="attribute">id</span>=&quot;270&quot;&gt;<br>&lt;<span class="constant">exponent</span>/&gt;<br>&lt;<span class="constant">mantissa</span>/&gt;<br>&lt;/<span class="constant">decimal</span>&gt;</td>
<td valign="top">Indicates that the field is represented by two parts: an exponent and a mantissa.</td>
</tr>
<tr class="tr1">
<td valign="top"><strong>Byte Vector</strong></td>
<td valign="top" class="keyWord">&lt;<span class="constant">byteVector</span> <span class="attribute">name</span>=&quot;RawData&quot; <span class="attribute">id</span> =&quot;96&quot; <span class="attribute">presence</span>=&quot;optional&quot;/&gt;</td>
<td valign="top">Sequence of bytes.</td>
</tr>
<tr class="tr2">
<td valign="top">\anchor FieldOperatorSequence <strong>Sequence</strong></td>
<td valign="top" class="keyWord">&lt;<span class="constant">sequence</span> <span class="attribute">name</span>=&quot;NoSecurityAltID&quot; <span class="attribute">id</span>=&quot;454&quot; <span class="attribute">presence</span>=&quot;optional&quot;&gt;<br>&lt;<span class="constant">string</span> <span class="attribute">name</span>=&quot;SecurityAltID&quot; <span class="attribute">id</span>=&quot;455&quot;/&gt;<br>&lt;/<span class="constant">sequence</span>&gt;</td>
<td valign="top"><p>Specifies that the contained group of instructions should be used repeatedly to encode each element (e.g. to encode/decode a FIX Repeating Group).</p><p>A sequence can have an associated <strong>length</strong> field containing an unsigned integer indicating the number of encoded elements.</p></td>
</tr>
</table>
</td>
</tr>
</table>
<p>The optional \a presence attribute indicates whether the field is mandatory or optional. If the attribute is not specified, the field is mandatory.</p>
<p>The required \a name attribute identifies the corresponding field in the current FIX message type by the field name.</p>
<p>The optional \a id  attribute identifies the corresponding field in the current FIX message type by the tag number.</p>

\subsection FieldOperators Field Operators

<p>A field that is not a \ref FieldOperatorSequence "Sequence" can have a field operator. The <span class="fileSystem"><strong>Field Operator</strong></span> specifies an optimization operation for the field.</p>
<p>The following field operators are supported:</p>

<table align="center"  width="100%" border="0" cellspacing="1" cellpadding="2" class="fixTableBorder">
<tr>
<td class="white"><table  width="100%"  border="1" cellspacing="1" cellpadding="5" class="white">
<tr class="th">
<th align="left">Field    Operator</th>
<th>Example</th>
<th>Notes</th>
</tr>
<tr class="tr1">
<td valign="top"><p><strong>Constant</strong></p></td>
<td valign="top"><p class="keyWord">&lt;<span class="constant">string</span> <span class="attribute">name</span>=&quot;MessageType&quot; <span class="attribute">id</span>=&quot;35&quot;&gt;<br>
&lt;<span class="constant">constant</span> <span class="attribute">value</span>=&quot;X&quot; /&gt;<br>
&lt;/<span class="constant">string</span>&gt; </p></td>
<td valign="top"><p>Specifies    that the value of a field will always be the same initial value.</p>
<p>Is    applicable to all field types.</p></td>
</tr>
<tr class="tr2">
<td valign="top"><p><strong>Default</strong></p></td>
<td valign="top"><p class="keyWord">&lt;<span class="constant">string</span> <span class="attribute">name</span>=&quot;PosDupFlag&quot; <span class="attribute">id</span>=&quot;43&quot; <span class="attribute">presence</span>=&quot;optional&quot;&gt;<br>
&lt;<span class="constant">default    = &quot;N&quot;</span> /&gt;<br>
&lt;/<span class="constant">string</span>&gt; </p></td>
<td valign="top"><p>Specifies  that the value of a field is either present in the FAST stream or it will be the initial value.</p>
<p>Is    applicable to all field types.</p></td>
</tr>
<tr class="tr1">
<td valign="top"><p><strong>Copy </strong></p></td>
<td valign="top"><p class="keyWord">&lt;<span class="constant">uInt32</span> <span class="attribute">name</span>=&quot;MDUpdateAction&quot; <span class="attribute">id</span>=&quot;279&quot;&gt;<br>
&lt;<span class="constant">copy</span> <span class="attribute">value</span>=&quot;1&quot; /&gt;<br>
&lt;/<span class="constant">uInt32</span>&gt;</p></td>
<td valign="top"><p>If    the value is present in the stream it becomes the new previous value,    otherwise the value of the field is the previous value.</p>
<p>Is    applicable to all field types.</p></td>
</tr>
<tr class="tr2">
<td valign="top"><p><strong>Increment</strong></p></td>
<td valign="top"><p class="keyWord">&lt;<span class="constant">uInt32</span> <span class="attribute">name</span>=&quot;RptSeq&quot; <span class="attribute">id</span>=&quot;83&quot;&gt;<br>
&lt;<span class="constant">increment</span> /&gt;<br>
&lt;/<span class="constant">uInt32</span>&gt;</p></td>
<td valign="top"><p>If    the value is present in the stream it becomes the new previous value,    otherwise the value of the field is the previous value incremented by one.</p>
<p>Is    applicable to Integer field types only.</p></td>
</tr>
<tr class="tr1">
<td valign="top"><p><strong>Delta</strong></p></td>
<td valign="top"><p class="keyWord">&lt;<span class="constant">int32</span> <span class="attribute">name</span>=&quot;MDEntrySize&quot; <span class="attribute">id</span>=&quot;271&quot;&gt;<br>
&lt;<span class="constant">delta</span> /&gt;<br>
&lt;/<span class="constant">int32</span>&gt;</p></td>
<td valign="top"><p>Specifies that a delta value is present in the stream. The field is obtained by combining the delta value with the previous value.</p>
<p>Is applicable to Integer, Decimal, String and Byte Vector field types.</p></td>
</tr>
<tr class="tr2">
<td valign="top"><p><strong>Tail</strong></p></td>
<td valign="top"><p class="keyWord">&lt;<span class="constant">string</span> <span class="attribute">name</span>=&quot;SendingTime&quot; <span class="attribute">id</span>=&quot;52&quot;&gt;<br>
&lt;<span class="constant">tail</span>/&gt;<br>
&lt;/<span class="constant">string</span>&gt;</p></td>
<td valign="top"><p>Specifies that a tail value is present in the stream.