quickfix_ruby_ud 2.0.7-x86_64-linux

data/ext/quickfix/MessageSorters.h

@@ -0,0 +1,185 @@
+/* -*- 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 <functional>
+#include <map>
+#include <stdarg.h>
+#include <vector>
+
+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;
+    }
+
+    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::SignatureLength:
+      return 1;
+    case FIELD::Signature:
+      return 2;
+    default:
+      return 0;
+    };
+  }
+};
+
+/// 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 int order[], int size);
+  message_order(const message_order &) = default;
+  message_order(message_order &&) = default;
+
+  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 &) = default;
+  message_order &operator=(message_order &&) = default;
+
+  operator bool() const { return !m_groupOrder.empty(); }
+
+private:
+  void setOrder(const int order[], int size);
+
+  cmp_mode m_mode;
+  int m_delim;
+  shared_array<int> m_groupOrder;
+  int m_largest;
+};
+} // namespace FIX
+
+#endif // FIX_MESSAGESORTERS_H

data/ext/quickfix/MessageStore.cpp

@@ -0,0 +1,182 @@
+/****************************************************************************
+** 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 UtcTimeStamp &now, const SessionID &) { return new MemoryStore(now); }
+
+void MemoryStoreFactory::destroy(MessageStore *pStore) { delete pStore; }
+
+bool MemoryStore::set(SEQNUM msgSeqNum, const std::string &msg) EXCEPT(IOException) {
+  m_messages[msgSeqNum] = msg;
+  return true;
+}
+
+void MemoryStore::get(SEQNUM begin, SEQNUM end, std::vector<std::string> &messages) const EXCEPT(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 UtcTimeStamp &now,
+    const SessionID &sessionID,
+    bool &threw,
+    ConfigError &ex) {
+  threw = false;
+  try {
+    return m_pFactory->create(now, sessionID);
+  } catch (ConfigError &e) {
+    threw = true;
+    ex = e;
+    return 0;
+  }
+}
+
+void MessageStoreFactoryExceptionWrapper::destroy(MessageStore *pStore) { m_pFactory->destroy(pStore); }
+
+bool MessageStoreExceptionWrapper::set(SEQNUM 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(
+    SEQNUM begin,
+    SEQNUM 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;
+  }
+}
+
+SEQNUM MessageStoreExceptionWrapper::getNextSenderMsgSeqNum(bool &threw, IOException &ex) const {
+  threw = false;
+  try {
+    return m_pStore->getNextSenderMsgSeqNum();
+  } catch (IOException &e) {
+    threw = true;
+    ex = e;
+    return 0;
+  }
+}
+
+SEQNUM 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(SEQNUM num, bool &threw, IOException &ex) {
+  threw = false;
+  try {
+    m_pStore->setNextSenderMsgSeqNum(num);
+  } catch (IOException &e) {
+    threw = true;
+    ex = e;
+  }
+}
+
+void MessageStoreExceptionWrapper::setNextTargetMsgSeqNum(SEQNUM 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::now();
+  }
+}
+
+void MessageStoreExceptionWrapper::reset(const UtcTimeStamp &now, bool &threw, IOException &ex) {
+  threw = false;
+  try {
+    m_pStore->reset(now);
+  } 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,164 @@
+/* -*- 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 <string>
+#include <vector>
+
+namespace FIX {
+class MessageStore;
+
+/**
+ * This interface must be implemented to create a MessageStore.
+ */
+class MessageStoreFactory {
+public:
+  virtual ~MessageStoreFactory() {}
+  virtual MessageStore *create(const UtcTimeStamp &now, 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 UtcTimeStamp &now, 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(SEQNUM, const std::string &) EXCEPT(IOException) = 0;
+  virtual void get(SEQNUM, SEQNUM, std::vector<std::string> &) const EXCEPT(IOException) = 0;
+
+  virtual SEQNUM getNextSenderMsgSeqNum() const EXCEPT(IOException) = 0;
+  virtual SEQNUM getNextTargetMsgSeqNum() const EXCEPT(IOException) = 0;
+  virtual void setNextSenderMsgSeqNum(SEQNUM) EXCEPT(IOException) = 0;
+  virtual void setNextTargetMsgSeqNum(SEQNUM) EXCEPT(IOException) = 0;
+  virtual void incrNextSenderMsgSeqNum() EXCEPT(IOException) = 0;
+  virtual void incrNextTargetMsgSeqNum() EXCEPT(IOException) = 0;
+
+  virtual UtcTimeStamp getCreationTime() const EXCEPT(IOException) = 0;
+
+  virtual void reset(const UtcTimeStamp &now) EXCEPT(IOException) = 0;
+  virtual void refresh() EXCEPT(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(const UtcTimeStamp &now)
+      : m_nextSenderMsgSeqNum(1),
+        m_nextTargetMsgSeqNum(1),
+        m_creationTime(now) {}
+
+  bool set(SEQNUM, const std::string &) EXCEPT(IOException);
+  void get(SEQNUM, SEQNUM, std::vector<std::string> &) const EXCEPT(IOException);
+
+  SEQNUM getNextSenderMsgSeqNum() const EXCEPT(IOException) { return m_nextSenderMsgSeqNum; }
+  SEQNUM getNextTargetMsgSeqNum() const EXCEPT(IOException) { return m_nextTargetMsgSeqNum; }
+  void setNextSenderMsgSeqNum(SEQNUM value) EXCEPT(IOException) { m_nextSenderMsgSeqNum = value; }
+  void setNextTargetMsgSeqNum(SEQNUM value) EXCEPT(IOException) { m_nextTargetMsgSeqNum = value; }
+  void incrNextSenderMsgSeqNum() EXCEPT(IOException) { ++m_nextSenderMsgSeqNum; }
+  void incrNextTargetMsgSeqNum() EXCEPT(IOException) { ++m_nextTargetMsgSeqNum; }
+
+  void setCreationTime(const UtcTimeStamp &creationTime) EXCEPT(IOException) { m_creationTime = creationTime; }
+  UtcTimeStamp getCreationTime() const EXCEPT(IOException) { return m_creationTime; }
+
+  void reset(const UtcTimeStamp &now) EXCEPT(IOException) {
+    m_nextSenderMsgSeqNum = 1;
+    m_nextTargetMsgSeqNum = 1;
+    m_messages.clear();
+    m_creationTime = now;
+  }
+  void refresh() EXCEPT(IOException) {}
+
+private:
+  typedef std::map<SEQNUM, std::string> Messages;
+
+  Messages m_messages;
+  SEQNUM m_nextSenderMsgSeqNum;
+  SEQNUM m_nextTargetMsgSeqNum;
+  UtcTimeStamp m_creationTime;
+};
+
+class MessageStoreFactoryExceptionWrapper {
+private:
+  MessageStoreFactory *m_pFactory;
+
+public:
+  MessageStoreFactoryExceptionWrapper(MessageStoreFactory *pFactory)
+      : m_pFactory(pFactory) {}
+
+  MessageStore *create(const UtcTimeStamp &now, 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(SEQNUM, const std::string &, bool &, IOException &);
+  void get(SEQNUM, SEQNUM, std::vector<std::string> &, bool &, IOException &) const;
+  SEQNUM getNextSenderMsgSeqNum(bool &, IOException &) const;
+  SEQNUM getNextTargetMsgSeqNum(bool &, IOException &) const;
+  void setNextSenderMsgSeqNum(SEQNUM, bool &, IOException &);
+  void setNextTargetMsgSeqNum(SEQNUM, bool &, IOException &);
+  void incrNextSenderMsgSeqNum(bool &, IOException &);
+  void incrNextTargetMsgSeqNum(bool &, IOException &);
+
+  UtcTimeStamp getCreationTime(bool &, IOException &);
+
+  void reset(const UtcTimeStamp &, bool &, IOException &);
+  void refresh(bool &, IOException &);
+};
+} // namespace FIX
+
+#endif // FIX_MESSAGESTORE_H

data/ext/quickfix/Mutex.h

@@ -0,0 +1,120 @@
+/* -*- 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;
+};
+} // namespace FIX
+
+#endif