Log* FileLogFactory::create() { QF_STACK_PUSH(FileLogFactory::create) m_globalLogCount++; if( m_globalLogCount > 1 ) return m_globalLog; try { if ( m_path.size() ) return new FileLog( m_path ); std::string path; std::string backupPath; Dictionary settings = m_settings.get(); path = settings.getString( FILE_LOG_PATH ); backupPath = path; if( settings.has( FILE_LOG_BACKUP_PATH ) ) backupPath = settings.getString( FILE_LOG_BACKUP_PATH ); return m_globalLog = new FileLog( path ); } catch( ConfigError& ) { m_globalLogCount--; throw; } QF_STACK_POP }
void SocketInitiator::onDisconnect( SocketConnector&, int s ) { QF_STACK_PUSH(SocketInitiator::onDisconnect) SocketConnections::iterator i = m_connections.find( s ); SocketConnections::iterator j = m_pendingConnections.find( s ); SocketConnection* pSocketConnection = 0; if( i != m_connections.end() ) pSocketConnection = i->second; if( j != m_pendingConnections.end() ) pSocketConnection = j->second; if( !pSocketConnection ) return; setDisconnected( pSocketConnection->getSession()->getSessionID() ); Session* pSession = pSocketConnection->getSession(); if ( pSession ) { pSession->disconnect(); setDisconnected( pSession->getSessionID() ); } delete pSocketConnection; m_connections.erase( s ); m_pendingConnections.erase( s ); QF_STACK_POP }
void SessionFactory::processFixtDataDictionaries(const SessionID& sessionID, const Dictionary& settings, DataDictionaryProvider& provider) throw(ConfigError) { QF_STACK_PUSH(SessionFactory::processFixtDataDictionaries) DataDictionary dataDictionary = createDataDictionary(sessionID, settings, TRANSPORT_DATA_DICTIONARY); provider.addTransportDataDictionary(sessionID.getBeginString(), dataDictionary); 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) ) { DataDictionary dataDictionary = createDataDictionary(sessionID, settings, APP_DATA_DICTIONARY); provider.addApplicationDataDictionary(Message::toApplVerID(settings.getString(DEFAULT_APPLVERID)), dataDictionary); } 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); DataDictionary dataDictionary = createDataDictionary(sessionID, settings, key); provider.addApplicationDataDictionary(Message::toApplVerID(beginStringQualifier), dataDictionary); } } } QF_STACK_POP }
void onWrite( SocketMonitor&, int socket ) { QF_STACK_PUSH(ConnectorWrapper::onWrite) m_strategy.onWrite( m_connector, socket ); QF_STACK_POP }
bool SocketConnection::processQueue() { QF_STACK_PUSH(SocketConnection::processQueue) Locker l( m_mutex ); if( !m_sendQueue.size() ) return true; struct timeval timeout = { 0, 0 }; fd_set writeset = m_fds; if( select( 1 + m_socket, 0, &writeset, 0, &timeout ) <= 0 ) return false; const std::string& msg = m_sendQueue.front(); int result = socket_send ( m_socket, msg.c_str() + m_sendLength, msg.length() - m_sendLength ); if( result > 0 ) m_sendLength += result; if( m_sendLength == msg.length() ) { m_sendLength = 0; m_sendQueue.pop_front(); } return !m_sendQueue.size(); QF_STACK_POP }
void NullStore::get( int begin, int end, std::vector < std::string > & messages ) const throw( IOException ) { QF_STACK_PUSH(NullStore::get) messages.clear(); QF_STACK_POP }
void HttpMessage::setString( const std::string& string ) throw( InvalidMessage ) { QF_STACK_PUSH(HttpMessage::setString) clear(); std::string::size_type eolPos = string.find( "\r\n" ); if( eolPos == std::string::npos ) throw InvalidMessage(); std::string line = string.substr( 0, eolPos ); std::string::size_type getPos = line.find( "GET " ); if( getPos != 0 ) throw InvalidMessage(); std::string::size_type httpPos = line.rfind( "HTTP", std::string::npos ); if( httpPos == std::string::npos ) throw InvalidMessage(); m_root = line.substr( getPos + 4, httpPos - 5 ); std::string::size_type paramPos = m_root.find_first_of( '?' ); if( paramPos == std::string::npos ) return; std::string parameters = m_root.substr( paramPos, m_root.size() - paramPos ); m_root = m_root.substr( 0, paramPos ); paramPos = 0; while( paramPos != std::string::npos ) { std::string::size_type sepPos = parameters.find_first_of( "=", paramPos ); if( sepPos == std::string::npos ) break; std::string::size_type tempPos = paramPos; paramPos = parameters.find_first_of( "&", paramPos + 1 ); std::string key = parameters.substr(tempPos + 1, sepPos - tempPos - 1); std::string value = parameters.substr(sepPos + 1, paramPos - sepPos - 1); m_parameters[key] = value; } QF_STACK_POP }
void OdbcLogFactory::destroy( Log* pLog ) { QF_STACK_PUSH(OdbcLogFactory::destroy) delete pLog; QF_STACK_POP }
void OdbcLogFactory::init( const Dictionary& settings, std::string& user, std::string& password, std::string& connectionString ) { QF_STACK_PUSH(OdbcLogFactory::init) user = DEFAULT_USER; password = DEFAULT_PASSWORD; connectionString = DEFAULT_CONNECTION_STRING; if( m_useSettings ) { try { user = settings.getString( ODBC_LOG_USER ); } catch( ConfigError& ) {} try { password = settings.getString( ODBC_LOG_PASSWORD ); } catch( ConfigError& ) {} try { connectionString = settings.getString( ODBC_LOG_CONNECTION_STRING ); } catch( ConfigError& ) {} } else { user = m_user; password = m_password; connectionString = m_connectionString; } QF_STACK_POP }
void onError( SocketMonitor&, int socket ) { QF_STACK_PUSH(ConnectorWrapper::onError) m_strategy.onDisconnect( m_connector, socket ); QF_STACK_POP }
std::string HttpMessage::toString() const { QF_STACK_PUSH(HttpMessage::toString) std::string str; return toString( str ); QF_STACK_POP }
bool FieldMap::hasGroup( int field ) const { QF_STACK_PUSH(FieldMap::hasGroup) Groups::const_iterator i = m_groups.find( field ); return i != m_groups.end(); QF_STACK_POP }
std::string& HttpMessage::toString( std::string& str ) const { QF_STACK_PUSH(HttpMessage::toString) str = m_root + getParameterString(); return str; QF_STACK_POP }
void ThreadedSocketConnection::disconnect() { QF_STACK_PUSH(ThreadedSocketConnection::disconnect) m_disconnect = true; socket_close( m_socket ); QF_STACK_POP }
void FieldMap::removeField( int field ) { QF_STACK_PUSH(FieldMap::removeField) Fields::iterator i = m_fields.find( field ); if ( i != m_fields.end() ) m_fields.erase( i ); QF_STACK_POP }
bool SocketInitiator::onData( SocketConnector& connector, int s ) { QF_STACK_PUSH(SocketInitiator::onData) SocketConnections::iterator i = m_connections.find( s ); if ( i == m_connections.end() ) return false; SocketConnection* pSocketConnection = i->second; return pSocketConnection->read( connector ); QF_STACK_POP }
std::string Message::toString( int beginStringField, int bodyLengthField, int checkSumField ) const { QF_STACK_PUSH(Message::toString) std::string str; return toString( str, beginStringField, bodyLengthField, checkSumField ); QF_STACK_POP }
int FieldMap::groupCount( int field ) const { QF_STACK_PUSH(FieldMap::groupCount) Groups::const_iterator i = m_groups.find( field ); if( i == m_groups.end() ) return 0; return i->second.size(); QF_STACK_POP }
void Acceptor::block() throw ( ConfigError, RuntimeError ) { QF_STACK_PUSH( Acceptor::start ) m_stop = false; onConfigure( m_settings ); onInitialize( m_settings ); startThread(this); QF_STACK_POP }
void SessionFactory::processFixDataDictionary(const SessionID& sessionID, const Dictionary& settings, DataDictionaryProvider& provider) throw(ConfigError) { QF_STACK_PUSH(SessionFactory::processFixDataDictionary) DataDictionary dataDictionary = createDataDictionary(sessionID, settings, DATA_DICTIONARY); provider.addTransportDataDictionary(sessionID.getBeginString(), dataDictionary); provider.addApplicationDataDictionary(Message::toApplVerID(sessionID.getBeginString()), dataDictionary); QF_STACK_POP }
void FieldMap::replaceGroup( int num, int field, FieldMap& group ) { QF_STACK_PUSH(FieldMap::replaceGroup) Groups::const_iterator i = m_groups.find( field ); if ( i == m_groups.end() ) return; if ( num <= 0 ) return; if ( i->second.size() < ( unsigned ) num ) return; *( *( i->second.begin() + ( num - 1 ) ) ) = group; QF_STACK_POP }
void SocketInitiator::onWrite( SocketConnector& connector, int s ) { QF_STACK_PUSH(SocketInitiator::onWrite) SocketConnections::iterator i = m_connections.find( s ); if ( i == m_connections.end() ) return ; SocketConnection* pSocketConnection = i->second; if( pSocketConnection->processQueue() ) pSocketConnection->unsignal(); QF_STACK_POP }
Session* Acceptor::getSession( const SessionID& sessionID ) const { QF_STACK_PUSH(Initiator::getSession) Sessions::const_iterator i = m_sessions.find( sessionID ); if( i != m_sessions.end() ) return i->second; else return 0; QF_STACK_POP }
void FieldMap::addGroup( int field, const FieldMap& group, bool setCount ) { QF_STACK_PUSH(FieldMap::addGroup) FieldMap * pGroup = new FieldMap( group.m_fields.key_comp() ); *pGroup = group; m_groups[ field ].push_back( pGroup ); Groups::iterator i = m_groups.find( field ); if( setCount ) setField( IntField( field, i->second.size() ) ); QF_STACK_POP }
bool SocketMonitor::addRead( int s ) { QF_STACK_PUSH(SocketMonitor::addRead) socket_setnonblock( s ); Sockets::iterator i = m_readSockets.find( s ); if( i != m_readSockets.end() ) return false; m_readSockets.insert( s ); return true; QF_STACK_POP }
FieldMap& FieldMap::getGroup( int num, int field, FieldMap& group ) const throw( FieldNotFound ) { QF_STACK_PUSH(FieldMap::getGroup) Groups::const_iterator i = m_groups.find( field ); if ( i == m_groups.end() ) throw FieldNotFound( field ); if ( num <= 0 ) throw FieldNotFound( field ); if ( i->second.size() < ( unsigned ) num ) throw FieldNotFound( field ); group = *( *( i->second.begin() + ( num - 1 ) ) ); return group; QF_STACK_POP }
Log* OdbcLogFactory::create() { QF_STACK_PUSH(OdbcLogFactory::create) std::string database; std::string user; std::string connectionString; init( m_settings.get(), database, user, connectionString ); OdbcLog* result = new OdbcLog( database, user, connectionString ); initLog( m_settings.get(), *result ); return result; QF_STACK_POP }
void SocketInitiator::onConnect( SocketConnector&, int s ) { QF_STACK_PUSH(SocketInitiator::onConnect) SocketConnections::iterator i = m_pendingConnections.find( s ); if( i == m_pendingConnections.end() ) return; SocketConnection* pSocketConnection = i->second; m_connections[s] = pSocketConnection; m_pendingConnections.erase( i ); setConnected( pSocketConnection->getSession()->getSessionID() ); pSocketConnection->onTimeout(); QF_STACK_POP }
void Acceptor::start() throw ( ConfigError, RuntimeError ) { QF_STACK_PUSH( Acceptor::start ) m_stop = false; onConfigure( m_settings ); onInitialize( m_settings ); HttpServer::startGlobal( m_settings ); if( !thread_spawn( &startThread, this, m_threadid ) ) throw RuntimeError("Unable to spawn thread"); QF_STACK_POP }
void FieldMap::clear() { QF_STACK_PUSH(FieldMap::clear) m_fields.clear(); Groups::iterator i; for ( i = m_groups.begin(); i != m_groups.end(); ++i ) { std::vector < FieldMap* > ::iterator j; for ( j = i->second.begin(); j != i->second.end(); ++j ) delete *j; } m_groups.clear(); QF_STACK_POP }