quickfix_ruby_ud 2.0.7-x86_64-linux

data/ext/quickfix/FieldMap.cpp

@@ -0,0 +1,254 @@
+/****************************************************************************
+** 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 "FieldMap.h"
+#include <algorithm>
+#include <deque>
+#include <iterator>
+
+namespace FIX {
+
+FieldMap::FieldMap(const message_order &order, int size)
+    : m_order(order) {
+  m_fields.reserve(size);
+}
+
+FieldMap::FieldMap(const message_order &order /*= message_order(message_order::normal)*/)
+    : m_order(order) {
+  m_fields.reserve(DEFAULT_SIZE);
+}
+
+FieldMap::FieldMap(const int order[])
+    : m_order(message_order(order)) {
+  m_fields.reserve(DEFAULT_SIZE);
+}
+
+FieldMap::FieldMap(const FieldMap &copy) { *this = copy; }
+
+FieldMap::FieldMap(FieldMap &&rhs)
+    : m_fields(std::move(rhs.m_fields)),
+      m_groups(std::move(rhs.m_groups)),
+      m_order(std::move(rhs.m_order)) {}
+
+FieldMap::~FieldMap() { clear(); }
+
+FieldMap &FieldMap::operator=(const FieldMap &rhs) {
+  clear();
+
+  m_fields = rhs.m_fields;
+  m_order = rhs.m_order;
+
+  for (auto const &tagWithGroups : rhs.m_groups) {
+    for (auto const &group : tagWithGroups.second) {
+      m_groups[tagWithGroups.first].push_back(new FieldMap(*group));
+    }
+  }
+
+  return *this;
+}
+
+FieldMap &FieldMap::operator=(FieldMap &&rhs) {
+  m_fields = std::move(rhs.m_fields);
+  m_groups = std::move(rhs.m_groups);
+  m_order = std::move(rhs.m_order);
+  return *this;
+}
+
+void FieldMap::addGroup(int field, const FieldMap &group, bool setCount) {
+  FieldMap *pGroup = new FieldMap(group);
+
+  addGroupPtr(field, pGroup, setCount);
+}
+
+void FieldMap::addGroupPtr(int tag, FieldMap *group, bool setCount) {
+  if (group == 0) {
+    return;
+  }
+
+  std::vector<FieldMap *> &groups = m_groups[tag];
+  groups.push_back(group);
+
+  if (setCount) {
+    setField(IntField(tag, (int)groups.size()));
+  }
+}
+
+void FieldMap::replaceGroup(int num, int tag, const FieldMap &group) {
+  Groups::const_iterator tagWithGroups = m_groups.find(tag);
+  if (tagWithGroups == m_groups.end()) {
+    return;
+  }
+  if (num <= 0) {
+    return;
+  }
+  if (tagWithGroups->second.size() < static_cast<unsigned>(num)) {
+    return;
+  }
+  *(*(tagWithGroups->second.begin() + (num - 1))) = group;
+}
+
+void FieldMap::removeGroup(int num, int tag) {
+  Groups::iterator tagWithGroups = m_groups.find(tag);
+  if (tagWithGroups == m_groups.end()) {
+    return;
+  }
+  if (num <= 0) {
+    return;
+  }
+  std::vector<FieldMap *> &groups = tagWithGroups->second;
+  if (groups.size() < static_cast<unsigned>(num)) {
+    return;
+  }
+
+  std::vector<FieldMap *>::iterator group = groups.begin();
+  std::advance(group, (num - 1));
+
+  delete (*group);
+  groups.erase(group);
+
+  if (groups.size() == 0) {
+    m_groups.erase(tagWithGroups);
+    removeField(tag);
+  } else {
+    IntField groupCount(tag, (int)groups.size());
+    setField(groupCount);
+  }
+}
+
+void FieldMap::removeGroup(int tag) {
+  Groups::iterator tagWithGroups = m_groups.find(tag);
+  if (tagWithGroups == m_groups.end()) {
+    return;
+  }
+
+  std::vector<FieldMap *> toDelete;
+  toDelete.swap(tagWithGroups->second);
+
+  m_groups.erase(tagWithGroups);
+
+  std::for_each(toDelete.begin(), toDelete.end(), [](FieldMap *group) { delete group; });
+
+  removeField(tag);
+}
+
+void FieldMap::removeField(int tag) {
+  Fields::iterator field = findTag(tag);
+  if (field != m_fields.end()) {
+    m_fields.erase(field);
+    removeGroup(tag);
+  }
+}
+
+bool FieldMap::hasGroup(int num, int tag) const { return (int)groupCount(tag) >= num; }
+
+bool FieldMap::hasGroup(int tag) const { return m_groups.find(tag) != m_groups.end(); }
+
+size_t FieldMap::groupCount(int tag) const {
+  Groups::const_iterator tagWithGroups = m_groups.find(tag);
+  return tagWithGroups == m_groups.end() ? 0 : tagWithGroups->second.size();
+}
+
+void FieldMap::clear() {
+  m_fields.clear();
+
+  for (auto const &tagWithGroups : m_groups) {
+    for (auto const &group : tagWithGroups.second) {
+      delete group;
+    }
+  }
+
+  m_groups.clear();
+}
+
+bool FieldMap::isEmpty() { return m_fields.empty(); }
+
+size_t FieldMap::totalFields() const {
+  size_t result = m_fields.size();
+
+  for (auto const &tagWithGroups : m_groups) {
+    for (auto const &group : tagWithGroups.second) {
+      result += group->totalFields();
+    }
+  }
+  return result;
+}
+
+std::string &FieldMap::calculateString(std::string &result) const {
+  for (auto const &field : m_fields) {
+    result += field.getFixString();
+
+    // add groups if they exist
+    if (!m_groups.size()) {
+      continue;
+    }
+
+    Groups::const_iterator tagWithGroups = m_groups.find(field.getTag());
+    if (tagWithGroups == m_groups.end()) {
+      continue;
+    }
+
+    for (auto const &group : tagWithGroups->second) {
+      group->calculateString(result);
+    }
+  }
+  return result;
+}
+
+int FieldMap::calculateLength(int beginStringField, int bodyLengthField, int checkSumField) const {
+  int result = 0;
+
+  for (auto const &field : m_fields) {
+    const int tag = field.getTag();
+    if (tag != beginStringField && tag != bodyLengthField && tag != checkSumField) {
+      result += field.getLength();
+    }
+  }
+
+  for (auto const &tagWithGroups : m_groups) {
+    for (auto const &group : tagWithGroups.second) {
+      result += group->calculateLength();
+    }
+  }
+  return result;
+}
+
+int FieldMap::calculateTotal(int checkSumField) const {
+  int result = 0;
+
+  for (auto const &field : m_fields) {
+    if (field.getTag() != checkSumField) {
+      result += field.getTotal();
+    }
+  }
+
+  for (auto const &tagWithGroups : m_groups) {
+    for (auto const &group : tagWithGroups.second) {
+      result += group->calculateTotal();
+    }
+  }
+  return result;
+}
+
+} // namespace FIX

data/ext/quickfix/FieldMap.h

@@ -0,0 +1,327 @@
+/* -*- 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_FIELDMAP
+#define FIX_FIELDMAP
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4786)
+#endif
+
+#include "Exceptions.h"
+#include "Field.h"
+#include "MessageSorters.h"
+#include "Utility.h"
+#include <algorithm>
+#include <map>
+#include <sstream>
+#include <vector>
+
+namespace FIX {
+/**
+ * Stores and organizes a collection of Fields.
+ *
+ * This is the basis for a message, header, and trailer.  This collection
+ * class uses a sorter to keep the fields in a particular order.
+ */
+class FieldMap {
+
+  class sorter {
+  public:
+    explicit sorter(const message_order &order)
+        : m_order(order) {}
+
+    bool operator()(int tag, const FieldBase &right) const { return m_order(tag, right.getTag()); }
+
+    bool operator()(const FieldBase &left, int tag) const { return m_order(left.getTag(), tag); }
+
+    bool operator()(const FieldBase &left, const FieldBase &right) const {
+      return m_order(left.getTag(), right.getTag());
+    }
+
+  private:
+    const message_order &m_order;
+  };
+
+  class finder {
+  public:
+    explicit finder(int tag)
+        : m_tag(tag) {}
+
+    bool operator()(const FieldBase &field) const { return m_tag == field.getTag(); }
+
+  private:
+    int m_tag;
+  };
+
+  enum {
+    DEFAULT_SIZE = 16
+  };
+
+protected:
+  FieldMap(const message_order &order, int size);
+
+public:
+  typedef std::vector<FieldBase, ALLOCATOR<FieldBase>> Fields;
+  typedef std::
+      map<int, std::vector<FieldMap *>, std::less<int>, ALLOCATOR<std::pair<const int, std::vector<FieldMap *>>>>
+          Groups;
+
+  typedef Fields::iterator iterator;
+  typedef Fields::const_iterator const_iterator;
+  typedef Fields::value_type value_type;
+  typedef Groups::iterator g_iterator;
+  typedef Groups::const_iterator g_const_iterator;
+  typedef Groups::value_type g_value_type;
+
+  FieldMap(const message_order &order = message_order(message_order::normal));
+
+  FieldMap(const int order[]);
+
+  FieldMap(const FieldMap &copy);
+  FieldMap(FieldMap &&rhs);
+
+  virtual ~FieldMap();
+
+  FieldMap &operator=(const FieldMap &rhs);
+  FieldMap &operator=(FieldMap &&rhs);
+
+  /// Set a field without type checking
+  void setField(const FieldBase &field, bool overwrite = true) EXCEPT(RepeatedTag) {
+    if (!overwrite) {
+      addField(field);
+    } else {
+      Fields::iterator foundField = findTag(field.getTag());
+      if (foundField == m_fields.end()) {
+        addField(field);
+      } else {
+        foundField->setString(field.getString());
+      }
+    }
+  }
+
+  /// Set a field without a field class
+  void setField(int tag, const std::string &value) EXCEPT(RepeatedTag, NoTagValue) {
+    FieldBase fieldBase(tag, value);
+    setField(fieldBase);
+  }
+
+  /// Get a field if set
+  bool getFieldIfSet(FieldBase &field) const {
+    Fields::const_iterator foundField = findTag(field.getTag());
+    if (foundField == m_fields.end()) {
+      return false;
+    }
+    field = (*foundField);
+    return true;
+  }
+
+  /// Get a field without type checking
+  FieldBase &getField(FieldBase &field) const EXCEPT(FieldNotFound) {
+    field = getFieldRef(field.getTag());
+    return field;
+  }
+
+  /// Get a field without type checking
+  template <typename T> const T &getField() const EXCEPT(FieldNotFound) {
+    return *reinterpret_cast<const T *>(&getFieldRef(T::tag));
+  }
+
+  /// Get a field without a field class
+  const std::string &getField(int tag) const EXCEPT(FieldNotFound) { return getFieldRef(tag).getString(); }
+
+  /// Get direct access to a field through a reference
+  const FieldBase &getFieldRef(int tag) const EXCEPT(FieldNotFound) {
+    Fields::const_iterator field = findTag(tag);
+    if (field == m_fields.end()) {
+      throw FieldNotFound(tag);
+    }
+    return (*field);
+  }
+
+  /// Get direct access to a field through a pointer
+  const FieldBase *const getFieldPtr(int tag) const EXCEPT(FieldNotFound) { return &getFieldRef(tag); }
+
+  /// Check to see if a field is set
+  bool isSetField(const FieldBase &field) const { return isSetField(field.getTag()); }
+  /// Check to see if a field is set by referencing its number
+  bool isSetField(int tag) const { return findTag(tag) != m_fields.end(); }
+
+  /// Remove a field. If field is not present, this is a no-op.
+  void removeField(int tag);
+
+  /// Add a group.
+  void addGroup(int tag, const FieldMap &group, bool setCount = true);
+
+  /// Acquire ownership of Group object
+  void addGroupPtr(int tag, FieldMap *group, bool setCount = true);
+
+  /// Replace a specific instance of a group.
+  void replaceGroup(int num, int tag, const FieldMap &group);
+
+  /// Get a specific instance of a group.
+  FieldMap &getGroup(int num, int tag, FieldMap &group) const EXCEPT(FieldNotFound) {
+    return group = getGroupRef(num, tag);
+  }
+
+  /// Get direct access to a field through a reference
+  FieldMap &getGroupRef(int num, int tag) const EXCEPT(FieldNotFound) {
+    Groups::const_iterator tagWithGroups = m_groups.find(tag);
+    if (tagWithGroups == m_groups.end()) {
+      throw FieldNotFound(tag);
+    }
+    if (num <= 0) {
+      throw FieldNotFound(tag);
+    }
+    if (tagWithGroups->second.size() < static_cast<unsigned>(num)) {
+      throw FieldNotFound(tag);
+    }
+    return *(*(tagWithGroups->second.begin() + (num - 1)));
+  }
+
+  /// Get direct access to a field through a pointer
+  FieldMap *getGroupPtr(int num, int tag) const EXCEPT(FieldNotFound) { return &getGroupRef(num, tag); }
+
+  const Groups &groups() const { return m_groups; }
+
+  /// Remove a specific instance of a group.
+  void removeGroup(int num, int tag);
+  /// Remove all instances of a group.
+  void removeGroup(int tag);
+
+  /// Check to see any instance of a group exists
+  bool hasGroup(int tag) const;
+  /// Check to see if a specific instance of a group exists
+  bool hasGroup(int num, int tag) const;
+  /// Count the number of instance of a group
+  size_t groupCount(int tag) const;
+
+  /// Clear all fields from the map
+  void clear();
+  /// Check if map contains any fields
+  bool isEmpty();
+
+  size_t totalFields() const;
+
+  std::string &calculateString(std::string &) const;
+
+  int calculateLength(
+      int beginStringField = FIELD::BeginString,
+      int bodyLengthField = FIELD::BodyLength,
+      int checkSumField = FIELD::CheckSum) const;
+
+  int calculateTotal(int checkSumField = FIELD::CheckSum) const;
+
+  iterator begin() { return m_fields.begin(); }
+  iterator end() { return m_fields.end(); }
+  const_iterator begin() const { return m_fields.begin(); }
+  const_iterator end() const { return m_fields.end(); }
+  g_iterator g_begin() { return m_groups.begin(); }
+  g_iterator g_end() { return m_groups.end(); }
+  g_const_iterator g_begin() const { return m_groups.begin(); }
+  g_const_iterator g_end() const { return m_groups.end(); }
+
+protected:
+  friend class Message;
+
+  void addField(const FieldBase &field) {
+    Fields::iterator iter = findPositionFor(field.getTag());
+    if (iter == m_fields.end()) {
+      m_fields.push_back(field);
+    } else {
+      m_fields.insert(iter, field);
+    }
+  }
+
+  // used to find data length fields during message decoding
+  // message fields are not yet sorted so regular find*** functions might return wrong results
+  const FieldBase &reverse_find(int tag) const {
+    Fields::const_reverse_iterator field = std::find_if(m_fields.rbegin(), m_fields.rend(), finder(tag));
+    if (field == m_fields.rend()) {
+      throw FieldNotFound(tag);
+    }
+
+    return *field;
+  }
+
+  // append field to message without sorting
+  // only applicable during message decoding
+  void appendField(const FieldBase &field) { m_fields.push_back(field); }
+
+  // sort fields after message decoding
+  void sortFields() { std::sort(m_fields.begin(), m_fields.end(), sorter(m_order)); }
+
+private:
+  Fields::const_iterator findTag(int tag) const { return lookup(m_fields.begin(), m_fields.end(), tag); }
+
+  Fields::iterator findTag(int tag) { return lookup(m_fields.begin(), m_fields.end(), tag); }
+
+  template <typename Iterator> Iterator lookup(Iterator begin, Iterator end, int tag) const {
+#if defined(__SUNPRO_CC)
+    std::size_t numElements;
+    std::distance(begin, end, numElements);
+#else
+    std::size_t numElements = std::distance(begin, end);
+#endif
+    if (numElements < 16) {
+      return std::find_if(begin, end, finder(tag));
+    }
+
+    Iterator field = std::lower_bound(begin, end, tag, sorter(m_order));
+    if (field != end && field->getTag() == tag) {
+      return field;
+    }
+
+    return end;
+  }
+
+  Fields::iterator findPositionFor(int tag) {
+    if (m_fields.empty()) {
+      return m_fields.end();
+    }
+
+    const FieldBase &lastField = m_fields.back();
+    if (m_order(lastField.getTag(), tag) || lastField.getTag() == tag) {
+      return m_fields.end();
+    }
+
+    return std::upper_bound(m_fields.begin(), m_fields.end(), tag, sorter(m_order));
+  }
+
+  Fields m_fields;
+  Groups m_groups;
+  message_order m_order;
+};
+/*! @} */
+} // namespace FIX
+
+#define FIELD_SET(MAP, FIELD)                                                                                          \
+  bool isSet(const FIELD &field) const { return (MAP).isSetField(field); }                                             \
+  void set(const FIELD &field) { (MAP).setField(field); }                                                              \
+  FIELD &get(FIELD &field) const { return (FIELD &)(MAP).getField(field); }                                            \
+  bool getIfSet(FIELD &field) const { return (MAP).getFieldIfSet(field); }
+
+#define FIELD_GET_PTR(MAP, FLD) (const FIX::FLD *)MAP.getFieldPtr(FIX::FIELD::FLD)
+#define FIELD_GET_REF(MAP, FLD) (const FIX::FLD &)MAP.getFieldRef(FIX::FIELD::FLD)
+#define FIELD_THROW_IF_NOT_FOUND(MAP, FLD)                                                                             \
+  if (!(MAP).isSetField(FIX::FIELD::FLD))                                                                              \
+  throw FieldNotFound(FIX::FIELD::FLD)
+#endif // FIX_FIELDMAP

data/ext/quickfix/FieldNumbers.h

@@ -0,0 +1,44 @@
+/* -*- 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_FIELDNUMBERS_BASE_H
+#define FIX_FIELDNUMBERS_BASE_H
+
+#include "FixFieldNumbers.h"
+#include <iostream>
+
+namespace FIX {
+namespace FIELD {
+const int FIX40_LastField = PrevClosePx;
+const int FIX41_LastField = PegDifference;
+const int FIX42_LastField = EncodedListStatusText;
+const int FIX43_LastField = SideComplianceID;
+const int FIX44_LastField = LegInterestAccrualDate;
+const int FIX50_LastField = ExchangeSpecialInstructions;
+const int NormalMin = 1;
+const int NormalMax = 4999;
+const int UserMin = 5000;
+const int UserMax = 9999;
+const int InternalMin = 10000;
+} // namespace FIELD
+} // namespace FIX
+
+#endif // FIX_FIELDNUMBERS_BASE_H

data/ext/quickfix/FieldTypes.cpp

@@ -0,0 +1,62 @@
+/****************************************************************************
+** 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 "FieldTypes.h"
+
+#ifdef HAVE_FTIME
+#include <sys/timeb.h>
+#endif
+
+namespace FIX {
+
+DateTime DateTime::nowUtc() {
+#if defined(_POSIX_SOURCE) || defined(HAVE_GETTIMEOFDAY)
+  struct timeval tv;
+  gettimeofday(&tv, 0);
+  return fromUtcTimeT(tv.tv_sec, tv.tv_usec, 6);
+#elif defined(HAVE_FTIME)
+  timeb tb;
+  ftime(&tb);
+  return fromUtcTimeT(tb.time, tb.millitm);
+#else
+  return fromUtcTimeT(::time(0), 0);
+#endif
+}
+
+DateTime DateTime::nowLocal() {
+#if defined(_POSIX_SOURCE) || defined(HAVE_GETTIMEOFDAY)
+  struct timeval tv;
+  gettimeofday(&tv, 0);
+  return fromLocalTimeT(tv.tv_sec, tv.tv_usec, 6);
+#elif defined(HAVE_FTIME)
+  timeb tb;
+  ftime(&tb);
+  return fromLocalTimeT(tb.time, tb.millitm);
+#else
+  return fromLocalTimeT(::time(0), 0);
+#endif
+}
+
+} // namespace FIX