CME iLink 3 Handler

    // Initialize engine
    Engine::FixEngine::InitParameters params;
    params.propertiesFileName_ = "myapp.properties";

	...
    
    params.cmeTradingSystemName = "MyTradeSystem";// CME system name
    params.cmeTradingSystemVersion = "1.0";       // CME system version     
    params.cmeTradingSystemVendor = "MyFirmName"; // CME system vendor

    FixEngine::init( params );

    Engine::SessionExtraParameters extraParams;

	...

	extraParams.useLiteMessage_ = true;
    extraParams.iLink3AccessKey_ = "XXXXX"; // Session Access Key
    extraParams.iLink3Firm_ = "000"; // Session Globex Firm
    extraParams.getSessionSecurityKeyCallback_ = GetILink3Key;

	std::string sessionID = "AAA"; // Session ID

    RefCounter<Session> pSn(FixEngine::singleton()->createSession( pMyILink3App, sessionID, "ILink3", "ILINK3", &extraParams), false);

static std::string GetILink3Key ( const std::string& /*accessKey*/ )
{
    return "xxxxxxxxxxxxxxxxx"; // Session signature key
}

  	std::string backupHost;
	int backupPort = 0;
	Engine::SessionExtraParameters extraParams;	

	... // parameters setup here
	
	bool hasBackup = !backupHost.empty() && backupPort != 0;
    if(hasBackup)
    {
        extraParams.enableAutoSwitchToBackupConnection_ = true; // Auto switch to backup
        extraParams.cyclicSwitchBackupConnection_ = true; // Auto switch back to primary
    }
    
	... // Session creation here

	Engine::SessionBackupParameters backupParams;
    backupParams.host_ = backupHost;
    backupParams.port_ = backupPort;
    backupParams.hbi_ = hbi;

    pSn->connect(hbi, host, port, Engine::NONE, hasBackup ? &backupParams : NULL);

static void sendMessage( RefCounter<Session> pILink3Session, const char* pMessageData, size_t messageDataSize )
{
    pILink3Session->put( pMessageData, messageDataSize ); // Sequence number is updated automatically before message is sent.
}

bool TraderApp::process( const Engine::FIXMessage& msg, const Engine::Session& aSn )
{
    const char* buffer;
    size_t bufferSize;

    if(!msg.getBinaryData( buffer, bufferSize ))
        throw Utils::Exception( "Message without binary data received! Unable to process!" );
	// buffer points to binary data now, bufferSize contains binary data size.
    // Please pay attention that binary data is valid in the scope of process routine only. So one must copy it if one needs it for a wider scope!
	// See iLink3_certification sample on possible solution.
    return true;
}

static const size_t cMaxILink3MessageSize = 65535;
unsigned int sendPartiesDefinition( RefCounter<Session> pILink3Session, unsigned int id )
{
	// Allocate buffer on stack
    char buf[cMaxILink3MessageSize];
    memset(& buf, 0, sizeof( buf )); // buffer for messages with repeating groups should be cleared before use
    ILink3::PartyDetailsDefinitionRequest518* pPartyDetails = new (&buf) ILink3::PartyDetailsDefinitionRequest518(true); // Use placement new to avoid memory allocation.

    // Populate fields.
	pPartyDetails->setPartyDetailsListReqID( id );
    pPartyDetails->setSendingTimeEpoch( System::Time::currentTimeUsec1970() * 1000 );
    pPartyDetails->setListUpdateAction( ILink3::ListUpdAct::ListUpdAct_Add );
    pPartyDetails->setCustOrderCapacity( ILink3::CustOrderCapacity::CustOrderCapacity_Membertradingfortheirownaccount );
    pPartyDetails->setClearingAccountType( ILink3::ClearingAcctType::ClearingAcctType_Customer );
    pPartyDetails->setCustOrderHandlingInst( ILink3::CustOrdHandlInst::CustOrdHandlInst_ClientElectronic );
        
	// Default values are set within constructor if its boolean argument is 'true'.
	/*
    pPartyDetails->setMemo( "" );
    pPartyDetails->setAvgPxGroupID( "" );
    pPartyDetails->setSelfMatchPreventionID( ILink3::getuInt64NULLNullValue() );
    pPartyDetails->setCmtaGiveupCD( ILink3::CmtaGiveUpCD::CmtaGiveUpCD_Null );
    pPartyDetails->setSelfMatchPreventionInstruction( ILink3::SMPI::SMPI_Null );
    pPartyDetails->setAvgPxIndicator( ILink3::AvgPxInd::AvgPxInd_Null );
    pPartyDetails->setClearingTradePriceType( ILink3::SLEDS::SLEDS_Null );
    pPartyDetails->setExecutor( ILink3::getuInt64NULLNullValue() );
    pPartyDetails->setIDMShortCode( ILink3::getuInt64NULLNullValue() );
    */

    // Populate repeating group
	{
		// Get reference to repeating group of interest.
        ILink3::PartyDetailsDefinitionRequest518::NoPartyDetails& partyDetail = pPartyDetails->getNoPartyDetails();
		// Set required number of the group elements.
        partyDetail.setElementsCount( 3 );
		// Get pointer to the group elements array.
        ILink3::PartyDetailsDefinitionRequest518::NoPartyDetails::NoPartyDetailsElement* elements = partyDetail.getElements();

        elements[0].setPartyDetailRole( ILink3::PartyDetailRole::PartyDetailRole_CustomerAccount );
        elements[0].setPartyDetailID( "acc" );

        elements[1].setPartyDetailRole( ILink3::PartyDetailRole::PartyDetailRole_ExecutingFirm );
        elements[1].setPartyDetailID( "004" );

        elements[2].setPartyDetailRole( ILink3::PartyDetailRole::PartyDetailRole_Operator );
        elements[2].setPartyDetailID( "operator" );
    }

	// Update message size taking into account all nesting repeating groups.
    pPartyDetails->updateMessageLength();

	// It is OK to pass buffer pointing to stack location since the engine doesn't use it after return.        
	pILink3Session->put( pPartyDetails, pPartyDetails->getMessageLength() );

    return id;
}

#define SET_PRICE9(a, b) ((a).setMantissa(static_cast<System::i64>((b)*1000000000)))
static void sendLimit( RefCounter<Session> pILink3Session, int instrumentID, int qty )
{
	// Allocate buffer on stack
    char buf[cMaxILink3MessageSize];
    ILink3::NewOrderSingle514* pNewOrder = new (&buf) ILink3::NewOrderSingle514( true );

    // Populate fields.
    pNewOrder->setOrdType( ILink3::OrderTypeReq::OrderTypeReq_Limit );

    SET_PRICE9( pNewOrder->price, 1 );
    pNewOrder->setOrderQty( qty );
    pNewOrder->setSecurityID( instrumentID );
    pNewOrder->setSide( ILink3::SideReq::SideReq_Sell );
    pNewOrder->setSenderID( "user1" );
    std::ostringstream ss;
    ss << "TEST_" << pILink3Session->getOutSeqNum();
    pNewOrder->setClOrdID( ss.str() );
    pNewOrder->setPartyDetailsListReqID( 0 );
    //pNewOrder->setOrderRequestID( 0 );
    pNewOrder->setSendingTimeEpoch( System::Time::currentTimeUsec1970() * 1000 );
    pNewOrder->setLocation( "IL" );
    pNewOrder->setTimeInForce( ILink3::TimeInForce::TimeInForce_Day );
    pNewOrder->setManualOrderIndicator( ILink3::ManualOrdIndReq::ManualOrdIndReq_Manual );

	// Update message size.
    pNewOrder->updateMessageLength();

	// It is OK to pass buffer pointing to stack location since the engine doesn't use it after return.        
    pILink3Session->put( pNewOrder, pNewOrder->getMessageLength() );
}

void processData( const char* binaryData, size_t dataSize )
{
    // Cast data to base iLink 3 type
	const ILink3::StandardHeader* hdr = reinterpret_cast<const ILink3::StandardHeader*>(binaryData);

	// Check whatever the message is valid	
    if(!ILink3::isValidILink3Message( hdr ))
        throw std::exception( "Invalid iLink 3 message received!" );
    if(hdr->getSbeHeader().getTemplateId() == ILink3::ExecutionReportNew522::TemplateID)
    {
	    const ILink3::ExecutionReportNew522& msg = reinterpret_cast<const ILink3::ExecutionReportNew522&>(*hdr);
        std::cout << "SplitMsg:" << static_cast<unsigned int>(msg.splitMsg.value) << std::endl;
        std::cout << "DelayToTime:" << msg.delayToTime << std::endl;
        std::cout << "\t\t Qty:" << msg.orderQty << std::endl;
    }else if(...)
	{
		...
	}else
	{
		// Unexpected message type processing here.
	}
}

void terminate( RefCounter<Session> pILink3Session, bool bReleaseSession )
{
    // Send logout and disconnect
	pILink3Session->disconnect( "The session was closed by application" );

    // Unregister our application from the session to avoid any callback be called after this point. Application object can be destroyed after this call.
    pILink3Session->registerApplication(NULL);

	// It is safe to release reference to the session. The engine keeps its our reference and releases it after session's termination is finished but it is safe to keep this reference if needed and release it later.
	if( bReleaseSession )
		pILink3Session.reset();

}

class MyApp: public Engine::Application
{
public:
	virtual void onResendRequestEvent( const Engine::ResendRequestEvent& event, const Engine::Session& /*sn*/ );
}
...
void MyApp::onResendRequestEvent( const Engine::ResendRequestEvent& event, const Engine::Session& /*sn*/ ) 
{
	// Getting begin and end sequence numbers of the gap
	int gapBegin = event.getBeginSeqNo();
	int gapEnd = event.getEndSeqNo();
	
	if(gapEnd - gapBegin < 100) // Do custom NotApplied processing if the gap is more than 100 messages. It is just a sample not related to any actual business needs!
		return;
	// Tell the engine to ignore NotApplied message.
	event.processResendRequest_ = false;

	// Getting original binary message if required.
    const char* buffer;
    size_t bufferSize;

    if(!event.resendRequestMsg_->getBinaryData( buffer, bufferSize ))
        throw Utils::Exception( "Message without binary data received! Unable to process!" );
	
    // Cast data to base iLink 3 type
	const ILink3::NotApplied513* pNotApplied = reinterpret_cast<const ILink3::NotApplied513*>(buffer);

	// Check whatever the message is valid	
    if(!ILink3::isValidILink3Message( pNotApplied ) ||  pNotApplied ->getSbeHeader().getTemplateId() != ILink3::NotApplied513::TemplateID)
        throw std::exception( "Invalid NotApplied message received!" );

	// Do custom NotApplied processing here

	...
	
    return;
}

    Engine::SessionExtraParameters extraParams;

	...

	extraParams.useLiteMessage_ = true;
    extraParams.iLink3AccessKey_ = "XXXXX"; // Session Access Key
    extraParams.extFirm_ = "000"; // Session Globex Firm
    extraParams.getSessionSecurityKeyCallback_ = GetILink3Key;

	std::string sessionID = "AAA"; // Session ID

	// pMyILink3AppForSeg99 and pMyILink3AppForSeg21 can be the same if no separate processing for different segments is required.
	// Create session for segment 99
    RefCounter<Session> pSn99(FixEngine::singleton()->createSession( pMyILink3AppForSeg99, sessionID, "ILink3-seg99", "ILINK3", &extraParams), false);

	// Connect to segment 99
    pSn99->connect(hbi, seg99Host, seg99Port);

	// Create session for segment 21
    RefCounter<Session> pSn21(FixEngine::singleton()->createSession( pMyILink3AppForSeg21, sessionID, "ILink3-seg21", "ILINK3", &extraParams), false);

	// Connect to segment 21
    pSn21->connect(hbi, seg21Host, seg21Port);