quickfix_ruby 1.14.3

data/ext/quickfix/FieldMap.cpp

@@ -0,0 +1,238 @@
+/****************************************************************************
+** 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 <iterator>
+#include <deque>
+
+namespace FIX
+{
+FieldMap::~FieldMap()
+{
+  clear();
+}
+
+FieldMap& FieldMap::operator=( const FieldMap& rhs )
+{
+  clear();
+
+  m_fields = rhs.m_fields;
+
+  Groups::const_iterator i;
+  for ( i = rhs.m_groups.begin(); i != rhs.m_groups.end(); ++i )
+  {
+    std::vector < FieldMap* > ::const_iterator j;
+    for ( j = i->second.begin(); j != i->second.end(); ++j )
+    {
+        FieldMap * pGroup = new FieldMap( **j );
+        m_groups[ i->first ].push_back( pGroup );
+    }
+  }
+
+  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 field, FieldMap * group, bool setCount )
+{
+    if( group == 0 )
+        return;
+
+    std::vector< FieldMap* >& vec = m_groups[ field ];
+    vec.push_back( group );
+
+    if( setCount )
+        setField( IntField( field, (int)vec.size() ) );
+}
+
+void FieldMap::replaceGroup( int num, int field, const FieldMap& group )
+{
+  Groups::const_iterator i = m_groups.find( field );
+  if ( i == m_groups.end() ) return;
+  if ( num <= 0 ) return;
+  if ( i->second.size() < ( unsigned ) num ) return;
+  *( *( i->second.begin() + ( num - 1 ) ) ) = group;
+}
+
+void FieldMap::removeGroup( int num, int field )
+{
+  Groups::iterator i = m_groups.find( field );
+  if ( i == m_groups.end() ) return;
+  if ( num <= 0 ) return;
+  std::vector< FieldMap* >& vector = i->second;
+  if ( vector.size() < ( unsigned ) num ) return;
+
+  std::vector< FieldMap* >::iterator iter = vector.begin();
+  std::advance( iter, ( num - 1 ) );
+
+  delete (*iter);
+  vector.erase( iter );
+
+  if( vector.size() == 0 )
+  {
+    m_groups.erase( field );
+    removeField( field );
+  }
+  else
+  {
+    IntField groupCount( field, (int)vector.size() );
+    setField( groupCount, true );
+  }
+}
+
+void FieldMap::removeGroup( int field )
+{
+  removeGroup( (int)groupCount(field), field );
+}
+
+void FieldMap::removeField( int field )
+{
+  Fields::iterator i = m_fields.find( field );
+  if ( i != m_fields.end() )
+    m_fields.erase( i );
+}
+
+bool FieldMap::hasGroup( int num, int field ) const
+{
+  return (int)groupCount(field) >= num;
+}
+
+bool FieldMap::hasGroup( int field ) const
+{
+  Groups::const_iterator i = m_groups.find( field );
+  return i != m_groups.end();
+}
+
+size_t FieldMap::groupCount( int field ) const
+{
+  Groups::const_iterator i = m_groups.find( field );
+  if( i == m_groups.end() )
+    return 0;
+  return i->second.size();
+}
+
+void FieldMap::clear()
+{
+  m_fields.clear();
+
+  Groups::iterator i;
+  for ( i = m_groups.begin(); i != m_groups.end(); ++i )
+  {
+    std::vector < FieldMap* > ::iterator j;
+    for ( j = i->second.begin(); j != i->second.end(); ++j )
+      delete *j;
+  }
+  m_groups.clear();
+}
+
+bool FieldMap::isEmpty()
+{
+  return m_fields.size() == 0;
+}
+
+size_t FieldMap::totalFields() const
+{
+  size_t result = m_fields.size();
+    
+  Groups::const_iterator i;
+  for ( i = m_groups.begin(); i != m_groups.end(); ++i )
+  {
+    std::vector < FieldMap* > ::const_iterator j;
+    for ( j = i->second.begin(); j != i->second.end(); ++j )
+      result += ( *j ) ->totalFields();
+  }
+  return result;
+}
+
+std::string& FieldMap::calculateString( std::string& result ) const
+{  
+  Fields::const_iterator i;
+  for ( i = m_fields.begin(); i != m_fields.end(); ++i )
+  {
+    result += i->second.getFixString();
+
+    // add groups if they exist
+    if( !m_groups.size() ) continue;
+    Groups::const_iterator j = m_groups.find( i->first );
+    if ( j == m_groups.end() ) continue;
+    std::vector < FieldMap* > ::const_iterator k;
+    for ( k = j->second.begin(); k != j->second.end(); ++k )
+      ( *k ) ->calculateString( result );
+  }
+  return result;
+}
+
+int FieldMap::calculateLength( int beginStringField,
+                               int bodyLengthField,
+                               int checkSumField ) const
+{
+  int result = 0;
+  Fields::const_iterator i;
+  for ( i = m_fields.begin(); i != m_fields.end(); ++i )
+  {
+    if ( i->first != beginStringField
+         && i->first != bodyLengthField
+         && i->first != checkSumField )
+    { result += i->second.getLength(); }
+  }
+
+  Groups::const_iterator j;
+  for ( j = m_groups.begin(); j != m_groups.end(); ++j )
+  {
+    std::vector < FieldMap* > ::const_iterator k;
+    for ( k = j->second.begin(); k != j->second.end(); ++k )
+      result += ( *k ) ->calculateLength();
+  }
+  return result;
+}
+
+int FieldMap::calculateTotal( int checkSumField ) const
+{
+  int result = 0;
+  Fields::const_iterator i;
+  for ( i = m_fields.begin(); i != m_fields.end(); ++i )
+  {
+    if ( i->first != checkSumField )
+      result += i->second.getTotal();
+  }
+
+  Groups::const_iterator j;
+  for ( j = m_groups.begin(); j != m_groups.end(); ++j )
+  {
+    std::vector < FieldMap* > ::const_iterator k;
+    for ( k = j->second.begin(); k != j->second.end(); ++k )
+      result += ( *k ) ->calculateTotal();
+  }
+  return result;
+}
+
+}

data/ext/quickfix/FieldMap.h

@@ -0,0 +1,244 @@
+/* -*- 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 "Field.h"
+#include "MessageSorters.h"
+#include "Exceptions.h"
+#include "Utility.h"
+#include <map>
+#include <vector>
+#include <sstream>
+#include <algorithm>
+
+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
+{
+public:
+#if defined(_MSC_VER) && _MSC_VER < 1300
+  typedef std::multimap < int, FieldBase, message_order > Fields;
+  typedef std::map < int, std::vector < FieldMap* >, std::less<int> > Groups;
+#else
+  typedef std::multimap < int, FieldBase, message_order, 
+                          ALLOCATOR<std::pair<const int,FieldBase> > > Fields;
+  typedef std::map < int, std::vector < FieldMap* >, std::less<int>, 
+                     ALLOCATOR<std::pair<const int, std::vector< FieldMap* > > > > Groups;
+#endif
+
+  typedef Fields::const_iterator iterator;
+  typedef iterator const_iterator;
+  typedef Groups::const_iterator g_iterator;
+  typedef Groups::const_iterator g_const_iterator;
+
+  FieldMap( const message_order& order =
+            message_order( message_order::normal ) )
+  : m_fields( order ) {}
+
+  FieldMap( const int order[] )
+  : m_fields( message_order(order) ) {}
+
+  FieldMap( const FieldMap& copy )
+  { *this = copy; }
+
+  virtual ~FieldMap();
+
+  FieldMap& operator=( const FieldMap& rhs );
+
+  /// Set a field without type checking
+  void setField( const FieldBase& field, bool overwrite = true )
+  throw( RepeatedTag )
+  {
+      if(!overwrite)
+          m_fields.insert( Fields::value_type( field.getField(), field ) );
+      else
+      {
+          Fields::iterator i = m_fields.find( field.getField() );
+          if( i == m_fields.end() )
+              m_fields.insert( Fields::value_type( field.getField(), field ) );
+          else
+              i->second = field;
+      }
+  }
+  /// Set a field without a field class
+  void setField( int field, const std::string& value )
+  throw( RepeatedTag, NoTagValue )
+  {
+    FieldBase fieldBase( field, value );
+    setField( fieldBase );
+  }
+
+  /// Get a field if set
+  bool getFieldIfSet( FieldBase& field ) const
+  {
+    Fields::const_iterator iter = m_fields.find( field.getField() );
+    if ( iter == m_fields.end() )
+      return false;
+    field = iter->second;
+    return true;
+  }
+
+  /// Get a field without type checking
+  FieldBase& getField( FieldBase& field )
+  const throw( FieldNotFound )
+  {
+    field = getFieldRef( field.getField() );
+    return field;
+  }
+
+  /// Get a field without a field class
+  const std::string& getField( int field )
+  const throw( FieldNotFound )
+  {
+    return getFieldRef( field ).getString();
+  }
+
+  /// Get direct access to a field through a reference
+  const FieldBase& getFieldRef( int field )
+  const throw( FieldNotFound )
+  {
+    Fields::const_iterator iter = m_fields.find( field );
+    if ( iter == m_fields.end() )
+      throw FieldNotFound( field );
+    return iter->second;
+  }
+
+  /// Get direct access to a field through a pointer
+  const FieldBase* const getFieldPtr( int field )
+  const throw( FieldNotFound )
+  {
+    return &getFieldRef( field );
+  }
+
+  /// Check to see if a field is set
+  bool isSetField( const FieldBase& field ) const
+  { return isSetField( field.getField() ); }
+  /// Check to see if a field is set by referencing its number
+  bool isSetField( int field ) const
+  { return m_fields.find( field ) != m_fields.end(); }
+
+  /// Remove a field. If field is not present, this is a no-op.
+  void removeField( int field );
+
+  /// Add a group.
+  void addGroup( int field, const FieldMap& group, bool setCount = true );
+
+  /// Acquire ownership of Group object
+  void addGroupPtr( int field, FieldMap * group, bool setCount = true );
+
+  /// Replace a specific instance of a group.
+  void replaceGroup( int num, int field, const FieldMap& group );
+
+  /// Get a specific instance of a group.
+  FieldMap& getGroup( int num, int field, FieldMap& group ) const
+  throw( FieldNotFound )
+  {
+    return group = getGroupRef( num, field );
+  }
+
+  /// Get direct access to a field through a reference
+  FieldMap& getGroupRef( int num, int field ) const
+  throw( FieldNotFound )
+  {
+    Groups::const_iterator i = m_groups.find( field );
+    if( i == m_groups.end() ) throw FieldNotFound( field );
+    if( num <= 0 ) throw FieldNotFound( field );
+    if( i->second.size() < (unsigned)num ) throw FieldNotFound( field );
+    return *( *(i->second.begin() + (num-1) ) );
+  }
+
+  /// Get direct access to a field through a pointer
+  FieldMap* getGroupPtr( int num, int field ) const
+  throw( FieldNotFound )
+  {
+    return &getGroupRef( num, field );
+  }
+
+  /// Remove a specific instance of a group.
+  void removeGroup( int num, int field );
+  /// Remove all instances of a group.
+  void removeGroup( int field );
+
+  /// Check to see any instance of a group exists
+  bool hasGroup( int field ) const;
+  /// Check to see if a specific instance of a group exists
+  bool hasGroup( int num, int field ) const;
+  /// Count the number of instance of a group
+  size_t groupCount( int field ) 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() const { return m_fields.begin(); }
+  iterator end() const { return m_fields.end(); }
+  g_iterator g_begin() const { return m_groups.begin(); }
+  g_iterator g_end() const { return m_groups.end(); }
+
+private:
+  Fields m_fields;
+  Groups m_groups;
+};
+/*! @} */
+}
+
+#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,46 @@
+/* -*- 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 <iostream>
+#include "FixFieldNumbers.h"
+
+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;
+  }
+}
+
+#endif //FIX_FIELDNUMBERS_BASE_H

data/ext/quickfix/FieldTypes.cpp

@@ -0,0 +1,64 @@
+/****************************************************************************
+** 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( HAVE_FTIME )
+    timeb tb;
+    ftime (&tb);
+    return fromUtcTimeT (tb.time, tb.millitm);
+#elif defined( _POSIX_SOURCE )
+    struct timeval tv;
+    gettimeofday (&tv, 0);
+    return fromUtcTimeT( tv.tv_sec, tv.tv_usec / 1000 );
+#else
+    return fromUtcTimeT( ::time (0), 0 );
+#endif
+}
+
+DateTime DateTime::nowLocal()
+{
+#if defined( HAVE_FTIME )
+    timeb tb;
+    ftime (&tb);
+    return fromLocalTimeT( tb.time, tb.millitm );
+#elif defined( _POSIX_SOURCE )
+    struct timeval tv;
+    gettimeofday (&tv, 0);
+    return fromLocalTimeT( tv.tv_sec, tv.tv_usec / 1000 );
+#else
+    return fromLocalTimeT( ::time (0), 0 );
+#endif
+}
+
+}