quickfix_ruby 1.14.3

data/ext/quickfix/SessionState.h

@@ -0,0 +1,231 @@
+/* -*- 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_SESSIONSTATE_H
+#define FIX_SESSIONSTATE_H
+
+#ifdef _MSC_VER
+#pragma warning( disable : 4503 4355 4786 4290 )
+#endif
+
+#include "FieldTypes.h"
+#include "MessageStore.h"
+#include "Log.h"
+#include "Mutex.h"
+
+namespace FIX
+{
+/// Maintains all of state for the Session class.
+class SessionState : public MessageStore, public Log
+{
+  typedef std::map < int, Message > Messages;
+
+public:
+  SessionState()
+: m_enabled( true ), m_receivedLogon( false ),
+  m_sentLogout( false ), m_sentLogon( false ),
+  m_sentReset( false ), m_receivedReset( false ),
+  m_initiate( false ), m_logonTimeout( 10 ), 
+  m_logoutTimeout( 2 ), m_testRequest( 0 ),
+  m_pStore( 0 ), m_pLog( 0 ) {}
+
+  bool enabled() const { return m_enabled; }
+  void enabled( bool value ) { m_enabled = value; }
+
+  bool receivedLogon() const { return m_receivedLogon; }
+  void receivedLogon( bool value ) { m_receivedLogon = value; }
+
+  bool sentLogout() const { return m_sentLogout; }
+  void sentLogout( bool value ) { m_sentLogout = value; }
+
+  bool sentLogon() const { return m_sentLogon; }
+  void sentLogon( bool value ) { m_sentLogon = value; }
+
+  bool receivedReset() const { return m_receivedReset; }
+  void receivedReset( bool value ) { m_receivedReset = value; }
+
+  bool sentReset() const { return m_sentReset; }
+  void sentReset( bool value ) { m_sentReset = value; }
+
+  bool initiate() const { return m_initiate; }
+  void initiate( bool value ) { m_initiate = value; }
+
+  int logonTimeout() const { return m_logonTimeout; }
+  void logonTimeout( int value ) { m_logonTimeout = value; }
+
+  int logoutTimeout() const { return m_logoutTimeout; }
+  void logoutTimeout( int value ) { m_logoutTimeout = value; }
+
+  int testRequest() const { return m_testRequest; }
+  void testRequest( int value ) { m_testRequest = value; }
+
+  bool resendRequested() const
+  { return !(m_resendRange.first == 0 && m_resendRange.second == 0); }
+
+  typedef std::pair<int, int> ResendRange;
+
+  ResendRange resendRange () const { return m_resendRange; }
+  void resendRange (int begin, int end)
+  { m_resendRange = std::make_pair( begin, end ); }
+
+  MessageStore* store() { return m_pStore; }
+  void store( MessageStore* pValue ) { m_pStore = pValue; }
+  Log* log() { return m_pLog ? m_pLog : &m_nullLog; }
+  void log( Log* pValue ) { m_pLog = pValue; }
+
+  void heartBtInt( const HeartBtInt& value )
+  { m_heartBtInt = value; }
+  HeartBtInt& heartBtInt()
+  { return m_heartBtInt; }
+  const HeartBtInt& heartBtInt() const
+  { return m_heartBtInt; }
+
+  void lastSentTime( const UtcTimeStamp& value )
+  { m_lastSentTime = value; }
+  UtcTimeStamp& lastSentTime()
+  { return m_lastSentTime; }
+  const UtcTimeStamp& lastSentTime() const
+  { return m_lastSentTime; }
+
+  void lastReceivedTime( const UtcTimeStamp& value )
+  { m_lastReceivedTime = value; }
+  UtcTimeStamp& lastReceivedTime()
+  { return m_lastReceivedTime; }
+  const UtcTimeStamp& lastReceivedTime() const
+  { return m_lastReceivedTime; }
+
+  bool shouldSendLogon() const { return initiate() && !sentLogon(); }
+  bool alreadySentLogon() const { return initiate() && sentLogon(); }
+  bool logonTimedOut() const
+  {
+    UtcTimeStamp now;
+    return now - lastReceivedTime() >= logonTimeout();
+  }
+  bool logoutTimedOut() const
+  {
+    UtcTimeStamp now;
+    return sentLogout() && ( ( now - lastSentTime() ) >= logoutTimeout() );
+  }
+  bool withinHeartBeat() const
+  {
+    UtcTimeStamp now;
+    return ( ( now - lastSentTime() ) < heartBtInt() ) &&
+           ( ( now - lastReceivedTime() ) < heartBtInt() );
+  }
+  bool timedOut() const
+  {
+    UtcTimeStamp now;
+    return ( now - lastReceivedTime() ) >= ( 2.4 * ( double ) heartBtInt() );
+  }
+  bool needHeartbeat() const
+  {
+    UtcTimeStamp now;
+    return ( ( now - lastSentTime() ) >= heartBtInt() ) && !testRequest();
+  }
+  bool needTestRequest() const
+  {
+    UtcTimeStamp now;
+    return ( now - lastReceivedTime() ) >=
+           ( ( 1.2 * ( ( double ) testRequest() + 1 ) ) * ( double ) heartBtInt() );
+  }
+
+  std::string logoutReason() const 
+  { Locker l( m_mutex ); return m_logoutReason; }
+  void logoutReason( const std::string& value ) 
+  { Locker l( m_mutex ); m_logoutReason = value; }
+
+  void queue( int msgSeqNum, const Message& message )
+  { Locker l( m_mutex ); m_queue[ msgSeqNum ] = message; }
+  bool retrieve( int msgSeqNum, Message& message )
+  {
+    Locker l( m_mutex );
+    Messages::iterator i = m_queue.find( msgSeqNum );
+    if ( i != m_queue.end() )
+    {
+      message = i->second;
+      m_queue.erase( i );
+      return true;
+    }
+    return false;
+  }
+  void clearQueue()
+  { Locker l( m_mutex ); m_queue.clear(); }
+
+  bool set( int s, const std::string& m ) throw ( IOException )
+  { Locker l( m_mutex ); return m_pStore->set( s, m ); }
+  void get( int b, int e, std::vector < std::string > &m ) const
+  throw ( IOException )
+  { Locker l( m_mutex ); m_pStore->get( b, e, m ); }
+  int getNextSenderMsgSeqNum() const throw ( IOException )
+  { Locker l( m_mutex ); return m_pStore->getNextSenderMsgSeqNum(); }
+  int getNextTargetMsgSeqNum() const throw ( IOException )
+  { Locker l( m_mutex ); return m_pStore->getNextTargetMsgSeqNum(); }
+  void setNextSenderMsgSeqNum( int n ) throw ( IOException )
+  { Locker l( m_mutex ); m_pStore->setNextSenderMsgSeqNum( n ); }
+  void setNextTargetMsgSeqNum( int n ) throw ( IOException )
+  { Locker l( m_mutex ); m_pStore->setNextTargetMsgSeqNum( n ); }
+  void incrNextSenderMsgSeqNum() throw ( IOException )
+  { Locker l( m_mutex ); m_pStore->incrNextSenderMsgSeqNum(); }
+  void incrNextTargetMsgSeqNum() throw ( IOException )
+  { Locker l( m_mutex ); m_pStore->incrNextTargetMsgSeqNum(); }
+  UtcTimeStamp getCreationTime() const throw ( IOException )
+  { Locker l( m_mutex ); return m_pStore->getCreationTime(); }
+  void reset() throw ( IOException )
+  { Locker l( m_mutex ); m_pStore->reset(); }
+  void refresh() throw ( IOException )
+  { Locker l( m_mutex ); m_pStore->refresh(); }
+
+  void clear()
+  { if ( !m_pLog ) return ; Locker l( m_mutex ); m_pLog->clear(); }
+  void backup()
+  { if ( !m_pLog ) return ; Locker l( m_mutex ); m_pLog->backup(); }
+  void onIncoming( const std::string& string )
+  { if ( !m_pLog ) return ; Locker l( m_mutex ); m_pLog->onIncoming( string ); }
+  void onOutgoing( const std::string& string )
+  { if ( !m_pLog ) return ; Locker l( m_mutex ); m_pLog->onOutgoing( string ); }
+  void onEvent( const std::string& string )
+  { if ( !m_pLog ) return ; Locker l( m_mutex ); m_pLog->onEvent( string ); }
+
+private:
+  bool m_enabled;
+  bool m_receivedLogon;
+  bool m_sentLogout;
+  bool m_sentLogon;
+  bool m_sentReset;
+  bool m_receivedReset;
+  bool m_initiate;
+  int m_logonTimeout;
+  int m_logoutTimeout;
+  int m_testRequest;
+  ResendRange m_resendRange;
+  HeartBtInt m_heartBtInt;
+  UtcTimeStamp m_lastSentTime;
+  UtcTimeStamp m_lastReceivedTime;
+  std::string m_logoutReason;
+  Messages m_queue;
+  MessageStore* m_pStore;
+  Log* m_pLog;
+  NullLog m_nullLog;
+  mutable Mutex m_mutex;
+};
+}
+
+#endif //FIX_SESSIONSTATE_H

data/ext/quickfix/Settings.cpp

@@ -0,0 +1,100 @@
+/****************************************************************************
+** 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 "Settings.h"
+
+namespace FIX
+{
+bool isComment( const std::string& line )
+{
+  if( line.size() == 0 )
+    return false;
+
+  return line[0] == '#';
+}
+
+bool isSection( const std::string& line )
+{
+  if( line.size() == 0 )
+    return false;
+
+  return line[0] == '[' && line[line.size()-1] == ']';
+}
+
+std::string splitSection( const std::string& line )
+{
+  return string_strip(std::string( line, 1, line.size() - 2 ));
+}
+
+bool isKeyValue( const std::string& line )
+{
+  return line.find( '=' ) != std::string::npos;
+}
+
+std::pair<std::string, std::string> splitKeyValue( const std::string& line )
+{
+  size_t equals = line.find( '=' );
+  std::string key = std::string( line, 0, equals );
+  std::string value = std::string( line, equals + 1, std::string::npos );
+  return std::pair<std::string, std::string>( key, value );
+}
+
+std::istream& operator>>( std::istream& stream, Settings& s )
+{
+  char buffer[1024];
+  std::string line;
+  Settings::Sections::iterator section = s.m_sections.end();;
+
+  while( stream.getline(buffer, 1024) )
+  {
+    line = string_strip( buffer );
+    if( isComment(line) )
+    {
+      continue;
+    }
+    else if( isSection(line) )
+    {
+      section = s.m_sections.insert( s.m_sections.end(), Dictionary(splitSection(line)) );
+    }
+    else if( isKeyValue(line) )
+    {
+      std::pair<std::string, std::string> keyValue = splitKeyValue( line );
+      if( section == s.m_sections.end() )
+        continue;
+      (*section).setString( keyValue.first, keyValue.second );
+    }
+  }
+  return stream;
+}
+
+Settings::Sections Settings::get( const std::string& name ) const
+{
+  Sections sections;
+  for ( Sections::size_type i = 0; i < m_sections.size(); ++i )
+    if ( m_sections[ i ].getName() == name )
+      sections.push_back( m_sections[ i ] );
+  return sections;
+}
+}

data/ext/quickfix/Settings.h

@@ -0,0 +1,53 @@
+/* -*- 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_SETTINGS_H
+#define FIX_SETTINGS_H
+
+#ifdef _MSC_VER
+#pragma warning( disable : 4503 4355 4786 4290 )
+#endif
+
+#include "Dictionary.h"
+#include <string>
+#include <vector>
+#include <map>
+#include <iostream>
+
+namespace FIX
+{
+/// Internal representation of QuickFIX configuration settings.
+class Settings
+{
+public:
+  typedef std::vector < Dictionary > Sections;
+
+  Sections get( const std::string& name ) const;
+
+  friend std::istream& operator>>( std::istream&, Settings& );
+private:
+  Sections m_sections;
+};
+
+std::istream& operator>>( std::istream&, Settings& );
+}
+
+#endif //FIX_SETTINGS_H

data/ext/quickfix/SharedArray.h

@@ -0,0 +1,150 @@
+/* -*- 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 SHARED_ARRAY
+#define SHARED_ARRAY
+
+#include "AtomicCount.h"
+
+namespace FIX
+{
+  /// Shared array with atomic reference count
+  template<typename T>
+  class shared_array
+  {
+  public:
+    shared_array()
+    : m_size(0)
+    , m_buffer(0)
+    {}
+
+    shared_array(const shared_array& rhs)
+    : m_size(rhs.m_size)
+    , m_buffer(rhs.m_buffer)
+    {
+      rhs.attach();
+    }
+
+    ~shared_array()
+    { release(); }
+
+    shared_array& operator=(const shared_array& rhs)
+    {
+      if( &rhs == this )
+        return *this;
+
+      rhs.attach();
+      release();
+
+      m_size = rhs.m_size;
+      m_buffer = rhs.m_buffer;
+
+      return *this;
+    }
+
+    std::size_t size() const
+    { return m_size; }
+
+    bool empty() const
+    { return m_buffer == 0; }
+
+    operator T* () const
+    { return m_buffer; }
+
+    //optimized function to allocate storage for buffer and counter object at once
+    static shared_array create(const std::size_t nSize)
+    {
+      if(nSize <= 0)
+        return shared_array();
+
+      //verify the needed buffer size to allocate counter object and nSize elements
+      const std::size_t sizeToAllocate = nSize + ( sizeof(atomic_count) / sizeof(T) + 1 );
+
+      //allocate and zero-fill the buffer
+      T* storage = new T[ sizeToAllocate ];
+      memset(storage, 0, sizeToAllocate * sizeof(T));
+
+      // create the counter object at the end of the storage
+      // with initial reference count set to 1
+      new (&storage[nSize]) atomic_count( 1 );
+
+      return shared_array(storage, nSize);
+    }
+
+  private:
+
+    shared_array( T * buff, std::size_t nSize )
+    : m_size(nSize)
+    , m_buffer(buff)
+    {
+
+    }
+
+    atomic_count* get_counter() const
+    {
+      return reinterpret_cast<atomic_count*>( &m_buffer[ size() ] );
+    }
+
+    void increment_reference_count() const
+    {
+      atomic_count* counter = get_counter();
+      ++(*counter);
+    }
+
+    long decrement_reference_count() 
+    {
+      atomic_count* counter = get_counter();
+      return --(*counter);
+    }
+
+    void attach() const
+    {
+      if( !empty() )
+        increment_reference_count();
+    }
+
+    void release()
+    {
+      if( empty() )
+        return;
+
+      //free object if reference count has decreased to zero
+      if( decrement_reference_count() == 0)
+      {
+        T * tmpBuff = m_buffer;
+        atomic_count* tmpCounter = get_counter();
+
+        m_buffer = 0;
+        m_size = 0;
+
+        //explicitly call destructor for the counter object
+        tmpCounter->~atomic_count();
+
+        delete [] tmpBuff;
+      }
+    }
+
+    std::size_t m_size;
+    T * m_buffer;
+  };
+}
+
+#endif