quickfix_ruby 1.14.3

data/ext/quickfix/MessageSorters.h

@@ -0,0 +1,156 @@
+/* -*- 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_MESSAGESORTERS_H
+#define FIX_MESSAGESORTERS_H
+
+#ifdef _MSC_VER
+#pragma warning( disable : 4503 4355 4786 4290 )
+#endif
+
+#include "FieldNumbers.h"
+#include "SharedArray.h"
+#include <stdarg.h>
+#include <functional>
+#include <map>
+
+namespace FIX
+{
+/// Sorts fields in correct header order.
+struct header_order
+{
+  static bool compare( const int x, const int y )
+  {
+    int orderedX = getOrderedPosition( x );
+    int orderedY = getOrderedPosition( y );
+
+    if ( orderedX && orderedY )
+      return orderedX < orderedY;
+    else
+      if ( orderedX )
+        return true;
+      else
+        if ( orderedY )
+          return false;
+        else
+          return x < y;
+  }
+
+  static int getOrderedPosition( const int field )
+  {
+    switch ( field )
+    {
+      case FIELD::BeginString: return 1;
+      case FIELD::BodyLength: return 2;
+      case FIELD::MsgType: return 3;
+      default: return 0;
+    };
+  }
+};
+
+/// Sorts fields in correct trailer order.
+struct trailer_order
+{
+  static bool compare( const int x, const int y )
+  {
+    if ( x == FIELD::CheckSum ) return false;
+    else
+      if ( y == FIELD::CheckSum ) return true;
+      else return x < y;
+  }
+};
+
+/// Sorts fields in correct group order
+struct group_order
+{
+  static bool compare( const int x, const int y, int* order, int largest )
+  {
+    if ( x <= largest && y <= largest )
+    {
+      int iX = order[ x ];
+      int iY = order[ y ];
+      if ( iX == 0 && iY == 0 )
+        return x < y;
+      else if ( iX == 0 )
+        return false;
+      else if ( iY == 0 )
+        return true;
+      else
+        return iX < iY;
+    }
+    else if ( x <= largest ) return true;
+    else if ( y <= largest ) return false;
+    else return x < y;
+  }
+};
+
+typedef std::less < int > normal_order;
+
+/**
+ * Sorts fields in header, normal, or trailer order.
+ *
+ * Used as a dynamic sorter to create Header, Trailer, and Message
+ * FieldMaps while maintaining the same base type.
+ */
+struct message_order
+{
+public:
+  enum cmp_mode { header, trailer, normal, group };
+
+  message_order( cmp_mode mode = normal ) 
+    : m_mode( mode ), m_delim( 0 ), m_largest( 0 ) {}
+  message_order( int first, ... );
+  message_order( const int order[] );
+  message_order( const message_order& copy ) 
+  { *this = copy; }
+
+  bool operator() ( const int x, const int y ) const
+  {
+    switch ( m_mode )
+    {
+      case header:
+      return header_order::compare( x, y );
+      case trailer:
+      return trailer_order::compare( x, y );
+      case group:
+      return group_order::compare( x, y, m_groupOrder, m_largest );
+      case normal: default:
+      return x < y;
+    }
+  }
+
+  message_order& operator=( const message_order& rhs );
+
+  operator bool() const
+  { return !m_groupOrder.empty(); }
+
+private:
+  void setOrder( int size, const int order[] );
+
+  cmp_mode m_mode;
+  int m_delim;
+  shared_array<int> m_groupOrder;
+  int m_largest;
+};
+}
+
+#endif //FIX_MESSAGESORTERS_H
+

data/ext/quickfix/MessageStore.cpp

@@ -0,0 +1,146 @@
+/****************************************************************************
+** 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 "MessageStore.h"
+
+namespace FIX
+{
+MessageStore* MemoryStoreFactory::create( const SessionID& )
+{
+  return new MemoryStore();
+}
+
+void MemoryStoreFactory::destroy( MessageStore* pStore )
+{
+  delete pStore;
+}
+
+bool MemoryStore::set( int msgSeqNum, const std::string& msg )
+throw( IOException )
+{
+  m_messages[ msgSeqNum ] = msg;
+  return true;
+}
+
+void MemoryStore::get( int begin, int end,
+                       std::vector < std::string > & messages ) const
+throw( IOException )
+{
+  messages.clear();
+  Messages::const_iterator find = m_messages.find( begin );
+  for ( ; find != m_messages.end() && find->first <= end; ++find )
+    messages.push_back( find->second );
+}
+
+MessageStore* MessageStoreFactoryExceptionWrapper::create( const SessionID& sessionID, bool& threw, ConfigError& ex )
+{
+  threw = false;
+  try { return m_pFactory->create( sessionID ); }
+  catch ( ConfigError & e ) { threw = true; ex = e; return 0; }
+}
+
+void MessageStoreFactoryExceptionWrapper::destroy( MessageStore* pStore )
+{
+  m_pFactory->destroy( pStore );
+}
+
+bool MessageStoreExceptionWrapper::set( int num, const std::string& msg, bool& threw, IOException& ex )
+{
+  threw = false;
+  try { return m_pStore->set( num, msg ); }
+  catch ( IOException & e ) { threw = true; ex = e; return false; }
+}
+
+void MessageStoreExceptionWrapper::get( int begin, int end, std::vector < std::string > & msgs, bool& threw, IOException& ex ) const
+{
+  threw = false;
+  try { m_pStore->get( begin, end, msgs ); }
+  catch ( IOException & e ) { threw = true; ex = e; }
+}
+
+int MessageStoreExceptionWrapper::getNextSenderMsgSeqNum( bool& threw, IOException& ex ) const
+{
+  threw = false;
+  try { return m_pStore->getNextSenderMsgSeqNum(); }
+  catch ( IOException & e ) { threw = true; ex = e; return 0; }
+}
+
+int MessageStoreExceptionWrapper::getNextTargetMsgSeqNum( bool& threw, IOException& ex ) const
+{
+  threw = false;
+  try { return m_pStore->getNextTargetMsgSeqNum(); }
+  catch ( IOException & e ) { threw = true; ex = e; return 0; }
+}
+
+void MessageStoreExceptionWrapper::setNextSenderMsgSeqNum( int num, bool& threw, IOException& ex )
+{
+  threw = false;
+  try { m_pStore->setNextSenderMsgSeqNum( num ); }
+  catch ( IOException & e ) { threw = true; ex = e; }
+}
+
+void MessageStoreExceptionWrapper::setNextTargetMsgSeqNum( int num, bool& threw, IOException& ex )
+{
+  threw = false;
+  try { m_pStore->setNextTargetMsgSeqNum( num ); }
+  catch ( IOException & e ) { threw = true; ex = e; }
+}
+
+void MessageStoreExceptionWrapper::incrNextSenderMsgSeqNum( bool& threw, IOException& ex )
+{
+  threw = false;
+  try { m_pStore->incrNextSenderMsgSeqNum(); }
+  catch ( IOException & e ) { threw = true; ex = e; }
+}
+
+void MessageStoreExceptionWrapper::incrNextTargetMsgSeqNum( bool& threw, IOException& ex )
+{
+  threw = false;
+  try { m_pStore->incrNextTargetMsgSeqNum(); }
+  catch ( IOException & e ) { threw = true; ex = e; }
+}
+
+UtcTimeStamp MessageStoreExceptionWrapper::getCreationTime( bool& threw, IOException& ex )
+{
+  threw = false;
+  try { return m_pStore->getCreationTime(); }
+  catch ( IOException & e ) { threw = true; ex = e; return UtcTimeStamp(); }
+}
+
+void MessageStoreExceptionWrapper::reset( bool& threw, IOException& ex )
+{
+  threw = false;
+  try { m_pStore->reset(); }
+  catch ( IOException & e ) { threw = true; ex = e; }
+}
+
+void MessageStoreExceptionWrapper::refresh( bool& threw, IOException& ex )
+{
+  threw = false;
+  try { m_pStore->refresh(); }
+  catch ( IOException & e ) { threw = true; ex = e; }
+}
+
+} //namespace FIX

data/ext/quickfix/MessageStore.h

@@ -0,0 +1,174 @@
+/* -*- 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_MESSAGESTORE_H
+#define FIX_MESSAGESTORE_H
+
+#ifdef _MSC_VER
+#pragma warning( disable : 4503 4355 4786 4290 )
+#endif
+
+#include "Message.h"
+#include <map>
+#include <vector>
+#include <string>
+
+namespace FIX
+{
+class MessageStore;
+
+/**
+ * This interface must be implemented to create a MessageStore.
+ */
+class MessageStoreFactory
+{
+public:
+  virtual ~MessageStoreFactory() {}
+  virtual MessageStore* create( const SessionID& ) = 0;
+  virtual void destroy( MessageStore* ) = 0;
+};
+
+/**
+ * Creates a memory based implementation of MessageStore.
+ *
+ * This will lose all data on process termination. This class should only
+ * be used for test applications, never in production.
+ */
+class MemoryStoreFactory : public MessageStoreFactory
+{
+public:
+  MessageStore* create( const SessionID& );
+  void destroy( MessageStore* );
+};
+
+/**
+ * This interface must be implemented to store and retrieve messages and
+ * sequence numbers.
+ */
+class MessageStore
+{
+public:
+  virtual ~MessageStore() {}
+
+  virtual bool set( int, const std::string& )
+  throw ( IOException ) = 0;
+  virtual void get( int, int, std::vector < std::string > & ) const
+  throw ( IOException ) = 0;
+
+  virtual int getNextSenderMsgSeqNum() const throw ( IOException ) = 0;
+  virtual int getNextTargetMsgSeqNum() const throw ( IOException ) = 0;
+  virtual void setNextSenderMsgSeqNum( int ) throw ( IOException ) = 0;
+  virtual void setNextTargetMsgSeqNum( int ) throw ( IOException ) = 0;
+  virtual void incrNextSenderMsgSeqNum() throw ( IOException ) = 0;
+  virtual void incrNextTargetMsgSeqNum() throw ( IOException ) = 0;
+
+  virtual UtcTimeStamp getCreationTime() const throw ( IOException ) = 0;
+
+  virtual void reset() throw ( IOException ) = 0;
+  virtual void refresh() throw ( IOException ) = 0;
+};
+/*! @} */
+
+/**
+ * Memory based implementation of MessageStore.
+ *
+ * This will lose all data on process terminition. This class should only
+ * be used for test applications, never in production.
+ */
+class MemoryStore : public MessageStore
+{
+public:
+  MemoryStore() : m_nextSenderMsgSeqNum( 1 ), m_nextTargetMsgSeqNum( 1 ) {}
+
+  bool set( int, const std::string& ) throw ( IOException );
+  void get( int, int, std::vector < std::string > & ) const throw ( IOException );
+
+  int getNextSenderMsgSeqNum() const throw ( IOException )
+  { return m_nextSenderMsgSeqNum; }
+  int getNextTargetMsgSeqNum() const throw ( IOException )
+  { return m_nextTargetMsgSeqNum; }
+  void setNextSenderMsgSeqNum( int value ) throw ( IOException )
+  { m_nextSenderMsgSeqNum = value; }
+  void setNextTargetMsgSeqNum( int value ) throw ( IOException )
+  { m_nextTargetMsgSeqNum = value; }
+  void incrNextSenderMsgSeqNum() throw ( IOException )
+  { ++m_nextSenderMsgSeqNum; }
+  void incrNextTargetMsgSeqNum() throw ( IOException )
+  { ++m_nextTargetMsgSeqNum; }
+
+  void setCreationTime( const UtcTimeStamp& creationTime ) throw ( IOException )
+  { m_creationTime = creationTime; }
+  UtcTimeStamp getCreationTime() const throw ( IOException )
+  { return m_creationTime; }
+
+  void reset() throw ( IOException )
+  {
+    m_nextSenderMsgSeqNum = 1; m_nextTargetMsgSeqNum = 1;
+    m_messages.clear(); m_creationTime.setCurrent();
+  }
+  void refresh() throw ( IOException ) {}
+
+private:
+  typedef std::map < int, std::string > Messages;
+
+  Messages m_messages;
+  int m_nextSenderMsgSeqNum;
+  int m_nextTargetMsgSeqNum;
+  UtcTimeStamp m_creationTime;
+};
+
+class MessageStoreFactoryExceptionWrapper
+{
+private:
+  MessageStoreFactory* m_pFactory;
+public:
+  MessageStoreFactoryExceptionWrapper( MessageStoreFactory* pFactory )
+  : m_pFactory( pFactory ) {}
+
+  MessageStore* create( const SessionID&, bool&, ConfigError& );
+  void destroy( MessageStore* );
+};
+
+class MessageStoreExceptionWrapper
+{
+private:
+  MessageStore* m_pStore;
+public:
+  MessageStoreExceptionWrapper( MessageStore* pStore ) : m_pStore( pStore ) {}
+  ~MessageStoreExceptionWrapper() { delete m_pStore; }
+
+  bool set( int, const std::string&, bool&, IOException& );
+  void get( int, int, std::vector < std::string > &, bool&, IOException& ) const;
+  int getNextSenderMsgSeqNum( bool&, IOException& ) const;
+  int getNextTargetMsgSeqNum( bool&, IOException& ) const;
+  void setNextSenderMsgSeqNum( int, bool&, IOException& );
+  void setNextTargetMsgSeqNum( int, bool&, IOException& );
+  void incrNextSenderMsgSeqNum( bool&, IOException& );
+  void incrNextTargetMsgSeqNum( bool&, IOException& );
+
+  UtcTimeStamp getCreationTime( bool&, IOException& );
+
+  void reset( bool&, IOException& );
+  void refresh( bool&, IOException& );
+};
+}
+
+#endif //FIX_MESSAGESTORE_H

data/ext/quickfix/Mutex.h

@@ -0,0 +1,131 @@
+/* -*- 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_MUTEX_H
+#define FIX_MUTEX_H
+
+#include "Utility.h"
+
+namespace FIX
+{
+/// Portable implementation of a mutex.
+class Mutex
+{
+public:
+  Mutex()
+  {
+#ifdef _MSC_VER
+    InitializeCriticalSection( &m_mutex );
+#else
+    m_count = 0;
+    m_threadID = 0;
+    //pthread_mutexattr_t attr;
+    //pthread_mutexattr_init(&attr);
+    //pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+    //pthread_mutex_init(&m_mutex, &attr);
+    pthread_mutex_init( &m_mutex, 0 );
+#endif
+  }
+
+  ~Mutex()
+  {
+#ifdef _MSC_VER
+    DeleteCriticalSection( &m_mutex );
+#else
+    pthread_mutex_destroy( &m_mutex );
+#endif
+  }
+
+  void lock()
+  {
+#ifdef _MSC_VER
+    EnterCriticalSection( &m_mutex );
+#else
+    if ( m_count && m_threadID == pthread_self() )
+    { ++m_count; return ; }
+    pthread_mutex_lock( &m_mutex );
+    ++m_count;
+    m_threadID = pthread_self();
+#endif
+  }
+
+  void unlock()
+  {
+#ifdef _MSC_VER
+    LeaveCriticalSection( &m_mutex );
+#else
+    if ( m_count > 1 )
+    { m_count--; return ; }
+    --m_count;
+    m_threadID = 0;
+    pthread_mutex_unlock( &m_mutex );
+#endif
+  }
+
+private:
+
+#ifdef _MSC_VER
+  CRITICAL_SECTION m_mutex;
+#else
+  pthread_mutex_t m_mutex;
+  pthread_t m_threadID;
+  int m_count;
+#endif
+};
+
+/// Locks/Unlocks a mutex using RAII.
+class Locker
+{
+public:
+  Locker( Mutex& mutex )
+  : m_mutex( mutex )
+  {
+    m_mutex.lock();
+  }
+
+  ~Locker()
+  {
+    m_mutex.unlock();
+  }
+private:
+  Mutex& m_mutex;
+};
+
+/// Does the opposite of the Locker to ensure mutex ends up in a locked state.
+class ReverseLocker
+{
+public:
+  ReverseLocker( Mutex& mutex )
+  : m_mutex( mutex )
+  {
+    m_mutex.unlock();
+  }
+
+  ~ReverseLocker()
+  {
+    m_mutex.lock();
+  }
+private:
+  Mutex& m_mutex;
+};
+}
+
+#endif