FIX::SessionFactory Class Reference

Responsible for creating Session objects. More...

`#include <SessionFactory.h>`

Collaboration diagram for FIX::SessionFactory:
[legend]

## Public Member Functions

| SessionFactory (Application &application, MessageStoreFactory &messageStoreFactory, LogFactory *pLogFactory)
| ~SessionFactory ()
Session * | create (const SessionID &sessionID, const Dictionary &settings) throw ( ConfigError )
void | destroy (Session *pSession)

## Private Types

typedef std::map< std::string, ptr::shared_ptr< DataDictionary > > | Dictionaries

## Private Member Functions

ptr::shared_ptr< DataDictionary > | createDataDictionary (const SessionID &sessionID, const Dictionary &settings, const std::string &settingsKey) throw (ConfigError)
void | processFixtDataDictionaries (const SessionID &sessionID, const Dictionary &settings, DataDictionaryProvider &provider) throw (ConfigError)
void | processFixDataDictionary (const SessionID &sessionID, const Dictionary &settings, DataDictionaryProvider &provider) throw (ConfigError)
std::string | toApplVerID (const std::string &value)

## Private Attributes

Application & | m_application
MessageStoreFactory & | m_messageStoreFactory
LogFactory * | m_pLogFactory
Dictionaries | m_dictionaries

## Detailed Description

Responsible for creating Session objects.

This factory will use QuickFIX SessionID, Dictionary settings, MessageStoreFactory, and optional LogFactory to create all the required sessions for an Application.

Definition at line 46 of file SessionFactory.h.

## Member Typedef Documentation

## Dictionaries

typedef std::map< std::string, ptr::shared_ptr<DataDictionary> > FIX::SessionFactory::Dictionaries

private

Definition at line 63 of file SessionFactory.h.

## Constructor & Destructor Documentation

## SessionFactory()

FIX::SessionFactory::SessionFactory | ( | Application & | application,
|  | MessageStoreFactory & | messageStoreFactory,
|  | LogFactory * | pLogFactory
| ) |  |

inline

Definition at line 49 of file SessionFactory.h.

References create(), destroy(), and ~SessionFactory().

: m_application( application ),
m_messageStoreFactory( messageStoreFactory ),
m_pLogFactory( pLogFactory ) {}
FIX::SessionFactory::m_pLogFactory
LogFactory * m_pLogFactory
Definition: SessionFactory.h:81
FIX::SessionFactory::m_messageStoreFactory
MessageStoreFactory & m_messageStoreFactory
Definition: SessionFactory.h:80
FIX::SessionFactory::m_application
Application & m_application
Definition: SessionFactory.h:79

## ~SessionFactory()

FIX::SessionFactory::~SessionFactory | ( |  | ) |

Definition at line 37 of file SessionFactory.cpp.

Referenced by SessionFactory().

{
}

## Member Function Documentation

## create()

Session * FIX::SessionFactory::create | ( | const SessionID & | sessionID,
|  | const Dictionary & | settings
| ) |  |
throw | ( | ConfigError
| ) |  |

Definition at line 41 of file SessionFactory.cpp.

References FIX::CHECK_COMPID, FIX::CHECK_LATENCY, FIX::CONNECTION_TYPE, FIX::UtcTimeOnlyConvertor::convert(), FIX::DEFAULT_APPLVERID, FIX::END_DAY, FIX::END_TIME, FIX::DateTime::getHour(), FIX::DateTime::getMinute(), FIX::DateTime::getSecond(), FIX::HEARTBTINT, FIX::FIELD::HeartBtInt, FIX::TimeRange::isInRange(), FIX::LOGON_DAY, FIX::LOGON_TIME, FIX::LOGON_TIMEOUT, FIX::LOGOUT_DAY, FIX::LOGOUT_TIME, FIX::LOGOUT_TIMEOUT, m_application, m_messageStoreFactory, m_pLogFactory, FIX::MAX_LATENCY, FIX::MILLISECONDS_IN_TIMESTAMP, FIX::PERSIST_MESSAGES, processFixDataDictionary(), processFixtDataDictionaries(), FIX::REFRESH_ON_LOGON, FIX::RESET_ON_DISCONNECT, FIX::RESET_ON_LOGON, FIX::RESET_ON_LOGOUT, FIX::SEND_REDUNDANT_RESENDREQUESTS, FIX::SESSION_QUALIFIER, FIX::START_DAY, FIX::START_TIME, FIX::Message::toApplVerID(), FIX::USE_DATA_DICTIONARY, FIX::USE_LOCAL_TIME, and FIX::VALIDATE_LENGTH_AND_CHECKSUM.

Referenced by FIX::Acceptor::initialize(), FIX::Initiator::initialize(), and SessionFactory().

{
std::string connectionType = settings.getString( CONNECTION_TYPE );
if ( connectionType != "acceptor" && connectionType != "initiator" )
throw ConfigError( "Invalid ConnectionType" );
if( connectionType == "acceptor" && settings.has(SESSION_QUALIFIER) )
throw ConfigError( "SessionQualifier cannot be used with acceptor." );
bool useDataDictionary = true;
if ( settings.has( USE_DATA_DICTIONARY ) )
useDataDictionary = settings.getBool( USE_DATA_DICTIONARY );
std::string defaultApplVerID;
if( sessionID.isFIXT() )
{
if( !settings.has(DEFAULT_APPLVERID) )
{
throw ConfigError("ApplVerID is required for FIXT transport");
}
defaultApplVerID = Message::toApplVerID( settings.getString(DEFAULT_APPLVERID) );
}
DataDictionaryProvider dataDictionaryProvider;
if( useDataDictionary )
{
if( sessionID.isFIXT() )
{
processFixtDataDictionaries(sessionID, settings, dataDictionaryProvider);
}
else
{
processFixDataDictionary(sessionID, settings, dataDictionaryProvider);
}
}
bool useLocalTime = false;
if( settings.has(USE_LOCAL_TIME) )
useLocalTime = settings.getBool( USE_LOCAL_TIME );
int startDay = -1;
int endDay = -1;
try
{
startDay = settings.getDay( START_DAY );
endDay = settings.getDay( END_DAY );
}
catch( ConfigError & ) {}
catch( FieldConvertError & e ) { throw ConfigError( e.what() ); }
UtcTimeOnly startTime;
UtcTimeOnly endTime;
try
{
startTime = UtcTimeOnlyConvertor::convert
( settings.getString( START_TIME ) );
endTime = UtcTimeOnlyConvertor::convert
( settings.getString( END_TIME ) );
}
catch ( FieldConvertError & e ) { throw ConfigError( e.what() ); }
TimeRange utcSessionTime
( startTime, endTime, startDay, endDay );
TimeRange localSessionTime
( LocalTimeOnly(startTime.getHour(), startTime.getMinute(), startTime.getSecond()),
LocalTimeOnly(endTime.getHour(), endTime.getMinute(), endTime.getSecond()),
startDay, endDay );
TimeRange sessionTimeRange = useLocalTime ? localSessionTime : utcSessionTime;
if( startDay >= 0 && endDay < 0 )
throw ConfigError( "StartDay used without EndDay" );
if( endDay >= 0 && startDay < 0 )
throw ConfigError( "EndDay used without StartDay" );
HeartBtInt heartBtInt( 0 );
if ( connectionType == "initiator" )
{
heartBtInt = HeartBtInt( settings.getInt( HEARTBTINT ) );
if ( heartBtInt <= 0 ) throw ConfigError( "Heartbeat must be greater than zero" );
}
std::auto_ptr<Session> pSession;
pSession.reset( new Session( m_application, m_messageStoreFactory,
sessionID, dataDictionaryProvider, sessionTimeRange,
heartBtInt, m_pLogFactory ) );
pSession->setSenderDefaultApplVerID(defaultApplVerID);
int logonDay = startDay;
int logoutDay = endDay;
try
{
logonDay = settings.getDay( LOGON_DAY );
logoutDay = settings.getDay( LOGOUT_DAY );
}
catch( ConfigError & ) {}
catch( FieldConvertError & e ) { throw ConfigError( e.what() ); }
UtcTimeOnly logonTime( startTime );
UtcTimeOnly logoutTime( endTime );
try
{
logonTime = UtcTimeOnlyConvertor::convert
( settings.getString( LOGON_TIME ) );
}
catch( ConfigError & ) {}
catch( FieldConvertError & e ) { throw ConfigError( e.what() ); }
try
{
logoutTime = UtcTimeOnlyConvertor::convert
( settings.getString( LOGOUT_TIME ) );
}
catch( ConfigError & ) {}
catch( FieldConvertError & e ) { throw ConfigError( e.what() ); }
TimeRange utcLogonTime
( logonTime, logoutTime, logonDay, logoutDay );
TimeRange localLogonTime
( LocalTimeOnly(logonTime.getHour(), logonTime.getMinute(), logonTime.getSecond()),
LocalTimeOnly(logoutTime.getHour(), logoutTime.getMinute(), logoutTime.getSecond()),
logonDay, logoutDay );
TimeRange logonTimeRange = useLocalTime ? localLogonTime : utcLogonTime;
if( !sessionTimeRange.isInRange(logonTime, logonDay) )
throw ConfigError( "LogonTime must be between StartTime and EndTime" );
if( !sessionTimeRange.isInRange(logoutTime, logoutDay) )
throw ConfigError( "LogoutTime must be between StartTime and EndTime" );
pSession->setLogonTime( logonTimeRange );
if ( settings.has( SEND_REDUNDANT_RESENDREQUESTS ) )
pSession->setSendRedundantResendRequests( settings.getBool( SEND_REDUNDANT_RESENDREQUESTS ) );
if ( settings.has( CHECK_COMPID ) )
pSession->setCheckCompId( settings.getBool( CHECK_COMPID ) );
if ( settings.has( CHECK_LATENCY ) )
pSession->setCheckLatency( settings.getBool( CHECK_LATENCY ) );
if ( settings.has( MAX_LATENCY ) )
pSession->setMaxLatency( settings.getInt( MAX_LATENCY ) );
if ( settings.has( LOGON_TIMEOUT ) )
pSession->setLogonTimeout( settings.getInt( LOGON_TIMEOUT ) );
if ( settings.has( LOGOUT_TIMEOUT ) )
pSession->setLogoutTimeout( settings.getInt( LOGOUT_TIMEOUT ) );
if ( settings.has( RESET_ON_LOGON ) )
pSession->setResetOnLogon( settings.getBool( RESET_ON_LOGON ) );
if ( settings.has( RESET_ON_LOGOUT ) )
pSession->setResetOnLogout( settings.getBool( RESET_ON_LOGOUT ) );
if ( settings.has( RESET_ON_DISCONNECT ) )
pSession->setResetOnDisconnect( settings.getBool( RESET_ON_DISCONNECT ) );
if ( settings.has( REFRESH_ON_LOGON ) )
pSession->setRefreshOnLogon( settings.getBool( REFRESH_ON_LOGON ) );
if ( settings.has( MILLISECONDS_IN_TIMESTAMP ) )
pSession->setMillisecondsInTimeStamp( settings.getBool( MILLISECONDS_IN_TIMESTAMP ) );
if ( settings.has( PERSIST_MESSAGES ) )
pSession->setPersistMessages( settings.getBool( PERSIST_MESSAGES ) );
if ( settings.has( VALIDATE_LENGTH_AND_CHECKSUM ) )
pSession->setValidateLengthAndChecksum( settings.getBool( VALIDATE_LENGTH_AND_CHECKSUM ) );
return pSession.release();
}
FIX::LOGON_TIMEOUT
const char LOGON_TIMEOUT[]
Definition: SessionSettings.h:74
FIX::UtcTimeOnlyConvertor::convert
static std::string convert(const UtcTimeOnly &value, bool showMilliseconds=false)
Definition: FieldConvertors.h:689
FIX::RESET_ON_LOGON
const char RESET_ON_LOGON[]
Definition: SessionSettings.h:121
FIX::RESET_ON_DISCONNECT
const char RESET_ON_DISCONNECT[]
Definition: SessionSettings.h:123
FIX::LOGOUT_DAY
const char LOGOUT_DAY[]
Definition: SessionSettings.h:57
FIX::SessionFactory::m_pLogFactory
LogFactory * m_pLogFactory
Definition: SessionFactory.h:81
FIX::FIELD::HeartBtInt
const int HeartBtInt
Definition: FixFieldNumbers.h:240
FIX::RESET_ON_LOGOUT
const char RESET_ON_LOGOUT[]
Definition: SessionSettings.h:122
FIX::CONNECTION_TYPE
const char CONNECTION_TYPE[]
Definition: SessionSettings.h:42
FIX::LOGOUT_TIME
const char LOGOUT_TIME[]
Definition: SessionSettings.h:55
FIX::MAX_LATENCY
const char MAX_LATENCY[]
Definition: SessionSettings.h:60
FIX::DEFAULT_APPLVERID
const char DEFAULT_APPLVERID[]
Definition: SessionSettings.h:41
FIX::TYPE::UtcTimeOnly
Definition: FieldTypes.h:684
FIX::Message::toApplVerID
static ApplVerID toApplVerID(const BeginString &value)
Definition: Message.h:257
FIX::SessionFactory::processFixDataDictionary
void processFixDataDictionary(const SessionID &sessionID, const Dictionary &settings, DataDictionaryProvider &provider)
Definition: SessionFactory.cpp:266
FIX::SEND_REDUNDANT_RESENDREQUESTS
const char SEND_REDUNDANT_RESENDREQUESTS[]
Definition: SessionSettings.h:45
FIX::SESSION_QUALIFIER
const char SESSION_QUALIFIER[]
Definition: SessionSettings.h:40
FIX::LOGON_TIME
const char LOGON_TIME[]
Definition: SessionSettings.h:54
FIX::SessionFactory::m_messageStoreFactory
MessageStoreFactory & m_messageStoreFactory
Definition: SessionFactory.h:80
FIX::END_TIME
const char END_TIME[]
Definition: SessionSettings.h:51
FIX::SessionFactory::processFixtDataDictionaries
void processFixtDataDictionaries(const SessionID &sessionID, const Dictionary &settings, DataDictionaryProvider &provider)
Definition: SessionFactory.cpp:235
FIX::END_DAY
const char END_DAY[]
Definition: SessionSettings.h:53
FIX::START_DAY
const char START_DAY[]
Definition: SessionSettings.h:52
FIX::CHECK_COMPID
const char CHECK_COMPID[]
Definition: SessionSettings.h:58
FIX::SessionFactory::m_application
Application & m_application
Definition: SessionFactory.h:79
FIX::VALIDATE_LENGTH_AND_CHECKSUM
const char VALIDATE_LENGTH_AND_CHECKSUM[]
Definition: SessionSettings.h:70
FIX::LOGOUT_TIMEOUT
const char LOGOUT_TIMEOUT[]
Definition: SessionSettings.h:75
FIX::START_TIME
const char START_TIME[]
Definition: SessionSettings.h:50
FIX::LOGON_DAY
const char LOGON_DAY[]
Definition: SessionSettings.h:56
FIX::MILLISECONDS_IN_TIMESTAMP
const char MILLISECONDS_IN_TIMESTAMP[]
Definition: SessionSettings.h:125
FIX::USE_DATA_DICTIONARY
const char USE_DATA_DICTIONARY[]
Definition: SessionSettings.h:43
FIX::USE_LOCAL_TIME
const char USE_LOCAL_TIME[]
Definition: SessionSettings.h:49
FIX::PERSIST_MESSAGES
const char PERSIST_MESSAGES[]
Definition: SessionSettings.h:127
FIX::HEARTBTINT
const char HEARTBTINT[]
Definition: SessionSettings.h:61
FIX::CHECK_LATENCY
const char CHECK_LATENCY[]
Definition: SessionSettings.h:59
FIX::REFRESH_ON_LOGON
const char REFRESH_ON_LOGON[]
Definition: SessionSettings.h:124

## createDataDictionary()

ptr::shared_ptr< DataDictionary > FIX::SessionFactory::createDataDictionary | ( | const SessionID & | sessionID,
|  | const Dictionary & | settings,
|  | const std::string & | settingsKey
| ) |  |
throw | ( | ConfigError
| ) |  |

private

Definition at line 206 of file SessionFactory.cpp.

References m_dictionaries, FIX::VALIDATE_FIELDS_HAVE_VALUES, FIX::VALIDATE_FIELDS_OUT_OF_ORDER, and FIX::VALIDATE_USER_DEFINED_FIELDS.

Referenced by processFixDataDictionary(), and processFixtDataDictionaries().

{
ptr::shared_ptr<DataDictionary> pDD;
std::string path = settings.getString( settingsKey );
Dictionaries::iterator i = m_dictionaries.find( path );
if ( i != m_dictionaries.end() )
{
pDD = i->second;
}
else
{
pDD = ptr::shared_ptr<DataDictionary>(new DataDictionary( path ));
m_dictionaries[ path ] = pDD;
}
ptr::shared_ptr<DataDictionary> pCopyOfDD = ptr::shared_ptr<DataDictionary>(new DataDictionary(*pDD));
if( settings.has( VALIDATE_FIELDS_OUT_OF_ORDER ) )
pCopyOfDD->checkFieldsOutOfOrder( settings.getBool( VALIDATE_FIELDS_OUT_OF_ORDER ) );
if( settings.has( VALIDATE_FIELDS_HAVE_VALUES ) )
pCopyOfDD->checkFieldsHaveValues( settings.getBool( VALIDATE_FIELDS_HAVE_VALUES ) );
if( settings.has( VALIDATE_USER_DEFINED_FIELDS ) )
pCopyOfDD->checkUserDefinedFields( settings.getBool( VALIDATE_USER_DEFINED_FIELDS ) );
return pCopyOfDD;
}
FIX::VALIDATE_FIELDS_HAVE_VALUES
const char VALIDATE_FIELDS_HAVE_VALUES[]
Definition: SessionSettings.h:72
FIX::VALIDATE_FIELDS_OUT_OF_ORDER
const char VALIDATE_FIELDS_OUT_OF_ORDER[]
Definition: SessionSettings.h:71
FIX::VALIDATE_USER_DEFINED_FIELDS
const char VALIDATE_USER_DEFINED_FIELDS[]
Definition: SessionSettings.h:73
FIX::SessionFactory::m_dictionaries
Dictionaries m_dictionaries
Definition: SessionFactory.h:82

## destroy()

void FIX::SessionFactory::destroy | ( | Session * | pSession | ) |

Definition at line 201 of file SessionFactory.cpp.

Referenced by SessionFactory().

{
delete pSession;
}

## processFixDataDictionary()

void FIX::SessionFactory::processFixDataDictionary | ( | const SessionID & | sessionID,
|  | const Dictionary & | settings,
|  | DataDictionaryProvider & | provider
| ) |  |
throw | ( | ConfigError
| ) |  |

private

Definition at line 266 of file SessionFactory.cpp.

References createDataDictionary(), FIX::DATA_DICTIONARY, and FIX::Message::toApplVerID().

Referenced by create().

{
ptr::shared_ptr<DataDictionary> pDataDictionary = createDataDictionary(sessionID, settings, DATA_DICTIONARY);
provider.addTransportDataDictionary(sessionID.getBeginString(), pDataDictionary);
provider.addApplicationDataDictionary(Message::toApplVerID(sessionID.getBeginString()), pDataDictionary);
}
FIX::SessionFactory::createDataDictionary
ptr::shared_ptr< DataDictionary > createDataDictionary(const SessionID &sessionID, const Dictionary &settings, const std::string &settingsKey)
Definition: SessionFactory.cpp:206
FIX::Message::toApplVerID
static ApplVerID toApplVerID(const BeginString &value)
Definition: Message.h:257
FIX::DATA_DICTIONARY
const char DATA_DICTIONARY[]
Definition: SessionSettings.h:46

## processFixtDataDictionaries()

void FIX::SessionFactory::processFixtDataDictionaries | ( | const SessionID & | sessionID,
|  | const Dictionary & | settings,
|  | DataDictionaryProvider & | provider
| ) |  |
throw | ( | ConfigError
| ) |  |

private

Definition at line 235 of file SessionFactory.cpp.

References FIX::APP_DATA_DICTIONARY, createDataDictionary(), FIX::DEFAULT_APPLVERID, FIX::string_toUpper(), FIX::Message::toApplVerID(), and FIX::TRANSPORT_DATA_DICTIONARY.

Referenced by create().

{
ptr::shared_ptr<DataDictionary> pDataDictionary = createDataDictionary(sessionID, settings, TRANSPORT_DATA_DICTIONARY);
provider.addTransportDataDictionary(sessionID.getBeginString(), pDataDictionary);
for(Dictionary::const_iterator data = settings.begin(); data != settings.end(); ++data)
{
const std::string& key = data->first;
const std::string frontKey = key.substr(0, strlen(APP_DATA_DICTIONARY));
if( frontKey == string_toUpper(APP_DATA_DICTIONARY) )
{
if( key == string_toUpper(APP_DATA_DICTIONARY) )
{
provider.addApplicationDataDictionary(Message::toApplVerID(settings.getString(DEFAULT_APPLVERID)),
createDataDictionary(sessionID, settings, APP_DATA_DICTIONARY));
}
else
{
std::string::size_type offset = key.find('.');
if( offset == std::string::npos )
throw ConfigError(std::string("Malformed ") + APP_DATA_DICTIONARY + ": " + key);
std::string beginStringQualifier = key.substr(offset+1);
provider.addApplicationDataDictionary(Message::toApplVerID(beginStringQualifier),
createDataDictionary(sessionID, settings, key));
}
}
}
}
FIX::SessionFactory::createDataDictionary
ptr::shared_ptr< DataDictionary > createDataDictionary(const SessionID &sessionID, const Dictionary &settings, const std::string &settingsKey)
Definition: SessionFactory.cpp:206
FIX::DEFAULT_APPLVERID
const char DEFAULT_APPLVERID[]
Definition: SessionSettings.h:41
FIX::Message::toApplVerID
static ApplVerID toApplVerID(const BeginString &value)
Definition: Message.h:257
FIX::TRANSPORT_DATA_DICTIONARY
const char TRANSPORT_DATA_DICTIONARY[]
Definition: SessionSettings.h:47
FIX::string_toUpper
std::string string_toUpper(const std::string &value)
Definition: Utility.cpp:53
FIX::Dictionary::const_iterator
iterator const_iterator
Definition: Dictionary.h:45
FIX::APP_DATA_DICTIONARY
const char APP_DATA_DICTIONARY[]
Definition: SessionSettings.h:48

## toApplVerID()

std::string FIX::SessionFactory::toApplVerID | ( | const std::string & | value | ) |

private

## Member Data Documentation

## m_application

Application& FIX::SessionFactory::m_application

private

Definition at line 79 of file SessionFactory.h.

Referenced by create().

## m_dictionaries

Dictionaries FIX::SessionFactory::m_dictionaries

private

Definition at line 82 of file SessionFactory.h.

Referenced by createDataDictionary().

## m_messageStoreFactory

MessageStoreFactory& FIX::SessionFactory::m_messageStoreFactory

private

Definition at line 80 of file SessionFactory.h.

Referenced by create().

## m_pLogFactory

LogFactory* FIX::SessionFactory::m_pLogFactory

private

Definition at line 81 of file SessionFactory.h.

Referenced by create().

The documentation for this class was generated from the following files:

- SessionFactory.h
- SessionFactory.cpp