quickfix_ruby 1.14.3

data/ext/quickfix/SessionID.h

@@ -0,0 +1,170 @@
+/* -*- C++ -*- */
+
+/****************************************************************************
+** Copyright (c) 2001-2014
+**
+** This file is part of the QuickFIX FIX Engine
+**
+** This file may be distributed under the terms of the quickfixengine.org
+** license as defined by quickfixengine.org and appearing in the file
+** LICENSE included in the packaging of this file.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.quickfixengine.org/LICENSE for licensing information.
+**
+** Contact ask@quickfixengine.org if any conditions of this licensing are
+** not clear to you.
+**
+****************************************************************************/
+
+#ifndef FIX_SESSIONID_H
+#define FIX_SESSIONID_H
+
+#include "Fields.h"
+
+namespace FIX
+{
+/// Unique session id consists of BeginString, SenderCompID and TargetCompID.
+class SessionID
+{
+public:
+  SessionID()
+  {
+    toString(m_frozenString);
+  }
+
+  SessionID( const std::string& beginString,
+             const std::string& senderCompID,
+             const std::string& targetCompID,
+             const std::string& sessionQualifier = "" )
+  : m_beginString( BeginString(beginString) ),
+    m_senderCompID( SenderCompID(senderCompID) ),
+    m_targetCompID( TargetCompID(targetCompID) ),
+    m_sessionQualifier( sessionQualifier ),
+    m_isFIXT(false)
+  {
+    toString(m_frozenString);
+    if( beginString.substr(0, 4) == "FIXT" )
+      m_isFIXT = true;
+  }
+
+  const BeginString& getBeginString() const
+    { return m_beginString; }
+  const SenderCompID& getSenderCompID() const
+    { return m_senderCompID; }
+  const TargetCompID& getTargetCompID() const
+    { return m_targetCompID; }
+  const std::string& getSessionQualifier() const
+    { return m_sessionQualifier; }
+  const bool isFIXT() const
+    { return m_isFIXT; }
+
+  /// Get a string representation of the SessionID
+  std::string toString() const
+  {
+    return m_frozenString;
+  }
+    
+  // Return a reference for a high-performance scenario
+  const std::string& toStringFrozen() const
+  {
+    return m_frozenString;
+  }
+
+  /// Build from string representation of SessionID
+  void fromString( const std::string& str )
+  {
+    std::string::size_type first =
+      str.find_first_of(':');
+    std::string::size_type second =
+      str.find("->");
+    std::string::size_type third =
+      str.find_last_of(':');
+    if( first == std::string::npos )
+      return;
+    if( second == std::string::npos )
+      return;
+    m_beginString = str.substr(0, first);
+    m_senderCompID = str.substr(first+1, second - first - 1);
+    if( first == third )
+    {
+      m_targetCompID = str.substr(second+2);
+      m_sessionQualifier = "";
+    }
+    else
+    {
+      m_targetCompID = str.substr(second+2, third - second - 2);
+      m_sessionQualifier = str.substr(third+1);
+    }
+    toString(m_frozenString);
+  }
+
+  /// Get a string representation without making a copy
+  std::string& toString( std::string& str ) const
+  {
+    str = getBeginString().getValue() + ":" +
+          getSenderCompID().getValue() + "->" +
+          getTargetCompID().getValue();
+    if( m_sessionQualifier.size() )
+      str += ":" + m_sessionQualifier;
+    return str;
+  }
+
+  friend bool operator<( const SessionID&, const SessionID& );
+  friend bool operator==( const SessionID&, const SessionID& );
+  friend bool operator!=( const SessionID&, const SessionID& );
+  friend std::ostream& operator<<( std::ostream&, const SessionID& );
+  friend std::ostream& operator>>( std::ostream&, const SessionID& );
+
+  SessionID operator~() const
+  {
+    return SessionID( m_beginString, SenderCompID( m_targetCompID ),
+                      TargetCompID( m_senderCompID ), m_sessionQualifier );
+  }
+
+private:
+  BeginString m_beginString;
+  SenderCompID m_senderCompID;
+  TargetCompID m_targetCompID;
+  std::string m_sessionQualifier;
+  bool m_isFIXT;
+  std::string m_frozenString;
+};
+/*! @} */
+
+inline bool operator<( const SessionID& lhs, const SessionID& rhs )
+{
+  return lhs.toStringFrozen() < rhs.toStringFrozen();
+}
+
+inline bool operator==( const SessionID& lhs, const SessionID& rhs )
+{
+  return lhs.toStringFrozen() == rhs.toStringFrozen();
+}
+
+inline bool operator!=( const SessionID& lhs, const SessionID& rhs )
+{
+  return !( lhs == rhs );
+}
+
+inline std::ostream& operator<<
+( std::ostream& stream, const SessionID& sessionID )
+{
+  stream << sessionID.toStringFrozen();
+  return stream;
+}
+
+inline std::istream& operator>>
+( std::istream& stream, SessionID& sessionID )
+{
+  std::string str;
+  stream >> str;
+  sessionID.fromString( str );
+  return stream;
+}
+
+}
+#endif //FIX_SESSIONID_H
+

data/ext/quickfix/SessionSettings.cpp

@@ -0,0 +1,189 @@
+/****************************************************************************
+** Copyright (c) 2001-2014
+**
+** This file is part of the QuickFIX FIX Engine
+**
+** This file may be distributed under the terms of the quickfixengine.org
+** license as defined by quickfixengine.org and appearing in the file
+** LICENSE included in the packaging of this file.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.quickfixengine.org/LICENSE for licensing information.
+**
+** Contact ask@quickfixengine.org if any conditions of this licensing are
+** not clear to you.
+**
+****************************************************************************/
+
+#ifdef _MSC_VER
+#include "stdafx.h"
+#else
+#include "config.h"
+#endif
+
+#include "SessionSettings.h"
+#include "Settings.h"
+#include "Values.h"
+#include <fstream>
+
+namespace FIX
+{
+SessionSettings::SessionSettings( std::istream& stream )
+throw( ConfigError )
+{
+  stream >> *this;
+}
+
+SessionSettings::SessionSettings( const std::string& file )
+throw( ConfigError )
+{
+  std::ifstream fstream( file.c_str() );
+  if ( !fstream.is_open() )
+    throw ConfigError( ( "File " + file + " not found" ).c_str() );
+  fstream >> *this;
+}
+
+std::istream& operator>>( std::istream& stream, SessionSettings& s )
+throw( ConfigError )
+{
+  Settings settings;
+  stream >> settings;
+
+  Settings::Sections section;
+
+  section = settings.get( "DEFAULT" );
+  Dictionary def;
+  if ( section.size() )
+    def = section[ 0 ];
+  s.set( def );
+
+  section = settings.get( "SESSION" );
+  Settings::Sections::size_type session;
+  Dictionary dict;
+
+  for ( session = 0; session < section.size(); ++session )
+  {
+    dict = section[ session ];
+    dict.merge( def );
+
+    BeginString beginString
+    ( dict.getString( BEGINSTRING ) );
+    SenderCompID senderCompID
+    ( dict.getString( SENDERCOMPID ) );
+    TargetCompID targetCompID
+    ( dict.getString( TARGETCOMPID ) );
+
+    std::string sessionQualifier;
+    if( dict.has( SESSION_QUALIFIER ) )
+      sessionQualifier = dict.getString( SESSION_QUALIFIER );
+    SessionID sessionID( beginString, senderCompID, targetCompID, sessionQualifier );
+    s.set( sessionID, dict );
+  }
+  return stream;
+}
+
+std::ostream& operator<<( std::ostream& stream, const SessionSettings& s )
+{
+  const Dictionary& defaults = s.m_defaults;
+  if( defaults.size() )
+  {
+    stream << "[DEFAULT]" << std::endl;
+    Dictionary::iterator i;
+    for( i = defaults.begin(); i != defaults.end(); ++i )
+      stream << i->first << "=" << i->second << std::endl;
+    stream << std::endl;
+  }
+
+  std::set<SessionID> sessions = s.getSessions();
+  std::set<SessionID>::iterator i;
+  for( i = sessions.begin(); i != sessions.end(); ++i )
+  {
+    stream << "[SESSION]" << std::endl;
+    const Dictionary& section = s.get( *i );
+    if( !section.size() ) continue;
+
+    Dictionary::iterator i;
+    for( i = section.begin(); i != section.end(); ++i )
+    {
+      if( defaults.has(i->first) && defaults.getString(i->first) == i->second )
+        continue;
+      stream << i->first << "=" << i->second << std::endl;
+    }
+    stream << std::endl;
+  }
+
+  return stream;
+}
+
+const bool SessionSettings::has( const SessionID& sessionID ) const
+{
+  return m_settings.find( sessionID ) != m_settings.end();
+}
+
+const Dictionary& SessionSettings::get( const SessionID& sessionID ) const
+throw( ConfigError )
+{
+  Dictionaries::const_iterator i;
+  i = m_settings.find( sessionID );
+  if ( i == m_settings.end() ) throw ConfigError( "Session not found" );
+  return i->second;
+}
+
+void SessionSettings::set( const SessionID& sessionID,
+                           Dictionary settings )
+throw( ConfigError )
+{
+  if( has(sessionID) )
+    throw ConfigError( "Duplicate Session " + sessionID.toString() );
+
+  settings.setString( BEGINSTRING, sessionID.getBeginString() );
+  settings.setString( SENDERCOMPID, sessionID.getSenderCompID() );
+  settings.setString( TARGETCOMPID, sessionID.getTargetCompID() );
+
+  settings.merge( m_defaults );
+  validate( settings );
+  m_settings[ sessionID ] = settings;
+}
+
+void SessionSettings::set( const Dictionary& defaults ) throw( ConfigError ) 
+{ 
+  m_defaults = defaults;
+  Dictionaries::iterator i = m_settings.begin();
+  for( i = m_settings.begin(); i != m_settings.end(); ++i )
+    i->second.merge( defaults );
+}
+
+std::set < SessionID > SessionSettings::getSessions() const
+{
+  std::set < SessionID > result;
+  Dictionaries::const_iterator i;
+  for ( i = m_settings.begin(); i != m_settings.end(); ++i )
+    result.insert( i->first );
+  return result;
+}
+
+void SessionSettings::validate( const Dictionary& dictionary ) const
+throw( ConfigError )
+{
+  std::string beginString = dictionary.getString( BEGINSTRING );
+  if( beginString != BeginString_FIX40 &&
+      beginString != BeginString_FIX41 &&
+      beginString != BeginString_FIX42 &&
+      beginString != BeginString_FIX43 &&
+      beginString != BeginString_FIX44 &&
+      beginString != BeginString_FIXT11 )
+  {
+    throw ConfigError( std::string(BEGINSTRING) + " must be FIX.4.0 to FIX.4.4 or FIXT.1.1" );
+  }
+
+  std::string connectionType = dictionary.getString( CONNECTION_TYPE );
+  if( connectionType != "initiator" &&
+      connectionType != "acceptor" )
+  {
+    throw ConfigError( std::string(CONNECTION_TYPE) + " must be 'initiator' or 'acceptor'" );
+  }
+}
+
+}

data/ext/quickfix/SessionSettings.h

@@ -0,0 +1,171 @@
+/* -*- C++ -*- */
+
+/****************************************************************************
+** Copyright (c) 2001-2014
+**
+** This file is part of the QuickFIX FIX Engine
+**
+** This file may be distributed under the terms of the quickfixengine.org
+** license as defined by quickfixengine.org and appearing in the file
+** LICENSE included in the packaging of this file.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.quickfixengine.org/LICENSE for licensing information.
+**
+** Contact ask@quickfixengine.org if any conditions of this licensing are
+** not clear to you.
+**
+****************************************************************************/
+
+#ifndef FIX_SESSIONSETTINGS_H
+#define FIX_SESSIONSETTINGS_H
+
+#ifdef _MSC_VER
+#pragma warning( disable : 4503 4355 4786 4290 )
+#endif
+
+#include "Dictionary.h"
+#include "SessionID.h"
+#include "Exceptions.h"
+#include <map>
+#include <set>
+
+namespace FIX
+{
+const char BEGINSTRING[] = "BeginString";
+const char SENDERCOMPID[] = "SenderCompID";
+const char TARGETCOMPID[] = "TargetCompID";
+const char SESSION_QUALIFIER[] = "SessionQualifier";
+const char DEFAULT_APPLVERID[] = "DefaultApplVerID";
+const char CONNECTION_TYPE[] = "ConnectionType";
+const char USE_DATA_DICTIONARY[] = "UseDataDictionary";
+const char SEND_RESETSEQNUMFLAG[] = "SendResetSeqNumFlag";
+const char SEND_REDUNDANT_RESENDREQUESTS[] = "SendRedundantResendRequests";
+const char DATA_DICTIONARY[] = "DataDictionary";
+const char TRANSPORT_DATA_DICTIONARY[] = "TransportDataDictionary";
+const char APP_DATA_DICTIONARY[] = "AppDataDictionary";
+const char USE_LOCAL_TIME[] = "UseLocalTime";
+const char START_TIME[] = "StartTime";
+const char END_TIME[] = "EndTime";
+const char START_DAY[] = "StartDay";
+const char END_DAY[] = "EndDay";
+const char LOGON_TIME[] = "LogonTime";
+const char LOGOUT_TIME[] = "LogoutTime";
+const char LOGON_DAY[] = "LogonDay";
+const char LOGOUT_DAY[] = "LogoutDay";
+const char CHECK_COMPID[] = "CheckCompID";
+const char CHECK_LATENCY[] = "CheckLatency";
+const char MAX_LATENCY[] = "MaxLatency";
+const char HEARTBTINT[] = "HeartBtInt";
+const char SOCKET_ACCEPT_PORT[] = "SocketAcceptPort";
+const char SOCKET_REUSE_ADDRESS[] = "SocketReuseAddress";
+const char SOCKET_CONNECT_HOST[] = "SocketConnectHost";
+const char SOCKET_CONNECT_PORT[] = "SocketConnectPort";
+const char SOCKET_NODELAY[] = "SocketNodelay";
+const char SOCKET_SEND_BUFFER_SIZE[] = "SendBufferSize";
+const char SOCKET_RECEIVE_BUFFER_SIZE[] = "ReceiveBufferSize";
+const char RECONNECT_INTERVAL[] = "ReconnectInterval";
+const char VALIDATE_LENGTH_AND_CHECKSUM[] = "ValidateLengthAndChecksum";
+const char VALIDATE_FIELDS_OUT_OF_ORDER[] = "ValidateFieldsOutOfOrder";
+const char VALIDATE_FIELDS_HAVE_VALUES[] = "ValidateFieldsHaveValues";
+const char VALIDATE_USER_DEFINED_FIELDS[] = "ValidateUserDefinedFields";
+const char LOGON_TIMEOUT[] = "LogonTimeout";
+const char LOGOUT_TIMEOUT[] = "LogoutTimeout";
+const char FILE_STORE_PATH[] = "FileStorePath";
+const char MYSQL_STORE_USECONNECTIONPOOL[] = "MySQLStoreUseConnectionPool";
+const char MYSQL_STORE_DATABASE[] = "MySQLStoreDatabase";
+const char MYSQL_STORE_USER[] = "MySQLStoreUser";
+const char MYSQL_STORE_PASSWORD[] = "MySQLStorePassword";
+const char MYSQL_STORE_HOST[] = "MySQLStoreHost";
+const char MYSQL_STORE_PORT[] = "MySQLStorePort";
+const char POSTGRESQL_STORE_USECONNECTIONPOOL[] = "PostgreSQLStoreUseConnectionPool";
+const char POSTGRESQL_STORE_DATABASE[] = "PostgreSQLStoreDatabase";
+const char POSTGRESQL_STORE_USER[] = "PostgreSQLStoreUser";
+const char POSTGRESQL_STORE_PASSWORD[] = "PostgreSQLStorePassword";
+const char POSTGRESQL_STORE_HOST[] = "PostgreSQLStoreHost";
+const char POSTGRESQL_STORE_PORT[] = "PostgreSQLStorePort";
+const char ODBC_STORE_USER[] = "OdbcStoreUser";
+const char ODBC_STORE_PASSWORD[] = "OdbcStorePassword";
+const char ODBC_STORE_CONNECTION_STRING[] = "OdbcStoreConnectionString";
+const char FILE_LOG_PATH[] = "FileLogPath";
+const char FILE_LOG_BACKUP_PATH[] = "FileLogBackupPath";
+const char SCREEN_LOG_SHOW_INCOMING[] = "ScreenLogShowIncoming";
+const char SCREEN_LOG_SHOW_OUTGOING[] = "ScreenLogShowOutgoing";
+const char SCREEN_LOG_SHOW_EVENTS[] = "ScreenLogShowEvents";
+const char MYSQL_LOG_USECONNECTIONPOOL[] = "MySQLLogUseConnectionPool";
+const char MYSQL_LOG_DATABASE[] = "MySQLLogDatabase";
+const char MYSQL_LOG_USER[] = "MySQLLogUser";
+const char MYSQL_LOG_PASSWORD[] = "MySQLLogPassword";
+const char MYSQL_LOG_HOST[] = "MySQLLogHost";
+const char MYSQL_LOG_PORT[] = "MySQLLogPort";
+const char MYSQL_LOG_INCOMING_TABLE[] = "MySQLLogIncomingTable";
+const char MYSQL_LOG_OUTGOING_TABLE[] = "MySQLLogOutgoingTable";
+const char MYSQL_LOG_EVENT_TABLE[] = "MySQLLogEventTable";
+const char POSTGRESQL_LOG_USECONNECTIONPOOL[] = "PostgreSQLLogUseConnectionPool";
+const char POSTGRESQL_LOG_DATABASE[] = "PostgreSQLLogDatabase";
+const char POSTGRESQL_LOG_USER[] = "PostgreSQLLogUser";
+const char POSTGRESQL_LOG_PASSWORD[] = "PostgreSQLLogPassword";
+const char POSTGRESQL_LOG_HOST[] = "PostgreSQLLogHost";
+const char POSTGRESQL_LOG_PORT[] = "PostgreSQLLogPort";
+const char POSTGRESQL_LOG_INCOMING_TABLE[] = "PostgreSQLLogIncomingTable";
+const char POSTGRESQL_LOG_OUTGOING_TABLE[] = "PostgreSQLLogOutgoingTable";
+const char POSTGRESQL_LOG_EVENT_TABLE[] = "PostgreSQLLogEventTable";
+const char ODBC_LOG_USER[] = "OdbcLogUser";
+const char ODBC_LOG_PASSWORD[] = "OdbcLogPassword";
+const char ODBC_LOG_CONNECTION_STRING[] = "OdbcLogConnectionString";
+const char ODBC_LOG_INCOMING_TABLE[] = "OdbcLogIncomingTable";
+const char ODBC_LOG_OUTGOING_TABLE[] = "OdbcLogOutgoingTable";
+const char ODBC_LOG_EVENT_TABLE[] = "OdbcLogEventTable";
+const char RESET_ON_LOGON[] = "ResetOnLogon";
+const char RESET_ON_LOGOUT[] = "ResetOnLogout";
+const char RESET_ON_DISCONNECT[] = "ResetOnDisconnect";
+const char REFRESH_ON_LOGON[] = "RefreshOnLogon";
+const char MILLISECONDS_IN_TIMESTAMP[] = "MillisecondsInTimeStamp";
+const char HTTP_ACCEPT_PORT[] = "HttpAcceptPort";
+const char PERSIST_MESSAGES[] = "PersistMessages";
+
+/// Container for setting dictionaries mapped to sessions.
+class SessionSettings
+{
+public:
+  SessionSettings() {}
+  SessionSettings( std::istream& stream ) throw( ConfigError );
+  SessionSettings( const std::string& file ) throw( ConfigError );
+
+  /// Check if session setings are present
+  const bool has( const SessionID& ) const;
+
+  /// Get a dictionary for a session.
+  const Dictionary& get( const SessionID& ) const throw( ConfigError );
+  /// Set a dictionary for a session
+  void set( const SessionID&, Dictionary ) throw( ConfigError );
+
+  /// Get global default settings
+  const Dictionary& get() const { return m_defaults; }
+  /// Set global default settings
+  void set( const Dictionary& defaults ) throw( ConfigError );
+
+  /// Number of session settings
+  size_t size() const { return m_settings.size(); }
+
+  typedef std::map < SessionID, Dictionary > Dictionaries;
+  std::set < SessionID > getSessions() const;
+
+private:
+  void validate( const Dictionary& ) const throw( ConfigError );
+
+  Dictionaries m_settings;
+  Dictionary m_defaults;
+
+  friend std::ostream& operator<<( std::ostream&, const SessionSettings& );
+};
+/*! @} */
+
+std::istream& operator>>( std::istream&, SessionSettings& )
+throw( ConfigError );
+std::ostream& operator<<( std::ostream&, const SessionSettings& );
+}
+
+#endif //FIX_SESSIONSETTINGS_H