quickfix_ruby_ud 2.0.7-x86_64-linux

data/ext/quickfix/DataDictionaryProvider.h

@@ -0,0 +1,67 @@
+/* -*- 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_DATADICTIONARYPROVIDER_H
+#define FIX_DATADICTIONARYPROVIDER_H
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4503 4355 4786 4290)
+#endif
+
+#include "DataDictionary.h"
+#include "Exceptions.h"
+#include "Utility.h"
+
+namespace FIX {
+class BeginString;
+class ApplVerID;
+
+/**
+ * Queries for DataDictionary based on appropriate version of %FIX.
+ */
+
+class DataDictionaryProvider {
+public:
+  DataDictionaryProvider() {}
+  DataDictionaryProvider(const DataDictionaryProvider &copy);
+
+  const DataDictionary &getSessionDataDictionary(const BeginString &beginString) const EXCEPT(DataDictionaryNotFound);
+
+  const DataDictionary &getApplicationDataDictionary(const ApplVerID &applVerID) const EXCEPT(DataDictionaryNotFound);
+
+  void addTransportDataDictionary(const BeginString &beginString, std::shared_ptr<DataDictionary>);
+  void addApplicationDataDictionary(const ApplVerID &applVerID, std::shared_ptr<DataDictionary>);
+
+  void addTransportDataDictionary(const BeginString &beginString, const std::string &path) {
+    addTransportDataDictionary(beginString, std::shared_ptr<DataDictionary>(new DataDictionary(path)));
+  }
+  void addApplicationDataDictionary(const ApplVerID &applVerID, const std::string &path) {
+    addApplicationDataDictionary(applVerID, std::shared_ptr<DataDictionary>(new DataDictionary(path)));
+  }
+
+private:
+  std::map<std::string, std::shared_ptr<DataDictionary>> m_transportDictionaries;
+  std::map<std::string, std::shared_ptr<DataDictionary>> m_applicationDictionaries;
+  DataDictionary emptyDataDictionary;
+};
+} // namespace FIX
+
+#endif // FIX_DATADICTIONARYPROVIDER_H

data/ext/quickfix/DatabaseConnectionID.h

@@ -0,0 +1,98 @@
+/* -*- 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_DATABASECONNECTIONID_H
+#define FIX_DATABASECONNECTIONID_H
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4503 4355 4786 4290)
+#endif
+
+#include <map>
+#include <string>
+
+namespace FIX {
+class DatabaseConnectionID {
+public:
+  DatabaseConnectionID(
+      const std::string &database,
+      const std::string &user,
+      const std::string &password,
+      const std::string &host,
+      short port)
+      : m_database(database),
+        m_user(user),
+        m_password(password),
+        m_host(host),
+        m_port(port) {}
+
+  friend bool operator<(const DatabaseConnectionID &, const DatabaseConnectionID &);
+  friend bool operator==(const DatabaseConnectionID &, const DatabaseConnectionID &);
+  friend bool operator!=(const DatabaseConnectionID &, const DatabaseConnectionID &);
+
+  const std::string &getDatabase() const { return m_database; }
+  const std::string &getUser() const { return m_user; }
+  const std::string &getPassword() const { return m_password; }
+  const std::string &getHost() const { return m_host; }
+  short getPort() const { return m_port; }
+
+private:
+  std::string m_database;
+  std::string m_user;
+  std::string m_password;
+  std::string m_host;
+  short m_port;
+};
+
+inline bool operator<(const DatabaseConnectionID &lhs, const DatabaseConnectionID &rhs) {
+  if (lhs.m_database < rhs.m_database) {
+    return true;
+  } else if (rhs.m_database < lhs.m_database) {
+    return false;
+  } else if (lhs.m_user < rhs.m_user) {
+    return true;
+  } else if (rhs.m_user < lhs.m_user) {
+    return false;
+  } else if (lhs.m_password < rhs.m_password) {
+    return true;
+  } else if (rhs.m_password < lhs.m_password) {
+    return false;
+  } else if (lhs.m_host < rhs.m_host) {
+    return true;
+  } else if (rhs.m_host < lhs.m_host) {
+    return false;
+  } else if (lhs.m_port < rhs.m_port) {
+    return true;
+  } else if (rhs.m_port < lhs.m_port) {
+    return false;
+  } else {
+    return false;
+  }
+}
+inline bool operator==(const DatabaseConnectionID &lhs, const DatabaseConnectionID &rhs) {
+  return (
+      (lhs.m_database == rhs.m_database) && (lhs.m_user == rhs.m_user) && (lhs.m_password == rhs.m_password)
+      && (lhs.m_host == rhs.m_host) && (lhs.m_port == rhs.m_port));
+}
+inline bool operator!=(const DatabaseConnectionID &lhs, const DatabaseConnectionID &rhs) { return !(lhs == rhs); }
+} // namespace FIX
+
+#endif

data/ext/quickfix/DatabaseConnectionPool.h

@@ -0,0 +1,84 @@
+/* -*- 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_DATABASECONNECTIONPOOL_H
+#define FIX_DATABASECONNECTIONPOOL_H
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4503 4355 4786 4290)
+#endif
+
+#include "DatabaseConnectionID.h"
+#include <map>
+#include <string>
+
+namespace FIX {
+template <typename T> class DatabaseConnectionPool {
+public:
+  DatabaseConnectionPool(bool poolConnections)
+      : m_poolConnections(poolConnections) {}
+
+  T *create(const DatabaseConnectionID &id) {
+    if (!m_poolConnections) {
+      return new T(id);
+    }
+
+    if (m_connections.find(id) == m_connections.end()) {
+      m_connections[id] = Connection(new T(id), 0);
+    }
+    m_connections[id].second++;
+    return m_connections[id].first;
+  }
+
+  bool destroy(T *pConnection) {
+    if (!m_poolConnections) {
+      delete pConnection;
+      return true;
+    }
+
+    const DatabaseConnectionID &id = pConnection->connectionID();
+    if (m_connections.find(id) == m_connections.end()) {
+      return false;
+    }
+
+    Connection &connection = m_connections[id];
+    if (connection.first != pConnection) {
+      return false;
+    }
+
+    connection.second--;
+    if (connection.second == 0) {
+      m_connections.erase(id);
+      delete pConnection;
+    }
+    return true;
+  }
+
+private:
+  typedef std::pair<T *, int> Connection;
+  typedef std::map<DatabaseConnectionID, Connection> Connections;
+
+  Connections m_connections;
+  bool m_poolConnections;
+};
+} // namespace FIX
+
+#endif

data/ext/quickfix/Dictionary.cpp

@@ -0,0 +1,157 @@
+/****************************************************************************
+** 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 "Dictionary.h"
+#include "FieldConvertors.h"
+#include <algorithm>
+
+namespace FIX {
+std::string Dictionary::getString(const std::string &key, bool capitalize) const
+    EXCEPT(ConfigError, FieldConvertError) {
+  Data::const_iterator i = m_data.find(string_toUpper(key));
+  if (i == m_data.end()) {
+    throw ConfigError(key + " not defined");
+  }
+
+  std::string result = i->second;
+  if (capitalize) {
+    std::transform(result.begin(), result.end(), result.begin(), toupper);
+  }
+
+  return result;
+}
+
+int Dictionary::getInt(const std::string &key) const EXCEPT(ConfigError, FieldConvertError) {
+  try {
+    return IntConvertor::convert(getString(key));
+  } catch (FieldConvertError &) {
+    throw ConfigError("Illegal value " + getString(key) + " for " + key);
+  }
+}
+
+double Dictionary::getDouble(const std::string &key) const EXCEPT(ConfigError, FieldConvertError) {
+  try {
+    return DoubleConvertor::convert(getString(key));
+  } catch (FieldConvertError &) {
+    throw ConfigError("Illegal value " + getString(key) + " for " + key);
+  }
+}
+
+bool Dictionary::getBool(const std::string &key) const EXCEPT(ConfigError, FieldConvertError) {
+  try {
+    return BoolConvertor::convert(getString(key));
+  } catch (FieldConvertError &) {
+    throw ConfigError("Illegal value " + getString(key) + " for " + key);
+  }
+}
+
+int Dictionary::getDay(const std::string &key) const EXCEPT(ConfigError, FieldConvertError) {
+  try {
+    std::string value = getString(key);
+    if (value.size() < 2) {
+      throw FieldConvertError();
+    }
+    std::string abbr = value.substr(0, 2);
+    std::transform(abbr.begin(), abbr.end(), abbr.begin(), tolower);
+    if (abbr == "su") {
+      return 1;
+    }
+    if (abbr == "mo") {
+      return 2;
+    }
+    if (abbr == "tu") {
+      return 3;
+    }
+    if (abbr == "we") {
+      return 4;
+    }
+    if (abbr == "th") {
+      return 5;
+    }
+    if (abbr == "fr") {
+      return 6;
+    }
+    if (abbr == "sa") {
+      return 7;
+    }
+  } catch (FieldConvertError &) {
+    throw ConfigError("Illegal value " + getString(key) + " for " + key);
+  }
+  return -1;
+}
+
+void Dictionary::setString(const std::string &key, const std::string &value) {
+  m_data[string_strip(string_toUpper(key))] = string_strip(value);
+}
+
+void Dictionary::setInt(const std::string &key, int value) {
+  m_data[string_strip(string_toUpper(key))] = IntConvertor::convert(value);
+}
+
+void Dictionary::setDouble(const std::string &key, double value) {
+  m_data[string_strip(string_toUpper(key))] = DoubleConvertor::convert(value);
+}
+
+void Dictionary::setBool(const std::string &key, bool value) {
+  m_data[string_strip(string_toUpper(key))] = BoolConvertor::convert(value);
+}
+
+void Dictionary::setDay(const std::string &key, int value) {
+  switch (value) {
+  case 1:
+    setString(key, "SU");
+    break;
+  case 2:
+    setString(key, "MO");
+    break;
+  case 3:
+    setString(key, "TU");
+    break;
+  case 4:
+    setString(key, "WE");
+    break;
+  case 5:
+    setString(key, "TH");
+    break;
+  case 6:
+    setString(key, "FR");
+    break;
+  case 7:
+    setString(key, "SA");
+    break;
+  }
+}
+
+bool Dictionary::has(const std::string &key) const { return m_data.find(string_toUpper(key)) != m_data.end(); }
+
+void Dictionary::merge(const Dictionary &toMerge) {
+  Data::const_iterator i = toMerge.m_data.begin();
+  for (; i != toMerge.m_data.end(); ++i) {
+    if (m_data.find(i->first) == m_data.end()) {
+      m_data[i->first] = i->second;
+    }
+  }
+}
+} // namespace FIX

data/ext/quickfix/Dictionary.h

@@ -0,0 +1,89 @@
+/* -*- 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_DICTIONARY_H
+#define FIX_DICTIONARY_H
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4503 4355 4786 4290)
+#endif
+
+#include "Exceptions.h"
+#include <map>
+#include <string>
+
+namespace FIX {
+/// For storage and retrieval of key/value pairs.
+class Dictionary {
+public:
+  Dictionary(const std::string &name)
+      : m_name(name) {}
+  Dictionary() {}
+  virtual ~Dictionary() {}
+
+  typedef std::map<std::string, std::string> Data;
+  typedef Data::const_iterator iterator;
+  typedef iterator const_iterator;
+  typedef Data::value_type value_type;
+
+  /// Get the name of the dictionary.
+  std::string getName() const { return m_name; }
+  /// Return the number of key/value pairs.
+  size_t size() const { return m_data.size(); }
+
+  /// Get a value as a string.
+  std::string getString(const std::string &, bool capitalize = false) const EXCEPT(ConfigError, FieldConvertError);
+  /// Get a value as a int.
+  int getInt(const std::string &) const EXCEPT(ConfigError, FieldConvertError);
+  /// Get a value as a double.
+  double getDouble(const std::string &) const EXCEPT(ConfigError, FieldConvertError);
+  /// Get a value as a bool
+  bool getBool(const std::string &) const EXCEPT(ConfigError, FieldConvertError);
+  /// Get a value as a day of week
+  int getDay(const std::string &) const EXCEPT(ConfigError, FieldConvertError);
+
+  /// Set a value from a string.
+  void setString(const std::string &, const std::string &);
+  /// Set a value from a int.
+  void setInt(const std::string &, int);
+  /// Set a value from a double.
+  void setDouble(const std::string &, double);
+  /// Set a value from a bool
+  void setBool(const std::string &, bool);
+  /// Set a value from a day
+  void setDay(const std::string &, int);
+
+  /// Check if the dictionary contains a value for key.
+  bool has(const std::string &) const;
+  /// Merge two dictionaries.
+  void merge(const Dictionary &);
+
+  iterator begin() const { return m_data.begin(); }
+  iterator end() const { return m_data.end(); }
+
+private:
+  Data m_data;
+  std::string m_name;
+};
+/*! @} */
+} // namespace FIX
+
+#endif // FIX_DICTIONARY_H

data/ext/quickfix/Event.h

@@ -0,0 +1,89 @@
+/* -*- 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_EVENT_H
+#define FIX_EVENT_H
+
+#include "Utility.h"
+#include <math.h>
+
+#ifndef _MSC_VER
+#include <cmath>
+#include <pthread.h>
+#endif
+
+namespace FIX {
+/// Portable implementation of an event/conditional mutex
+class Event {
+public:
+  Event() {
+#ifdef _MSC_VER
+    m_event = CreateEvent(0, false, false, 0);
+#else
+    pthread_mutex_init(&m_mutex, 0);
+    pthread_cond_init(&m_event, 0);
+#endif
+  }
+
+  ~Event() {
+#ifdef _MSC_VER
+    CloseHandle(m_event);
+#else
+    pthread_cond_destroy(&m_event);
+    pthread_mutex_destroy(&m_mutex);
+#endif
+  }
+
+  void signal() {
+#ifdef _MSC_VER
+    SetEvent(m_event);
+#else
+    pthread_mutex_lock(&m_mutex);
+    pthread_cond_broadcast(&m_event);
+    pthread_mutex_unlock(&m_mutex);
+#endif
+  }
+
+  void wait(double s) {
+#ifdef _MSC_VER
+    WaitForSingleObject(m_event, (long)(s * 1000));
+#else
+    pthread_mutex_lock(&m_mutex);
+    timespec time, remainder;
+    double intpart;
+    time.tv_nsec = (long)(modf(s, &intpart) * 1e9);
+    time.tv_sec = (int)intpart;
+    pthread_cond_timedwait(&m_event, &m_mutex, &time);
+    pthread_mutex_unlock(&m_mutex);
+#endif
+  }
+
+private:
+#ifdef _MSC_VER
+  HANDLE m_event;
+#else
+  pthread_cond_t m_event;
+  pthread_mutex_t m_mutex;
+#endif
+};
+} // namespace FIX
+
+#endif

data/ext/quickfix/Except.h

@@ -0,0 +1,39 @@
+/* -*- 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_EXCEPT_H
+#define FIX_EXCEPT_H
+
+#if !defined(__cpp_noexcept_function_type) && defined(__cplusplus)
+#if __cplusplus > 201703L
+#define __cpp_noexcept_function_type 1
+#endif
+#endif
+
+#ifdef __cpp_noexcept_function_type
+#define NOEXCEPT noexcept
+#define EXCEPT(...)
+#else
+#define NOEXCEPT throw()
+#define EXCEPT(...) throw(__VA_ARGS__)
+#endif
+
+#endif