quickfix_ruby 1.14.3.1 → 1.15.1

data/ext/quickfix/FieldMap.cpp

@@ -30,6 +30,30 @@
 
 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()
 {
   clear();
@@ -40,6 +64,7 @@ FieldMap& FieldMap::operator=( const FieldMap& rhs )
   clear();
 
   m_fields = rhs.m_fields;
+  m_order = rhs.m_order;
 
   Groups::const_iterator i;
   for ( i = rhs.m_groups.begin(); i != rhs.m_groups.end(); ++i )
@@ -99,24 +124,38 @@ void FieldMap::removeGroup( int num, int field )
 
   if( vector.size() == 0 )
   {
-    m_groups.erase( field );
+    m_groups.erase( i );
     removeField( field );
   }
   else
   {
     IntField groupCount( field, (int)vector.size() );
-    setField( groupCount, true );
+    setField( groupCount );
   }
 }
 
 void FieldMap::removeGroup( int field )
 {
-  removeGroup( (int)groupCount(field), field );
+  Groups::iterator i = m_groups.find( field );
+  if ( i == m_groups.end() ) return;
+
+  removeField( field );
+
+  std::vector< FieldMap* > tmp;
+  tmp.swap( i->second );
+
+  m_groups.erase( i );
+
+  while ( !tmp.empty() )
+  {
+    delete tmp.back();
+    tmp.pop_back();
+  }
 }
 
 void FieldMap::removeField( int field )
 {
-  Fields::iterator i = m_fields.find( field );
+  Fields::iterator i = findTag( field );
   if ( i != m_fields.end() )
     m_fields.erase( i );
 }
@@ -156,7 +195,7 @@ void FieldMap::clear()
 
 bool FieldMap::isEmpty()
 {
-  return m_fields.size() == 0;
+  return m_fields.empty();
 }
 
 size_t FieldMap::totalFields() const
@@ -178,11 +217,11 @@ 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();
+    result += i->getFixString();
 
     // add groups if they exist
     if( !m_groups.size() ) continue;
-    Groups::const_iterator j = m_groups.find( i->first );
+    Groups::const_iterator j = m_groups.find( i->getTag() );
     if ( j == m_groups.end() ) continue;
     std::vector < FieldMap* > ::const_iterator k;
     for ( k = j->second.begin(); k != j->second.end(); ++k )
@@ -199,10 +238,11 @@ int FieldMap::calculateLength( int beginStringField,
   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(); }
+    int tag = i->getTag();
+    if ( tag != beginStringField
+         && tag != bodyLengthField
+         && tag != checkSumField )
+    { result += i->getLength(); }
   }
 
   Groups::const_iterator j;
@@ -221,8 +261,8 @@ int FieldMap::calculateTotal( int checkSumField ) const
   Fields::const_iterator i;
   for ( i = m_fields.begin(); i != m_fields.end(); ++i )
   {
-    if ( i->first != checkSumField )
-      result += i->second.getTotal();
+    if ( i->getTag() != checkSumField )
+      result += i->getTotal();
   }
 
   Groups::const_iterator j;

data/ext/quickfix/FieldMap.h

@@ -45,31 +45,68 @@ namespace FIX
  */
 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:
-#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>, 
+
+  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;
-#endif
 
-  typedef Fields::const_iterator iterator;
-  typedef iterator const_iterator;
-  typedef Groups::const_iterator g_iterator;
+  typedef Fields::iterator iterator;
+  typedef Fields::const_iterator const_iterator;
+  typedef Groups::iterator g_iterator;
   typedef Groups::const_iterator g_const_iterator;
 
   FieldMap( const message_order& order =
-            message_order( message_order::normal ) )
-  : m_fields( order ) {}
+            message_order( message_order::normal ) );
 
-  FieldMap( const int order[] )
-  : m_fields( message_order(order) ) {}
+  FieldMap( const int order[] );
 
-  FieldMap( const FieldMap& copy )
-  { *this = copy; }
+  FieldMap( const FieldMap& copy );
 
   virtual ~FieldMap();
 
@@ -79,32 +116,39 @@ public:
   void setField( const FieldBase& field, bool overwrite = true )
   throw( RepeatedTag )
   {
-      if(!overwrite)
-          m_fields.insert( Fields::value_type( field.getField(), field ) );
+    if( !overwrite )
+    {
+      addField( field );
+    }
+    else
+    {
+      Fields::iterator i = findTag( field.getTag() );
+      if( i == m_fields.end() )
+      {
+        addField( 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;
+        i->setString( field.getString() );
       }
+    }
   }
+
   /// Set a field without a field class
-  void setField( int field, const std::string& value )
+  void setField( int tag, const std::string& value )
   throw( RepeatedTag, NoTagValue )
   {
-    FieldBase fieldBase( field, value );
+    FieldBase fieldBase( tag, value );
     setField( fieldBase );
   }
 
   /// Get a field if set
   bool getFieldIfSet( FieldBase& field ) const
   {
-    Fields::const_iterator iter = m_fields.find( field.getField() );
+    Fields::const_iterator iter = findTag( field.getTag() );
     if ( iter == m_fields.end() )
       return false;
-    field = iter->second;
+    field = (*iter);
     return true;
   }
 
@@ -112,89 +156,89 @@ public:
   FieldBase& getField( FieldBase& field )
   const throw( FieldNotFound )
   {
-    field = getFieldRef( field.getField() );
+    field = getFieldRef( field.getTag() );
     return field;
   }
 
   /// Get a field without a field class
-  const std::string& getField( int field )
+  const std::string& getField( int tag )
   const throw( FieldNotFound )
   {
-    return getFieldRef( field ).getString();
+    return getFieldRef( tag ).getString();
   }
 
   /// Get direct access to a field through a reference
-  const FieldBase& getFieldRef( int field )
+  const FieldBase& getFieldRef( int tag )
   const throw( FieldNotFound )
   {
-    Fields::const_iterator iter = m_fields.find( field );
+    Fields::const_iterator iter = findTag( tag );
     if ( iter == m_fields.end() )
-      throw FieldNotFound( field );
-    return iter->second;
+      throw FieldNotFound( tag );
+    return (*iter);
   }
 
   /// Get direct access to a field through a pointer
-  const FieldBase* const getFieldPtr( int field )
+  const FieldBase* const getFieldPtr( int tag )
   const throw( FieldNotFound )
   {
-    return &getFieldRef( field );
+    return &getFieldRef( tag );
   }
 
   /// Check to see if a field is set
   bool isSetField( const FieldBase& field ) const
-  { return isSetField( field.getField() ); }
+  { return isSetField( field.getTag() ); }
   /// 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(); }
+  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 field );
+  void removeField( int tag );
 
   /// Add a group.
-  void addGroup( int field, const FieldMap& group, bool setCount = true );
+  void addGroup( int tag, const FieldMap& group, bool setCount = true );
 
   /// Acquire ownership of Group object
-  void addGroupPtr( int field, FieldMap * group, bool setCount = true );
+  void addGroupPtr( int tag, FieldMap * group, bool setCount = true );
 
   /// Replace a specific instance of a group.
-  void replaceGroup( int num, int field, const FieldMap& group );
+  void replaceGroup( int num, int tag, const FieldMap& group );
 
   /// Get a specific instance of a group.
-  FieldMap& getGroup( int num, int field, FieldMap& group ) const
+  FieldMap& getGroup( int num, int tag, FieldMap& group ) const
   throw( FieldNotFound )
   {
-    return group = getGroupRef( num, field );
+    return group = getGroupRef( num, tag );
   }
 
   /// Get direct access to a field through a reference
-  FieldMap& getGroupRef( int num, int field ) const
+  FieldMap& getGroupRef( int num, int tag ) 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 );
+    Groups::const_iterator i = m_groups.find( tag );
+    if( i == m_groups.end() ) throw FieldNotFound( tag );
+    if( num <= 0 ) throw FieldNotFound( tag );
+    if( i->second.size() < (unsigned)num ) throw FieldNotFound( tag );
     return *( *(i->second.begin() + (num-1) ) );
   }
 
   /// Get direct access to a field through a pointer
-  FieldMap* getGroupPtr( int num, int field ) const
+  FieldMap* getGroupPtr( int num, int tag ) const
   throw( FieldNotFound )
   {
-    return &getGroupRef( num, field );
+    return &getGroupRef( num, tag );
   }
 
   /// Remove a specific instance of a group.
-  void removeGroup( int num, int field );
+  void removeGroup( int num, int tag );
   /// Remove all instances of a group.
-  void removeGroup( int field );
+  void removeGroup( int tag );
 
   /// Check to see any instance of a group exists
-  bool hasGroup( int field ) const;
+  bool hasGroup( int tag ) const;
   /// Check to see if a specific instance of a group exists
-  bool hasGroup( int num, int field ) const;
+  bool hasGroup( int num, int tag ) const;
   /// Count the number of instance of a group
-  size_t groupCount( int field ) const;
+  size_t groupCount( int tag ) const;
 
   /// Clear all fields from the map
   void clear();
@@ -211,14 +255,108 @@ public:
 
   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(); }
+  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 iter = std::find_if( m_fields.rbegin(), m_fields.rend(), finder( tag ) );
+    if( iter == m_fields.rend() )
+      throw FieldNotFound( tag );
+
+    return *iter;
+  }
+
+  // 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 iter = std::lower_bound( begin, end, tag, sorter( m_order ) );
+    if( iter != end &&
+        iter->getTag() == tag )
+    {
+      return iter;
+    }
+
+    return end;
+  }
+
+  Fields::iterator findPositionFor( int tag )
+  {
+    if( m_fields.empty() )
+      return m_fields.end();
+
+    const FieldBase& last = m_fields.back();
+    if( m_order( last.getTag(), tag ) ||
+        last.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;
 };
 /*! @} */
 }