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

FIX::Session Class Reference

Maintains the state and implements the logic of a FIX session. More...

#include <Session.h>

Collaboration diagram for FIX::Session:

Collaboration graph
[legend]
List of all members.

Public Member Functions

 Session (Application &, MessageStoreFactory &, const SessionID &, const DataDictionary &, const SessionTime &, int heartBtInt, LogFactory *pLogFactory)
 ~Session ()
void logon ()
void logout (const std::string &reason="")
bool isEnabled ()
bool sentLogon ()
bool sentLogout ()
bool receivedLogon ()
bool isLoggedOn ()
void reset () throw ( IOException )
void refresh () throw ( IOException )
void setNextSenderMsgSeqNum (int num) throw ( IOException )
void setNextTargetMsgSeqNum (int num) throw ( IOException )
const SessionID & getSessionID () const
void setDataDictionary (const DataDictionary &dataDictionary)
const DataDictionary & getDataDictionary () const
bool isSessionTime ()
void checkCompId (bool value)
void checkLatency (bool value)
void setMaxLatency (int value)
void setLogonTimeout (int value)
void setLogoutTimeout (int value)
void setResetOnLogon (bool value)
void setResetOnLogout (bool value)
void setResetOnDisconnect (bool value)
void setRefreshOnLogon (bool value)
void setMillisecondsInTimeStamp (bool value)
void setResponder (Responder *pR)
bool send (Message &)
void next ()
void next (const std::string &, bool queued=false)
void next (const Message &, bool queued=false)
void disconnect ()
long getExpectedSenderNum ()
long getExpectedTargetNum ()
Log * getLog ()
const MessageStore * getStore ()

Static Public Member Functions

bool sendToTarget (Message &message, const std::string &qualifier="") throw ( SessionNotFound )
bool sendToTarget (Message &message, const SessionID &sessionID) throw ( SessionNotFound )
bool sendToTarget (Message &, const SenderCompID &senderCompID, const TargetCompID &targetCompID, const std::string &qualifier="") throw ( SessionNotFound )
bool sendToTarget (Message &message, const std::string &senderCompID, const std::string &targetCompID, const std::string &qualifier="") throw ( SessionNotFound )
bool doesSessionExist (const SessionID &)
Session * lookupSession (const SessionID &)
Session * lookupSession (const std::string &, bool reverse=false)
bool isSessionRegistered (const SessionID &)
Session * registerSession (const SessionID &)
void unregisterSession (const SessionID &)
int numSessions ()

Private Types

typedef std::map< SessionID,
Session * > 		Sessions

Private Member Functions

bool send (const std::string &)
bool sendRaw (Message &, int msgSeqNum=0)
bool resend (Message &message)
void insertSendingTime (Header &)
void insertOrigSendingTime (Header &, const UtcTimeStamp &when=UtcTimeStamp())
void fill (Header &)
bool isGoodTime (const SendingTime &sendingTime)
bool checkSessionTime (const UtcTimeStamp &time)
bool isTargetTooHigh (const MsgSeqNum &msgSeqNum)
bool isTargetTooLow (const MsgSeqNum &msgSeqNum)
bool isCorrectCompID (const SenderCompID &senderCompID, const TargetCompID &targetCompID)
bool shouldSendReset ()
bool validLogonState (const MsgType &msgType)
void fromCallback (const MsgType &msgType, const Message &msg, const SessionID &sessionID)
void doBadTime (const Message &msg)
void doBadCompID (const Message &msg)
bool doPossDup (const Message &msg)
bool doTargetTooLow (const Message &msg)
void doTargetTooHigh (const Message &msg)
void nextQueued ()
bool nextQueued (int num)
void nextLogon (const Message &)
void nextHeartbeat (const Message &)
void nextTestRequest (const Message &)
void nextLogout (const Message &)
void nextReject (const Message &)
void nextSequenceReset (const Message &)
void nextResendRequest (const Message &)
void generateLogon ()
void generateLogon (const Message &)
void generateResendRequest (const BeginString &, const MsgSeqNum &)
void generateSequenceReset (int, int)
void generateHeartbeat ()
void generateHeartbeat (const Message &)
void generateTestRequest (const std::string &)
void generateReject (const Message &, int err, int field=0)
void generateReject (const Message &, const std::string &)
void generateBusinessReject (const Message &, int err)
void generateLogout (const std::string &text="")
void populateRejectReason (Message &, int field, const std::string &)
void populateRejectReason (Message &, const std::string &)
bool verify (const Message &msg, bool checkTooHigh=true, bool checkTooLow=true)
bool set (int s, const Message &m)
bool get (int s, Message &m) const

Static Private Member Functions

bool addSession (Session &)
void removeSession (Session &)

Private Attributes

Application & m_application
SessionID m_sessionID
SessionTime m_sessionTime
bool m_checkCompId
bool m_checkLatency
int m_maxLatency
bool m_resetOnLogon
bool m_resetOnLogout
bool m_resetOnDisconnect
bool m_refreshOnLogon
bool m_millisecondsInTimeStamp
SessionState m_state
DataDictionary m_dataDictionary
MessageStoreFactory & m_messageStoreFactory
LogFactory * m_pLogFactory
Responder * m_pResponder
Mutex m_mutex

Static Private Attributes

Sessions s_sessions
Sessions s_registered
Mutex s_mutex

Detailed Description

Maintains the state and implements the logic of a FIX session.

Definition at line 45 of file Session.h.

Member Typedef Documentation

typedef std::map< SessionID, Session* > FIX::Session::Sessions [private]
 

Definition at line 150 of file Session.h.

Constructor & Destructor Documentation

FIX::Session::Session (  Application &  ,
MessageStoreFactory &  ,
const SessionID &  ,
const DataDictionary &  ,
const SessionTime &  ,
int  heartBtInt,
LogFactory *  pLogFactory
) 
 

Definition at line 41 of file Session.cpp.

References addSession(), checkSessionTime(), FIX::LogFactory::create(), FIX::MessageStoreFactory::create(), FIX::SessionState::heartBtInt(), FIX::SessionState::initiate(), FIX::SessionState::log(), m_sessionID, m_state, FIX::Application::onCreate(), FIX::SessionState::onEvent(), reset(), and FIX::SessionState::store(). 

00047 : m_application( application ),
00048   m_sessionID( sessionID ),
00049   m_sessionTime( sessionTime ),
00050   m_checkCompId( true ),
00051   m_checkLatency( true ), 
00052   m_maxLatency( 120 ),
00053   m_resetOnLogon( false ),
00054   m_resetOnLogout( false ), 
00055   m_resetOnDisconnect( false ),
00056   m_millisecondsInTimeStamp( true ),
00057   m_dataDictionary( dataDictionary ),
00058   m_messageStoreFactory( messageStoreFactory ),
00059   m_pLogFactory( pLogFactory ),
00060   m_pResponder( 0 )
00061 {
00062   m_state.heartBtInt( heartBtInt );
00063   m_state.initiate( heartBtInt != 0 );
00064   m_state.store( m_messageStoreFactory.create( m_sessionID ) );
00065   if ( m_pLogFactory )
00066     m_state.log( m_pLogFactory->create( m_sessionID ) );
00067 
00068   if( !checkSessionTime( UtcTimeStamp() ) )
00069     reset();
00070 
00071   addSession( *this );
00072   m_application.onCreate( m_sessionID );
00073   m_state.onEvent( "Created session" );
00074 }

FIX::Session::~Session (   ) 
 

Definition at line 76 of file Session.cpp.

References FIX::LogFactory::destroy(), FIX::MessageStoreFactory::destroy(), FIX::SessionState::log(), m_state, QF_STACK_IGNORE_BEGIN, QF_STACK_IGNORE_END, removeSession(), and FIX::SessionState::store(). 

00077 { QF_STACK_IGNORE_BEGIN
00078   removeSession( *this );
00079   m_messageStoreFactory.destroy( m_state.store() );
00080   if ( m_pLogFactory && m_state.log() )
00081     m_pLogFactory->destroy( m_state.log() );
00082   QF_STACK_IGNORE_END
00083 }

Member Function Documentation

bool FIX::Session::addSession (  Session &   )  [static, private]
 

Definition at line 1494 of file Session.cpp.

References m_sessionID, QF_STACK_POP, QF_STACK_PUSH, and s_sessions.

Referenced by Session(). 

01495 { QF_STACK_PUSH(Session::addSession)
01496 
01497   Locker locker( s_mutex );
01498   Sessions::iterator it = s_sessions.find( s.m_sessionID );
01499   if ( it == s_sessions.end() )
01500   {
01501     s_sessions[ s.m_sessionID ] = &s;
01502     return true;
01503   }
01504   else
01505     return false;
01506 
01507   QF_STACK_POP
01508 }

void FIX::Session::checkCompId (  bool  value  )  [inline]
 

Definition at line 109 of file Session.h.

References m_checkCompId.

Referenced by FIX::SessionFactory::create(). 

00110     { m_checkCompId = value; }

void FIX::Session::checkLatency (  bool  value  )  [inline]
 

Definition at line 111 of file Session.h.

References m_checkLatency.

Referenced by FIX::SessionFactory::create(). 

00112     { m_checkLatency = value; }

bool FIX::Session::checkSessionTime (  const UtcTimeStamp &  time  )  [inline, private]
 

Definition at line 169 of file Session.h.

References FIX::SessionState::getCreationTime(), FIX::SessionTime::isSameSession(), m_sessionTime, and m_state.

Referenced by next(), Session(), and setResponder(). 

00170   {
00171     UtcTimeStamp creationTime = m_state.getCreationTime();
00172     return m_sessionTime.isSameSession(time, creationTime);
00173   }

void FIX::Session::disconnect (   ) 
 

Definition at line 524 of file Session.cpp.

References FIX::SessionState::clearQueue(), FIX::Responder::disconnect(), FIX::SessionState::logoutReason(), m_pResponder, m_resetOnDisconnect, m_sessionID, m_state, FIX::SessionState::onEvent(), FIX::Application::onLogout(), QF_STACK_POP, QF_STACK_PUSH, FIX::SessionState::receivedLogon(), FIX::SessionState::receivedReset(), FIX::SessionState::resendRange(), FIX::SessionState::reset(), FIX::SessionState::sentLogon(), FIX::SessionState::sentLogout(), and FIX::SessionState::sentReset().

Referenced by next(), nextLogon(), nextLogout(), FIX::SocketInitiator::onDisconnect(), FIX::SocketAcceptor::onDisconnect(), FIX::ThreadedSocketConnection::read(), reset(), and verify(). 

00525 { QF_STACK_PUSH(Session::disconnect)
00526 
00527   Locker l(m_mutex);
00528 
00529   if ( m_pResponder )
00530   {
00531     m_state.onEvent( "Disconnecting" );
00532 
00533     m_pResponder->disconnect();
00534     m_pResponder = 0;
00535   }
00536 
00537   if ( m_state.receivedLogon() || m_state.sentLogon() )
00538   {
00539     m_state.receivedLogon( false );
00540     m_state.sentLogon( false );
00541     m_application.onLogout( m_sessionID );
00542   }
00543 
00544   m_state.sentLogout( false );
00545   m_state.receivedReset( false );
00546   m_state.sentReset( false );
00547   m_state.clearQueue();
00548   m_state.logoutReason();
00549   if ( m_resetOnDisconnect )
00550     m_state.reset();
00551 
00552   m_state.resendRange( 0, 0 );
00553 
00554   QF_STACK_POP
00555 }

void FIX::Session::doBadCompID (  const Message &  msg  )  [private]
 

Definition at line 1071 of file Session.cpp.

References generateLogout(), generateReject(), QF_STACK_POP, QF_STACK_PUSH, and FIX::SessionRejectReason_COMPID_PROBLEM.

Referenced by verify(). 

01072 { QF_STACK_PUSH(Session::doBadCompID)
01073 
01074   generateReject( msg, SessionRejectReason_COMPID_PROBLEM );
01075   generateLogout();
01076 
01077   QF_STACK_POP
01078 }

void FIX::Session::doBadTime (  const Message &  msg  )  [private]
 

Definition at line 1062 of file Session.cpp.

References generateLogout(), generateReject(), QF_STACK_POP, QF_STACK_PUSH, and FIX::SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM.

Referenced by verify(). 

01063 { QF_STACK_PUSH(Session::doBadTime)
01064 
01065   generateReject( msg, SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM );
01066   generateLogout();
01067 
01068   QF_STACK_POP
01069 }

bool FIX::Session::doesSessionExist (  const SessionID &   )  [static]
 

Definition at line 1406 of file Session.cpp.

References QF_STACK_POP, QF_STACK_PUSH, and s_sessions. 

01407 { QF_STACK_PUSH(Session::doesSessionExist)
01408 
01409   Locker locker( s_mutex );
01410   return s_sessions.end() != s_sessions.find( sessionID );
01411 
01412   QF_STACK_POP
01413 }

bool FIX::Session::doPossDup (  const Message &  msg  )  [private]
 

Definition at line 1080 of file Session.cpp.

References generateLogout(), generateReject(), FIX::FieldMap::getField(), FIX::Message::getHeader(), FIX::Header, FIX::FieldMap::isSetField(), FIX::MsgType_SequenceReset, QF_STACK_POP, QF_STACK_PUSH, FIX::SessionRejectReason_REQUIRED_TAG_MISSING, and FIX::SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM.

Referenced by doTargetTooLow(). 

01081 { QF_STACK_PUSH(Session::doPossDup)
01082 
01083   const Header & header = msg.getHeader();
01084   OrigSendingTime origSendingTime;
01085   SendingTime sendingTime;
01086   MsgType msgType;
01087 
01088   header.getField( msgType );
01089   header.getField( sendingTime );
01090 
01091   if ( msgType != MsgType_SequenceReset )
01092   {
01093     if ( !header.isSetField( origSendingTime ) )
01094     {
01095       generateReject( msg, SessionRejectReason_REQUIRED_TAG_MISSING, origSendingTime.getField() );
01096       return false;
01097     }
01098     header.getField( origSendingTime );
01099 
01100     if ( origSendingTime > sendingTime )
01101     {
01102       generateReject( msg, SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM );
01103       generateLogout();
01104       return false;
01105     }
01106   }
01107   return true;
01108 
01109   QF_STACK_POP
01110 }

void FIX::Session::doTargetTooHigh (  const Message &  msg  )  [private]
 

Definition at line 1136 of file Session.cpp.

References generateResendRequest(), getExpectedTargetNum(), FIX::FieldMap::getField(), FIX::Message::getHeader(), FIX::Header, m_state, FIX::SessionState::onEvent(), QF_STACK_POP, QF_STACK_PUSH, FIX::SessionState::queue(), FIX::SessionState::resendRange(), FIX::SessionState::ResendRange, and FIX::SessionState::resendRequested().

Referenced by nextLogon(), and verify(). 

01137 { QF_STACK_PUSH(Session::doTargetTooHigh)
01138 
01139   const Header & header = msg.getHeader();
01140   BeginString beginString;
01141   MsgSeqNum msgSeqNum;
01142   header.getField( beginString );
01143   header.getField( msgSeqNum );
01144 
01145   m_state.onEvent( "MsgSeqNum too high, expecting "
01146                    + IntConvertor::convert( getExpectedTargetNum() )
01147                    + " but received "
01148                    + IntConvertor::convert( msgSeqNum ) );
01149 
01150   m_state.queue( msgSeqNum, msg );
01151 
01152   if( m_state.resendRequested() )
01153   {
01154     SessionState::ResendRange range = m_state.resendRange();
01155 
01156     if( msgSeqNum >= range.first )
01157     {
01158           m_state.onEvent ("Already sent ResendRequest FROM: " +
01159                            IntConvertor::convert (range.first) + " TO: " +
01160                            IntConvertor::convert (range.second) +
01161                            ".  Not sending another.");
01162           return;
01163     }
01164   }
01165 
01166   generateResendRequest( beginString, msgSeqNum );
01167 
01168   QF_STACK_POP
01169 }

bool FIX::Session::doTargetTooLow (  const Message &  msg  )  [private]
 

Definition at line 1112 of file Session.cpp.

References doPossDup(), generateLogout(), getExpectedTargetNum(), FIX::FieldMap::getField(), FIX::Message::getHeader(), FIX::Header, FIX::FieldMap::isSetField(), QF_STACK_POP, and QF_STACK_PUSH.

Referenced by verify(). 

01113 { QF_STACK_PUSH(Session::doTargetTooLow)
01114 
01115   const Header & header = msg.getHeader();
01116   PossDupFlag possDupFlag(false);
01117   MsgSeqNum msgSeqNum;
01118   if( header.isSetField(possDupFlag) )
01119     header.getField( possDupFlag );
01120   header.getField( msgSeqNum );
01121 
01122   if ( !possDupFlag )
01123   {
01124     std::stringstream stream;
01125     stream << "MsgSeqNum too low, expecting " << getExpectedTargetNum()
01126            << " but received " << msgSeqNum;
01127     generateLogout( stream.str() );
01128     throw std::logic_error( stream.str() );
01129   }
01130 
01131   return doPossDup( msg );
01132 
01133   QF_STACK_POP
01134 }

void FIX::Session::fill (  Header &   )  [private]
 

Definition at line 104 of file Session.cpp.

References FIX::SessionID::getBeginString(), getExpectedSenderNum(), FIX::SessionID::getSenderCompID(), FIX::SessionID::getTargetCompID(), FIX::Header, insertSendingTime(), FIX::SessionState::lastSentTime(), m_sessionID, m_state, QF_STACK_POP, QF_STACK_PUSH, and FIX::FieldMap::setField().

Referenced by generateBusinessReject(), generateHeartbeat(), generateLogon(), generateLogout(), generateReject(), generateResendRequest(), generateTestRequest(), and sendRaw(). 

00105 { QF_STACK_PUSH(Session::fill)
00106 
00107   UtcTimeStamp now;
00108   m_state.lastSentTime( now );
00109   header.setField( m_sessionID.getBeginString() );
00110   header.setField( m_sessionID.getSenderCompID() );
00111   header.setField( m_sessionID.getTargetCompID() );
00112   header.setField( MsgSeqNum( getExpectedSenderNum() ) );
00113   insertSendingTime( header );
00114 
00115   QF_STACK_POP
00116 }

void FIX::Session::fromCallback (  const MsgType &  msgType,
const Message &  msg,
const SessionID &  sessionID
)  [private]
 

Definition at line 1050 of file Session.cpp.

References FIX::Application::fromAdmin(), FIX::Application::fromApp(), m_sessionID, QF_STACK_POP, and QF_STACK_PUSH.

Referenced by verify(). 

01052 { QF_STACK_PUSH(Session::fromCallback)
01053 
01054   if ( Message::isAdminMsgType( msgType ) )
01055     m_application.fromAdmin( msg, m_sessionID );
01056   else
01057     m_application.fromApp( msg, m_sessionID );
01058 
01059   QF_STACK_POP
01060 }

void FIX::Session::generateBusinessReject (  const Message &  ,
int  err
)  [private]
 

Definition at line 847 of file Session.cpp.

References FIX::BusinessRejectReason_APPLICATION_NOT_AVAILABLE, FIX::BusinessRejectReason_APPLICATION_NOT_AVAILABLE_TEXT, FIX::BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING, FIX::BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_TEXT, FIX::BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME, FIX::BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_TEXT, FIX::BusinessRejectReason_NOT_AUTHORIZED, FIX::BusinessRejectReason_NOT_AUTHORIZED_TEXT, FIX::BusinessRejectReason_OTHER, FIX::BusinessRejectReason_OTHER_TEXT, FIX::BusinessRejectReason_UNKNOWN_ID_TEXT, FIX::BusinessRejectReason_UNKNOWN_SECURITY, FIX::BusinessRejectReason_UNKNOWN_SECURITY_TEXT, FIX::BusinessRejectReason_UNKOWN_ID, FIX::BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE, FIX::BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_TEXT, fill(), FIX::FieldMap::getField(), FIX::Message::getHeader(), FIX::SessionState::incrNextTargetMsgSeqNum(), m_state, FIX::MsgType_BusinessMessageReject, FIX::SessionState::onEvent(), populateRejectReason(), QF_STACK_POP, QF_STACK_PUSH, sendRaw(), and FIX::FieldMap::setField().

Referenced by next(). 

00848 { QF_STACK_PUSH(Session::generateBusinessReject)
00849 
00850   Message reject;
00851   reject.getHeader().setField( MsgType( MsgType_BusinessMessageReject ) );
00852   fill( reject.getHeader() );
00853   MsgType msgType;
00854   MsgSeqNum msgSeqNum;
00855   message.getHeader().getField( msgType );
00856   message.getHeader().getField( msgSeqNum );
00857   reject.setField( RefMsgType( msgType ) );
00858   reject.setField( RefSeqNum( msgSeqNum ) );
00859   reject.setField( BusinessRejectReason( err ) );
00860   m_state.incrNextTargetMsgSeqNum();
00861 
00862   const char* reason = 0;
00863   switch ( err )
00864   {
00865     case BusinessRejectReason_OTHER:
00866     reason = BusinessRejectReason_OTHER_TEXT;
00867     break;
00868     case BusinessRejectReason_UNKOWN_ID:
00869     reason = BusinessRejectReason_UNKNOWN_ID_TEXT;
00870     break;
00871     case BusinessRejectReason_UNKNOWN_SECURITY:
00872     reason = BusinessRejectReason_UNKNOWN_SECURITY_TEXT;
00873     break;
00874     case BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE:
00875     reason = BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_TEXT;
00876     break;
00877     case BusinessRejectReason_APPLICATION_NOT_AVAILABLE:
00878     reason = BusinessRejectReason_APPLICATION_NOT_AVAILABLE_TEXT;
00879     break;
00880     case BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING:
00881     reason = BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_TEXT;
00882     break;
00883     case BusinessRejectReason_NOT_AUTHORIZED:
00884     reason = BusinessRejectReason_NOT_AUTHORIZED_TEXT;
00885     break;
00886     case BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME:
00887     reason = BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_TEXT;
00888     break;
00889   };
00890 
00891   populateRejectReason( reject, reason );
00892   sendRaw( reject );
00893   m_state.onEvent( "Message " + msgSeqNum.getString()
00894                    + " Rejected: " + reason );
00895 
00896   QF_STACK_POP
00897 }

void FIX::Session::generateHeartbeat (  const Message &   )  [private]
 

Definition at line 685 of file Session.cpp.

References fill(), FIX::FieldMap::getField(), FIX::Message::getHeader(), QF_STACK_POP, QF_STACK_PUSH, sendRaw(), and FIX::FieldMap::setField(). 

00686 { QF_STACK_PUSH(Session::generateHeartbeat)
00687 
00688   Message heartbeat;
00689   heartbeat.getHeader().setField( MsgType( "0" ) );
00690   fill( heartbeat.getHeader() );
00691   try
00692   {
00693     TestReqID testReqID;
00694     testRequest.getField( testReqID );
00695     heartbeat.setField( testReqID );
00696   }
00697   catch ( FieldNotFound& ) {}
00698 
00699   sendRaw( heartbeat );
00700 
00701   QF_STACK_POP
00702 }

void FIX::Session::generateHeartbeat (   )  [private]
 

Definition at line 674 of file Session.cpp.

References fill(), FIX::Message::getHeader(), QF_STACK_POP, QF_STACK_PUSH, sendRaw(), and FIX::FieldMap::setField().

Referenced by next(), and nextTestRequest(). 

00675 { QF_STACK_PUSH(Session::generateHeartbeat)
00676 
00677   Message heartbeat;
00678   heartbeat.getHeader().setField( MsgType( "0" ) );
00679   fill( heartbeat.getHeader() );
00680   sendRaw( heartbeat );
00681 
00682   QF_STACK_POP
00683 }

void FIX::Session::generateLogon (  const Message &   )  [private]
 

Definition at line 607 of file Session.cpp.

References fill(), FIX::FieldMap::getField(), FIX::Message::getHeader(), logon(), m_state, QF_STACK_POP, QF_STACK_PUSH, FIX::SessionState::receivedReset(), sendRaw(), FIX::SessionState::sentLogon(), and FIX::FieldMap::setField(). 

00608 { QF_STACK_PUSH(Session::generateLogon)
00609 
00610   Message logon;
00611   EncryptMethod encryptMethod;
00612   HeartBtInt heartBtInt;
00613   logon.setField( EncryptMethod( 0 ) );
00614   if( m_state.receivedReset() )
00615     logon.setField( ResetSeqNumFlag(true) );
00616   aLogon.getField( heartBtInt );
00617   logon.getHeader().setField( MsgType( "A" ) );
00618   logon.setField( heartBtInt );
00619   fill( logon.getHeader() );
00620   sendRaw( logon );
00621   m_state.sentLogon( true );
00622 
00623   QF_STACK_POP
00624 }

void FIX::Session::generateLogon (   )  [private]
 

Definition at line 580 of file Session.cpp.

References fill(), FIX::Message::getHeader(), FIX::SessionState::heartBtInt(), FIX::SessionState::lastReceivedTime(), logon(), m_refreshOnLogon, m_resetOnLogon, m_state, QF_STACK_POP, QF_STACK_PUSH, refresh(), FIX::SessionState::reset(), sendRaw(), FIX::SessionState::sentLogon(), FIX::FieldMap::setField(), shouldSendReset(), and FIX::SessionState::testRequest().

Referenced by next(), and nextLogon(). 

00581 { QF_STACK_PUSH(Session::generateLogon)
00582 
00583   Message logon;
00584   logon.getHeader().setField( MsgType( "A" ) );
00585   logon.setField( EncryptMethod( 0 ) );
00586   logon.setField( m_state.heartBtInt() );
00587 
00588   if( m_refreshOnLogon )
00589     refresh();
00590 
00591   if( shouldSendReset() )
00592   {
00593     if( m_resetOnLogon ) m_state.reset();
00594     logon.setField( ResetSeqNumFlag(true) );
00595   }
00596 
00597   fill( logon.getHeader() );
00598   UtcTimeStamp now;
00599   m_state.lastReceivedTime( now );
00600   m_state.testRequest( 0 );
00601   m_state.sentLogon( true );
00602   sendRaw( logon );
00603 
00604   QF_STACK_POP
00605 }

void FIX::Session::generateLogout (  const std::string &  text = ""  )  [private]
 

Definition at line 899 of file Session.cpp.

References fill(), FIX::Message::getHeader(), logout(), m_state, FIX::MsgType_Logout, QF_STACK_POP, QF_STACK_PUSH, sendRaw(), FIX::SessionState::sentLogout(), and FIX::FieldMap::setField().

Referenced by doBadCompID(), doBadTime(), doPossDup(), doTargetTooLow(), next(), nextLogout(), and reset(). 

00900 { QF_STACK_PUSH(Session::generateLogout)
00901 
00902   Message logout;
00903   logout.getHeader().setField( MsgType( MsgType_Logout ) );
00904   fill( logout.getHeader() );
00905   if ( text.length() )
00906     logout.setField( Text( text ) );
00907   sendRaw( logout );
00908   m_state.sentLogout( true );
00909 
00910   QF_STACK_POP
00911 }

void FIX::Session::generateReject (  const Message &  ,
const std::string & 
)  [private]
 

Definition at line 817 of file Session.cpp.

References fill(), FIX::SessionID::getBeginString(), FIX::FieldMap::getField(), FIX::Message::getHeader(), FIX::SessionState::incrNextTargetMsgSeqNum(), m_sessionID, m_state, FIX::MsgType_Logon, FIX::MsgType_SequenceReset, FIX::SessionState::onEvent(), QF_STACK_POP, QF_STACK_PUSH, FIX::Message::reverseRoute(), sendRaw(), and FIX::FieldMap::setField(). 

00818 { QF_STACK_PUSH(Session::generateReject)
00819 
00820   std::string beginString = m_sessionID.getBeginString();
00821 
00822   Message reject;
00823   reject.getHeader().setField( MsgType( "3" ) );
00824   reject.reverseRoute( message.getHeader() );
00825   fill( reject.getHeader() );
00826 
00827   MsgType msgType;
00828   MsgSeqNum msgSeqNum;
00829 
00830   message.getHeader().getField( msgType );
00831   message.getHeader().getField( msgSeqNum );
00832   if ( beginString >= FIX::BeginString_FIX42 )
00833     reject.setField( RefMsgType( msgType ) );
00834   reject.setField( RefSeqNum( msgSeqNum ) );
00835 
00836   if ( msgType != MsgType_Logon && msgType != MsgType_SequenceReset )
00837     m_state.incrNextTargetMsgSeqNum();
00838 
00839   reject.setField( Text( str ) );
00840   sendRaw( reject );
00841   m_state.onEvent( "Message " + msgSeqNum.getString()
00842                    + " Rejected: " + str );
00843 
00844   QF_STACK_POP
00845 }

void FIX::Session::generateReject (  const Message &  ,
int  err,
int  field = 0
)  [private]
 

Definition at line 718 of file Session.cpp.

References fill(), FIX::SessionID::getBeginString(), getExpectedTargetNum(), FIX::FieldMap::getField(), FIX::Message::getHeader(), FIX::SessionState::incrNextTargetMsgSeqNum(), FIX::FieldMap::isSetField(), m_sessionID, m_state, FIX::MsgType_Logon, FIX::MsgType_SequenceReset, FIX::SessionState::onEvent(), populateRejectReason(), QF_STACK_POP, QF_STACK_PUSH, FIX::SessionState::receivedLogon(), FIX::Message::reverseRoute(), sendRaw(), FIX::SessionRejectReason_COMPID_PROBLEM, FIX::SessionRejectReason_COMPID_PROBLEM_TEXT, FIX::SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE, FIX::SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_TEXT, FIX::SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP, FIX::SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_TEXT, FIX::SessionRejectReason_INVALID_MSGTYPE, FIX::SessionRejectReason_INVALID_MSGTYPE_TEXT, FIX::SessionRejectReason_INVALID_TAG_NUMBER, FIX::SessionRejectReason_INVALID_TAG_NUMBER_TEXT, FIX::SessionRejectReason_REQUIRED_TAG_MISSING, FIX::SessionRejectReason_REQUIRED_TAG_MISSING_TEXT, FIX::SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM, FIX::SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_TEXT, FIX::SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE, FIX::SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_TEXT, FIX::SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE, FIX::SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_TEXT, FIX::SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER, FIX::SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_TEXT, FIX::SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE, FIX::SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_TEXT, FIX::SessionRejectReason_VALUE_IS_INCORRECT, FIX::SessionRejectReason_VALUE_IS_INCORRECT_TEXT, and FIX::FieldMap::setField().

Referenced by doBadCompID(), doBadTime(), doPossDup(), next(), and nextSequenceReset(). 

00719 { QF_STACK_PUSH(Session::generateReject)
00720 
00721   std::string beginString = m_sessionID.getBeginString();
00722 
00723   Message reject;
00724   reject.getHeader().setField( MsgType( "3" ) );
00725   reject.reverseRoute( message.getHeader() );
00726   fill( reject.getHeader() );
00727 
00728   MsgSeqNum msgSeqNum;
00729   MsgType msgType;
00730 
00731   message.getHeader().getField( msgType );
00732   if( message.getHeader().isSetField( msgSeqNum ) )
00733   {
00734     message.getHeader().getField( msgSeqNum );
00735     if( msgSeqNum.getString() != "" )
00736       reject.setField( RefSeqNum( msgSeqNum ) );
00737   }
00738 
00739   if ( beginString >= FIX::BeginString_FIX42 )
00740   {
00741     if( msgType.getString() != "" )
00742       reject.setField( RefMsgType( msgType ) );
00743     if ( (beginString == FIX::BeginString_FIX42
00744           && err <= SessionRejectReason_INVALID_MSGTYPE)
00745           || beginString > FIX::BeginString_FIX42 )
00746     {
00747       reject.setField( SessionRejectReason( err ) );
00748     }
00749   }
00750   if ( msgType != MsgType_Logon && msgType != MsgType_SequenceReset
00751        && msgSeqNum == getExpectedTargetNum() )
00752   { m_state.incrNextTargetMsgSeqNum(); }
00753 
00754   const char* reason = 0;
00755   switch ( err )
00756   {
00757     case SessionRejectReason_INVALID_TAG_NUMBER:
00758     reason = SessionRejectReason_INVALID_TAG_NUMBER_TEXT;
00759     break;
00760     case SessionRejectReason_REQUIRED_TAG_MISSING:
00761     reason = SessionRejectReason_REQUIRED_TAG_MISSING_TEXT;
00762     break;
00763     case SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE:
00764     reason = SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_TEXT;
00765     break;
00766     case SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE:
00767     reason = SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_TEXT;
00768     break;
00769     case SessionRejectReason_VALUE_IS_INCORRECT:
00770     reason = SessionRejectReason_VALUE_IS_INCORRECT_TEXT;
00771     break;
00772     case SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE:
00773     reason = SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_TEXT;
00774     break;
00775     case SessionRejectReason_COMPID_PROBLEM:
00776     reason = SessionRejectReason_COMPID_PROBLEM_TEXT;
00777     break;
00778     case SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM:
00779     reason = SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_TEXT;
00780     break;
00781     case SessionRejectReason_INVALID_MSGTYPE:
00782     reason = SessionRejectReason_INVALID_MSGTYPE_TEXT;
00783     break;
00784     case SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE:
00785     reason = SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_TEXT;
00786     break;
00787     case SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER:
00788     reason = SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_TEXT;
00789     break;
00790     case SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP:
00791     reason = SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_TEXT;
00792   };
00793 
00794   if ( reason && ( field || err == SessionRejectReason_INVALID_TAG_NUMBER ) )
00795   {
00796     populateRejectReason( reject, field, reason );
00797     m_state.onEvent( "Message " + msgSeqNum.getString() + " Rejected: "
00798                      + reason + ":" + IntConvertor::convert( field ) );
00799   }
00800   else if ( reason )
00801   {
00802     populateRejectReason( reject, reason );
00803     m_state.onEvent( "Message " + msgSeqNum.getString()
00804          + " Rejected: " + reason );
00805   }
00806   else
00807     m_state.onEvent( "Message " + msgSeqNum.getString() + " Rejected" );
00808 
00809   if ( !m_state.receivedLogon() )
00810     throw std::runtime_error( "Tried to send a reject while not logged on" );
00811 
00812   sendRaw( reject );
00813 
00814   QF_STACK_POP
00815 }

void FIX::Session::generateResendRequest (  const BeginString &  ,
const MsgSeqNum & 
)  [private]
 

Definition at line 626 of file Session.cpp.

References fill(), getExpectedTargetNum(), FIX::Message::getHeader(), m_state, FIX::SessionState::onEvent(), QF_STACK_POP, QF_STACK_PUSH, FIX::SessionState::resendRange(), sendRaw(), and FIX::FieldMap::setField().

Referenced by doTargetTooHigh(). 

00627 { QF_STACK_PUSH(Session::generateResendRequest)
00628 
00629   Message resendRequest;
00630   BeginSeqNo beginSeqNo( ( int ) getExpectedTargetNum() );
00631   EndSeqNo endSeqNo( msgSeqNum - 1 );
00632   if ( beginString >= FIX::BeginString_FIX42 )
00633     endSeqNo = 0;
00634   else if( beginString <= FIX::BeginString_FIX41 )
00635     endSeqNo = 999999;
00636   resendRequest.getHeader().setField( MsgType( "2" ) );
00637   resendRequest.setField( beginSeqNo );
00638   resendRequest.setField( endSeqNo );
00639   fill( resendRequest.getHeader() );
00640   sendRaw( resendRequest );
00641 
00642   m_state.onEvent( "Sent ResendRequest FROM: "
00643                    + IntConvertor::convert( beginSeqNo ) +
00644                    " TO: " + IntConvertor::convert( endSeqNo ) );
00645 
00646   m_state.resendRange( beginSeqNo, msgSeqNum - 1 );
00647 
00648   QF_STACK_POP
00649 }

void FIX::Session::generateSequenceReset (  int  ,
int 
)  [private]
 

Definition at line 652 of file Session.cpp.

References FIX::FieldMap::getField(), FIX::Message::getHeader(), QF_STACK_POP, QF_STACK_PUSH, and FIX::FieldMap::setField().

Referenced by nextResendRequest(). 

00653 { QF_STACK_PUSH(Session::generateSequenceReset)
00654 
00655   Message sequenceReset;
00656   NewSeqNo newSeqNo( endSeqNo );
00657   sequenceReset.getHeader().setField( MsgType( "4" ) );
00658   sequenceReset.getHeader().setField( PossDupFlag( true ) );
00659   sequenceReset.setField( newSeqNo );
00660   fill( sequenceReset.getHeader() );
00661 
00662   SendingTime sendingTime;
00663   sequenceReset.getHeader().getField( sendingTime );
00664   insertOrigSendingTime( sequenceReset.getHeader(), sendingTime );
00665   sequenceReset.getHeader().setField( MsgSeqNum( beginSeqNo ) );
00666   sequenceReset.setField( GapFillFlag( true ) );
00667   sendRaw( sequenceReset, beginSeqNo );
00668   m_state.onEvent( "Sent SequenceReset TO: "
00669                    + IntConvertor::convert( newSeqNo ) );
00670 
00671   QF_STACK_POP
00672 }

void FIX::Session::generateTestRequest (  const std::string &   )  [private]