quickfix_ruby_ud 2.0.7-x86_64-linux

data/ext/quickfix/SessionState.h

@@ -0,0 +1,260 @@
+/* -*- 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 "Log.h"
+#include "MessageStore.h"
+#include "Mutex.h"
+
+namespace FIX {
+/// Maintains all of state for the Session class.
+class SessionState : public MessageStore, public Log {
+  typedef std::map<SEQNUM, Message> Messages;
+
+public:
+  SessionState(const UtcTimeStamp &now)
+      : 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_lastSentTime(now),
+        m_lastReceivedTime(now),
+        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<SEQNUM, SEQNUM> ResendRange;
+
+  ResendRange resendRange() const { return m_resendRange; }
+  void resendRange(SEQNUM begin, SEQNUM 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) const { return now - lastReceivedTime() >= logonTimeout(); }
+  bool logoutTimedOut(const UtcTimeStamp &now) const {
+    return sentLogout() && ((now - lastSentTime()) >= logoutTimeout());
+  }
+  bool withinHeartBeat(const UtcTimeStamp &now) const {
+    return ((now - lastSentTime()) < heartBtInt()) && ((now - lastReceivedTime()) < heartBtInt());
+  }
+  bool timedOut(const UtcTimeStamp &now) const { return (now - lastReceivedTime()) >= (2.4 * (double)heartBtInt()); }
+  bool needHeartbeat(const UtcTimeStamp &now) const {
+    return ((now - lastSentTime()) >= heartBtInt()) && !testRequest();
+  }
+  bool needTestRequest(const UtcTimeStamp &now) const {
+    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(SEQNUM msgSeqNum, const Message &message) {
+    Locker l(m_mutex);
+    m_queue[msgSeqNum] = message;
+  }
+  bool retrieve(SEQNUM 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(SEQNUM s, const std::string &m) EXCEPT(IOException) {
+    Locker l(m_mutex);
+    return m_pStore->set(s, m);
+  }
+  void get(SEQNUM b, SEQNUM e, std::vector<std::string> &m) const EXCEPT(IOException) {
+    Locker l(m_mutex);
+    m_pStore->get(b, e, m);
+  }
+  SEQNUM getNextSenderMsgSeqNum() const EXCEPT(IOException) {
+    Locker l(m_mutex);
+    return m_pStore->getNextSenderMsgSeqNum();
+  }
+  SEQNUM getNextTargetMsgSeqNum() const EXCEPT(IOException) {
+    Locker l(m_mutex);
+    return m_pStore->getNextTargetMsgSeqNum();
+  }
+  void setNextSenderMsgSeqNum(SEQNUM n) EXCEPT(IOException) {
+    Locker l(m_mutex);
+    m_pStore->setNextSenderMsgSeqNum(n);
+  }
+  void setNextTargetMsgSeqNum(SEQNUM n) EXCEPT(IOException) {
+    Locker l(m_mutex);
+    m_pStore->setNextTargetMsgSeqNum(n);
+  }
+  void incrNextSenderMsgSeqNum() EXCEPT(IOException) {
+    Locker l(m_mutex);
+    m_pStore->incrNextSenderMsgSeqNum();
+  }
+  void incrNextTargetMsgSeqNum() EXCEPT(IOException) {
+    Locker l(m_mutex);
+    m_pStore->incrNextTargetMsgSeqNum();
+  }
+  UtcTimeStamp getCreationTime() const EXCEPT(IOException) {
+    Locker l(m_mutex);
+    return m_pStore->getCreationTime();
+  }
+  void reset(const UtcTimeStamp &now) EXCEPT(IOException) {
+    Locker l(m_mutex);
+    m_pStore->reset(now);
+  }
+  void refresh() EXCEPT(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;
+};
+} // namespace FIX
+
+#endif // FIX_SESSIONSTATE_H

data/ext/quickfix/Settings.cpp

@@ -0,0 +1,160 @@
+/****************************************************************************
+** 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"
+#include <cstring>
+
+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::string resolveEnvVars(const std::string &str) {
+  std::string resultStr;
+  size_t actPos = 0;
+  size_t sourceLen = str.length();
+
+  while (actPos < sourceLen) {
+    char c = str[actPos++];
+    if (actPos < sourceLen) {
+      // escape character
+      if (c == '\\') {
+        c = str[actPos++];
+        switch (c) {
+        case 't':
+          resultStr.append(1, '\t');
+          break;
+        case 'r':
+          resultStr.append(1, '\r');
+          break;
+        case 'n':
+          resultStr.append(1, '\n');
+          break;
+        default:
+          resultStr.append(1, c);
+          break;
+        }
+        continue;
+      }
+
+      // variable substitution
+      if (c == '$') {
+        bool inBraces = false;
+        c = str[actPos++];
+        if ((c == '(') || (c == '{')) {
+          c = str[actPos++];
+          inBraces = true;
+        }
+
+        // actPos now points at start of var name
+        if (actPos >= sourceLen) {
+          break;
+        }
+        std::string varName;
+        while ((actPos <= sourceLen)) {
+          varName.append(1, c); // this must be done before overwriting c
+          c = str[actPos++];
+          if (std::strchr(" /:;,.=\"'?#+*()[]{}$&%\t\n", c)) {
+            break;
+          }
+        }
+        if (inBraces && (actPos <= sourceLen) && ((c == ')') || (c == '}')))
+          ;
+        else {
+          --actPos;
+        }
+        // varName contains the name of the variable,
+        // actPos points to first char _after_ variable
+        const char *varValue = 0;
+        if (!varName.empty() && (0 != (varValue = getenv(varName.c_str())))) {
+          resultStr.append(varValue);
+        }
+        continue;
+      }
+    }
+
+    // nothing special, just copy
+    resultStr.append(1, c);
+  }
+
+  return resultStr;
+}
+
+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, sizeof(buffer))) {
+    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, s.m_resolveEnvVars ? resolveEnvVars(keyValue.second) : 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;
+}
+} // namespace FIX

data/ext/quickfix/Settings.h

@@ -0,0 +1,56 @@
+/* -*- 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 <iostream>
+#include <map>
+#include <string>
+#include <vector>
+
+namespace FIX {
+/// Internal representation of QuickFIX configuration settings.
+class Settings {
+public:
+  Settings(bool resolveEnvVars = false)
+      : m_resolveEnvVars(resolveEnvVars) {}
+
+  typedef std::vector<Dictionary> Sections;
+
+  Sections get(const std::string &name) const;
+
+  friend std::istream &operator>>(std::istream &, Settings &);
+
+private:
+  Sections m_sections;
+  bool m_resolveEnvVars;
+};
+
+std::istream &operator>>(std::istream &, Settings &);
+} // namespace FIX
+
+#endif // FIX_SETTINGS_H