quickfix_ruby_ud 2.0.7-aarch64-linux

data/ext/quickfix/Group.cpp

@@ -0,0 +1,44 @@
+/****************************************************************************
+** 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 "Group.h"
+
+namespace FIX {
+void Group::addGroup(const Group &group) { FieldMap::addGroup(group.field(), group); }
+
+void Group::replaceGroup(unsigned num, const FIX::Group &group) { FieldMap::replaceGroup(num, group.field(), group); }
+
+Group &Group::getGroup(unsigned num, Group &group) const EXCEPT(FieldNotFound) {
+  return static_cast<Group &>(FieldMap::getGroup(num, group.field(), group));
+}
+
+void Group::removeGroup(unsigned num, const Group &group) { FieldMap::removeGroup(num, group.field()); }
+
+void Group::removeGroup(const Group &group) { FieldMap::removeGroup(group.field()); }
+
+bool Group::hasGroup(unsigned num, const Group &group) { return FieldMap::hasGroup(num, group.field()); }
+
+bool Group::hasGroup(const Group &group) { return FieldMap::hasGroup(group.field()); }
+} // namespace FIX

data/ext/quickfix/Group.h

@@ -0,0 +1,78 @@
+/* -*- 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_GROUP
+#define FIX_GROUP
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4786)
+#endif
+
+#include "FieldMap.h"
+#include "Fields.h"
+#include <vector>
+
+namespace FIX {
+/**
+ * Base class for all %FIX repeating groups.
+ *
+ * A group consists of a count field, deliminator, and a sorting order.
+ */
+class Group : public FieldMap {
+public:
+  Group(int field, int delim)
+      : FieldMap(message_order(delim, 0)),
+        m_field(field),
+        m_delim(delim) {}
+
+  Group(int field, int delim, const int order[])
+      : FieldMap(order),
+        m_field(field),
+        m_delim(delim) {}
+
+  Group(int field, int delim, const message_order &order)
+      : FieldMap(order),
+        m_field(field),
+        m_delim(delim) {}
+
+  Group(const Group &copy)
+      : FieldMap(copy),
+        m_field(copy.m_field),
+        m_delim(copy.m_delim) {}
+
+  int field() const { return m_field; }
+  int delim() const { return m_delim; }
+
+  void addGroup(const Group &group);
+  void replaceGroup(unsigned num, const Group &group);
+  Group &getGroup(unsigned num, Group &group) const EXCEPT(FieldNotFound);
+  void removeGroup(unsigned num, const Group &group);
+  void removeGroup(const Group &group);
+  bool hasGroup(const Group &group);
+  bool hasGroup(unsigned num, const Group &group);
+
+private:
+  int m_field;
+  int m_delim;
+};
+} // namespace FIX
+
+#endif // FIX_GROUP

data/ext/quickfix/HostDetailsProvider.cpp

@@ -0,0 +1,79 @@
+#include "HostDetailsProvider.h"
+#include "SessionSettings.h"
+
+const std::string FIX::HostDetailsProvider::HOST_SELECTION_POLICY_PRIORITY = "PRIORITY";
+
+FIX::HostDetails FIX::HostDetailsProvider::getHost(const SessionID &s, const Dictionary &d) {
+  std::string hostSelectionPolicy;
+  if (d.has(HOST_SELECTION_POLICY)) {
+    hostSelectionPolicy = d.getString(HOST_SELECTION_POLICY);
+  }
+
+  auto sessionIt = m_sessionToLastConnectionAttempt.find(s);
+
+  time_t now = getTime();
+
+  if (sessionIt == m_sessionToLastConnectionAttempt.end()) {
+    auto result = m_sessionToLastConnectionAttempt.emplace(s, LastConnectionAttempt{0, now});
+    sessionIt = result.first;
+  } else {
+    if (hostSelectionPolicy == HOST_SELECTION_POLICY_PRIORITY) {
+      int startOverInterval = 120;
+      if (d.has(HOST_SELECTION_POLICY_PRIORITY_START_OVER_INTERVAL)) {
+        startOverInterval = d.getInt(HOST_SELECTION_POLICY_PRIORITY_START_OVER_INTERVAL);
+      }
+
+      if ((now - sessionIt->second.time >= startOverInterval)) {
+        sessionIt->second.hostNumber = 0;
+        sessionIt->second.time = now;
+      } else {
+        ++sessionIt->second.hostNumber;
+        sessionIt->second.time = now;
+      }
+    } else {
+      ++sessionIt->second.hostNumber;
+      sessionIt->second.time = now;
+    }
+  }
+
+  HostDetails details;
+  bool isDefinedInSettings = populateHostDetails(sessionIt->second.hostNumber, d, details);
+
+  if (!isDefinedInSettings) {
+    populateHostDetails(0, d, details);
+    sessionIt->second.hostNumber = 0;
+  }
+
+  return details;
+}
+
+bool FIX::HostDetailsProvider::populateHostDetails(int n, const Dictionary &d, HostDetails &out) {
+  std::string host = SOCKET_CONNECT_HOST;
+  std::string port = SOCKET_CONNECT_PORT;
+  std::string sourceHost = SOCKET_CONNECT_SOURCE_HOST;
+  std::string sourcePort = SOCKET_CONNECT_SOURCE_PORT;
+
+  if (n > 0) {
+    std::string suffix = std::to_string(n);
+    host += suffix;
+    port += suffix;
+    sourceHost += suffix;
+    sourcePort += suffix;
+  }
+
+  if (d.has(host) && d.has(port)) {
+    out.address = d.getString(host);
+    out.port = (short)d.getInt(port);
+
+    if (d.has(sourceHost)) {
+      out.sourceAddress = d.getString(sourceHost);
+    }
+
+    if (d.has(sourcePort)) {
+      out.sourcePort = (short)d.getInt(sourcePort);
+    }
+
+    return true;
+  }
+  return false;
+}

data/ext/quickfix/HostDetailsProvider.h

@@ -0,0 +1,44 @@
+#ifndef FIX_HOSTDETAILSPROVIDER_H
+#define FIX_HOSTDETAILSPROVIDER_H
+
+#include <functional>
+#include <map>
+#include <optional>
+#include <string>
+#include <time.h>
+
+namespace FIX {
+class Dictionary;
+class SessionID;
+
+struct HostDetails {
+  std::string address;
+  short port{0};
+  std::string sourceAddress;
+  short sourcePort{0};
+};
+
+class HostDetailsProvider {
+public:
+  static const std::string HOST_SELECTION_POLICY_PRIORITY;
+
+  HostDetails getHost(const SessionID &s, const Dictionary &d);
+
+  std::function<time_t()> getTime = []() {
+    time_t now;
+    ::time(&now);
+    return now;
+  };
+
+private:
+  bool populateHostDetails(int n, const Dictionary &d, HostDetails &out);
+
+  struct LastConnectionAttempt {
+    int hostNumber;
+    time_t time;
+  };
+  std::map<SessionID, LastConnectionAttempt> m_sessionToLastConnectionAttempt;
+};
+} // namespace FIX
+
+#endif

data/ext/quickfix/HtmlBuilder.h

@@ -0,0 +1,178 @@
+/* -*- 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 HTML_BUILDER_H
+#define HTML_BUILDER_H
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4503 4355 4786 4290)
+#endif
+
+#include <sstream>
+
+namespace HTML {
+class TAG {
+public:
+  TAG(const std::string &tag, std::ostream &stream)
+      : m_tag(tag),
+        m_stream(stream) {
+    m_stream << "<" << m_tag;
+  }
+
+  virtual ~TAG() {
+    m_stream << m_value.str();
+    m_stream << "</" << m_tag << ">";
+  }
+
+  TAG &text() {
+    m_stream << ">";
+    return *this;
+  }
+  template <typename T> TAG &text(const T &value) {
+    m_value << value;
+    text();
+    return *this;
+  }
+
+private:
+  std::string m_tag;
+  std::stringstream m_value;
+
+protected:
+  std::ostream &m_stream;
+};
+
+class SPECIAL {
+public:
+  SPECIAL(const std::string &value, std::ostream &stream) { stream << "&" << value << ";"; }
+};
+
+class A : public TAG {
+public:
+  A(std::ostream &stream)
+      : TAG("A", stream) {}
+
+  A &href(const std::string &value) {
+    m_stream << " href='" << value << "'";
+    return *this;
+  }
+};
+
+class BODY : public TAG {
+public:
+  BODY(std::ostream &stream)
+      : TAG("BODY", stream) {}
+};
+
+class BR : public TAG {
+public:
+  BR(std::ostream &stream)
+      : TAG("BR", stream) {}
+};
+
+class CAPTION : public TAG {
+public:
+  CAPTION(std::ostream &stream)
+      : TAG("CAPTION", stream) {}
+};
+
+class CENTER : public TAG {
+public:
+  CENTER(std::ostream &stream)
+      : TAG("CENTER", stream) {}
+};
+
+class EM : public TAG {
+public:
+  EM(std::ostream &stream)
+      : TAG("EM", stream) {}
+};
+
+class H1 : public TAG {
+public:
+  H1(std::ostream &stream)
+      : TAG("H1", stream) {}
+};
+
+class H2 : public TAG {
+public:
+  H2(std::ostream &stream)
+      : TAG("H2", stream) {}
+};
+
+class HEAD : public TAG {
+public:
+  HEAD(std::ostream &stream)
+      : TAG("HEAD", stream) {}
+};
+
+class HR : public TAG {
+public:
+  HR(std::ostream &stream)
+      : TAG("HR", stream) {}
+};
+
+const char *NBSP = "&nbsp;";
+
+class TABLE : public TAG {
+public:
+  TABLE(std::ostream &stream)
+      : TAG("TABLE", stream) {}
+
+  TABLE &border(int value) {
+    m_stream << " border='" << value << "'";
+    return *this;
+  }
+  TABLE &cellspacing(int value) {
+    m_stream << " cellspacing='" << value << "'";
+    return *this;
+  }
+  TABLE &width(int value) {
+    m_stream << " width='" << value << "%'";
+    return *this;
+  }
+};
+
+class TD : public TAG {
+public:
+  TD(std::ostream &stream)
+      : TAG("TD", stream) {}
+
+  TD &align(const std::string &value) {
+    m_stream << " align='" << value << "'";
+    return *this;
+  }
+};
+
+class TITLE : public TAG {
+public:
+  TITLE(std::ostream &stream)
+      : TAG("TITLE", stream) {}
+};
+
+class TR : public TAG {
+public:
+  TR(std::ostream &stream)
+      : TAG("TR", stream) {}
+};
+} // namespace HTML
+
+#endif