quickfix_ruby 1.14.3.1 → 1.15.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 58371578252b4082a68d2cd3f842349de57003f3
-  data.tar.gz: aa6278870deec6cedffb3202d93a9f8f64cc1d2e
+  metadata.gz: df5047d3c81911491ebbf1d707c5ac0385d4a39d
+  data.tar.gz: 1558e66c08562f551af3d1d5a7589d09b6018ec3
 SHA512:
-  metadata.gz: 8c370996d33ff6f659df2803b61581bcd1d1d22c080b6e41b8eec322ac01b29f67bb0d2d3d50433d37700e65085b7c7a203f19da0066ad9c167a3f97c5f26aee
-  data.tar.gz: 643191c64ec5026fa6b0aca09ece4c46e3614cef586db704d811d873b0c01b0fb000896f8d0d7c1ebdf14ef4c40550e3d212eb147b8f08e64944c55b588f416d
+  metadata.gz: 7923a274db5a89bbd5e730d6bee308c4d9a7a853b52938f4f5a2a1b20cac2a9891ee0b0371be75895c5853a7a48ab3c613608d8fedac9bf3e80b3465dfb85de5
+  data.tar.gz: 8c0fd54ae7116b8b55d2ce21670ecab11dea76a204cbf5c4aa68901f72271e4ec1c5b1c393b17e39fe2b52c5d9b1adfee23e71c69e20655d2a8ed162dfcf43c0

data/ext/quickfix/Acceptor.h

@@ -114,7 +114,9 @@ private:
   SessionIDs m_sessionIDs;
   Application& m_application;
   MessageStoreFactory& m_messageStoreFactory;
+protected:
   SessionSettings m_settings;
+private:
   LogFactory* m_pLogFactory;
   Log* m_pLog;
   NullLog m_nullLog;

data/ext/quickfix/AtomicCount.h

@@ -22,7 +22,11 @@
 #ifndef ATOMIC_COUNT
 #define ATOMIC_COUNT
 
+#include "Utility.h"
+
+#if defined(__SUNPRO_CC) ||  defined(__TOS_AIX__)
 #include "Mutex.h"
+#endif
 
 namespace FIX
 {
@@ -55,7 +59,7 @@ typedef boost::detail::atomic_count atomic_count;
 
     operator long() const
     {
-      return static_cast<long const volatile &>( m_counter );
+      return ::InterlockedExchangeAdd(const_cast<long volatile *>( &m_counter ), 0 );
     }
 
   private:
@@ -66,30 +70,75 @@ typedef boost::detail::atomic_count atomic_count;
     long volatile m_counter;
   };
 
+#elif defined(__SUNPRO_CC) ||  defined(__TOS_AIX__)
+
+// general purpose atomic counter using mutexes
+class atomic_count
+{
+public:
+  explicit atomic_count( long v ): m_counter( v )
+  {
+  }
+
+  long operator++()
+  {
+    Locker _lock(m_mutex);
+    return ++m_counter;
+  }
+
+  long operator--()
+  {
+    Locker _lock(m_mutex);
+    return --m_counter;
+  }
+
+  operator long() const
+  {
+    return static_cast<long const volatile &>( m_counter );
+  }
+
+private:
+
+  atomic_count( atomic_count const & );
+  atomic_count & operator=( atomic_count const & );
+
+  Mutex m_mutex;
+  long m_counter;
+};
+
 #else
-  // general purpose atomic counter using mutexes
+
+  //
+  //  boost/detail/atomic_count_gcc_x86.hpp
+  //
+  //  atomic_count for g++ on 486+/AMD64
+  //
+  //  Copyright 2007 Peter Dimov
+  //
+  //  Distributed under the Boost Software License, Version 1.0. (See
+  //  accompanying file LICENSE_1_0.txt or copy at
+  //  http://www.boost.org/LICENSE_1_0.txt)
+  //
+
   class atomic_count
   {
   public:
-    explicit atomic_count( long v ): m_counter( v )
-    {
-    }
+
+    explicit atomic_count( long v ) : value_(static_cast<int>(v)) {}
 
     long operator++()
     {
-      Locker _lock(m_mutex);
-      return ++m_counter;
+      return atomic_exchange_and_add( &value_, 1 ) + 1;
     }
 
     long operator--()
     {
-      Locker _lock(m_mutex);
-      return --m_counter;
+      return atomic_exchange_and_add( &value_, -1 ) - 1;
     }
 
     operator long() const
     {
-      return static_cast<long const volatile &>( m_counter );
+      return atomic_exchange_and_add( &value_, 0 );
     }
 
   private:
@@ -97,8 +146,29 @@ typedef boost::detail::atomic_count atomic_count;
     atomic_count( atomic_count const & );
     atomic_count & operator=( atomic_count const & );
 
-    Mutex m_mutex;
-    long m_counter;
+    mutable int value_;
+
+  private:
+
+    static int atomic_exchange_and_add(int * pw, int dv)
+    {
+      // int r = *pw;
+      // *pw += dv;
+      // return r;
+
+      int r;
+
+      __asm__ __volatile__
+        (
+          "lock\n\t"
+          "xadd %1, %0":
+          "+m"(*pw), "=r"(r) : // outputs (%0, %1)
+          "1"(dv) : // inputs (%2 == %1)
+          "memory", "cc" // clobbers
+        );
+
+      return r;
+    }
   };
 
 #endif

data/ext/quickfix/DOMDocument.h

@@ -26,9 +26,11 @@
 #include <map>
 #include <iostream>
 #include <memory>
+#include "Utility.h"
 
 namespace FIX
 {
+  #include "Utility.h"
   /// Interface that represents attribute from underlying XML parser.
   class DOMAttributes
   {
@@ -40,7 +42,7 @@ namespace FIX
     virtual bool get( const std::string&, std::string& ) = 0;
     virtual map toMap() = 0;
   };
-  typedef std::auto_ptr<DOMAttributes> DOMAttributesPtr;
+  typedef SmartPtr<DOMAttributes> DOMAttributesPtr;
 
   /// Interface that represents node from underlying XML parser.
   class DOMNode
@@ -48,13 +50,13 @@ namespace FIX
   public:
     virtual ~DOMNode() {}
 
-    virtual std::auto_ptr<DOMNode> getFirstChildNode() = 0;
-    virtual std::auto_ptr<DOMNode> getNextSiblingNode() = 0;
-    virtual std::auto_ptr<DOMAttributes> getAttributes() = 0;
+    virtual SmartPtr<DOMNode> getFirstChildNode() = 0;
+    virtual SmartPtr<DOMNode> getNextSiblingNode() = 0;
+    virtual SmartPtr<DOMAttributes> getAttributes() = 0;
     virtual std::string getName() = 0;
     virtual std::string getText() = 0;
   };
-  typedef std::auto_ptr<DOMNode> DOMNodePtr;
+  typedef SmartPtr<DOMNode> DOMNodePtr;
 
   /// Interface that represents document of underlying XML parser.
   class DOMDocument
@@ -66,9 +68,9 @@ namespace FIX
     virtual bool load( const std::string& ) = 0;
     virtual bool xml( std::ostream& ) = 0;
 
-    virtual std::auto_ptr<DOMNode> getNode( const std::string& ) = 0;
+    virtual SmartPtr<DOMNode> getNode( const std::string& ) = 0;
   };
-  typedef std::auto_ptr<DOMDocument> DOMDocumentPtr;
+  typedef SmartPtr<DOMDocument> DOMDocumentPtr;
 }
 
 #endif

data/ext/quickfix/DataDictionary.cpp

@@ -40,22 +40,21 @@ namespace FIX
 {
 DataDictionary::DataDictionary()
 : m_hasVersion( false ), m_checkFieldsOutOfOrder( true ),
-  m_checkFieldsHaveValues( true ), m_checkUserDefinedFields( true )
+  m_checkFieldsHaveValues( true ), m_checkUserDefinedFields( true ), m_allowUnknownMessageFields( false ), m_storeMsgFieldsOrder(false)
 {}
 
-DataDictionary::DataDictionary( std::istream& stream )
+DataDictionary::DataDictionary( std::istream& stream, bool preserveMsgFldsOrder )
 throw( ConfigError )
 : m_hasVersion( false ), m_checkFieldsOutOfOrder( true ),
-  m_checkFieldsHaveValues( true ), m_checkUserDefinedFields( true )
+  m_checkFieldsHaveValues( true ), m_checkUserDefinedFields( true ), m_allowUnknownMessageFields( false ), m_storeMsgFieldsOrder(preserveMsgFldsOrder)
 {
   readFromStream( stream );
 }
 
-DataDictionary::DataDictionary( const std::string& url )
+DataDictionary::DataDictionary( const std::string& url, bool preserveMsgFldsOrder )
 throw( ConfigError )
 : m_hasVersion( false ), m_checkFieldsOutOfOrder( true ),
-  m_checkFieldsHaveValues( true ), m_checkUserDefinedFields( true ),
-  m_orderedFieldsArray(0)
+  m_checkFieldsHaveValues( true ), m_checkUserDefinedFields( true ), m_allowUnknownMessageFields( false ), m_storeMsgFieldsOrder(preserveMsgFldsOrder), m_orderedFieldsArray(0)
 {
   readFromURL( url );
 }
@@ -83,7 +82,9 @@ DataDictionary& DataDictionary::operator=( const DataDictionary& rhs )
   m_hasVersion = rhs.m_hasVersion;
   m_checkFieldsOutOfOrder = rhs.m_checkFieldsOutOfOrder;
   m_checkFieldsHaveValues = rhs.m_checkFieldsHaveValues;
+  m_storeMsgFieldsOrder = rhs.m_storeMsgFieldsOrder;
   m_checkUserDefinedFields = rhs.m_checkUserDefinedFields;
+  m_allowUnknownMessageFields = rhs.m_allowUnknownMessageFields;
   m_beginString = rhs.m_beginString;
   m_messageFields = rhs.m_messageFields;
   m_requiredFields = rhs.m_requiredFields;
@@ -99,6 +100,11 @@ DataDictionary& DataDictionary::operator=( const DataDictionary& rhs )
   m_names = rhs.m_names;
   m_valueNames = rhs.m_valueNames;
   m_dataFields = rhs.m_dataFields;
+  m_headerOrderedFields = rhs.m_headerOrderedFields;
+  m_headerOrder = rhs.m_headerOrder;
+  m_trailerOrderedFields = rhs.m_trailerOrderedFields;
+  m_trailerOrder = rhs.m_trailerOrder;
+  m_messageOrderedFields = rhs.m_messageOrderedFields;
 
   FieldToGroup::const_iterator i = rhs.m_groups.begin();
   for ( ; i != rhs.m_groups.end(); ++i )
@@ -121,7 +127,15 @@ throw( FIX::Exception )
 {  
   const Header& header = message.getHeader();
   const BeginString& beginString = FIELD_GET_REF( header, BeginString );
+#ifdef HAVE_EMX
+  const std::string & msgType = message.getSubMessageType();
+  if (msgType.empty())
+  {
+    throw InvalidMessageType("empty subMsgType, check Tag 9426/MESSAGE_ID");
+  }
+#else
   const MsgType& msgType = FIELD_GET_REF( header, MsgType );
+#endif
   if ( pSessionDD != 0 && pSessionDD->m_hasVersion )
   {
     if( pSessionDD->getVersion() != beginString )
@@ -160,11 +174,11 @@ void DataDictionary::iterate( const FieldMap& map, const MsgType& msgType ) cons
 {
   int lastField = 0;
 
-  FieldMap::iterator i;
+  FieldMap::const_iterator i;
   for ( i = map.begin(); i != map.end(); ++i )
   {
-    const FieldBase& field = i->second;
-    if( i != map.begin() && (field.getField() == lastField) )
+    const FieldBase& field = (*i);
+    if( i != map.begin() && (field.getTag() == lastField) )
       throw RepeatedTag( lastField );
     checkHasValue( field );
 
@@ -184,14 +198,14 @@ void DataDictionary::iterate( const FieldMap& map, const MsgType& msgType ) cons
         checkGroupCount( field, map, msgType );
       }
     }
-    lastField = field.getField();
+    lastField = field.getTag();
   }
 }
 
 void DataDictionary::readFromURL( const std::string& url )
 throw( ConfigError )
 {
-  DOMDocumentPtr pDoc = DOMDocumentPtr(new PUGIXML_DOMDocument());
+  DOMDocumentPtr pDoc(new PUGIXML_DOMDocument());
 
   if(!pDoc->load(url))
     throw ConfigError(url + ": Could not parse data dictionary file");
@@ -209,7 +223,7 @@ throw( ConfigError )
 void DataDictionary::readFromStream( std::istream& stream )
 throw( ConfigError )
 {
-  DOMDocumentPtr pDoc = DOMDocumentPtr(new PUGIXML_DOMDocument());
+  DOMDocumentPtr pDoc(new PUGIXML_DOMDocument());
 
   if(!pDoc->load(stream))
     throw ConfigError("Could not parse data dictionary stream");
@@ -217,7 +231,7 @@ throw( ConfigError )
   readFromDocument( pDoc );
 }
 
-void DataDictionary::readFromDocument( DOMDocumentPtr pDoc )
+void DataDictionary::readFromDocument( const DOMDocumentPtr &pDoc )
 throw( ConfigError )
 {
   // VERSION
@@ -441,6 +455,55 @@ message_order const& DataDictionary::getOrderedFields() const
   return m_orderedFieldsArray;
 }
 
+message_order const& DataDictionary::getHeaderOrderedFields() const throw( ConfigError )
+{
+  if( m_headerOrder ) return m_headerOrder;
+
+  if (m_headerOrderedFields.size() == 0)
+    throw ConfigError("<Header> does not have a stored message order");
+
+  int * tmp = new int[m_headerOrderedFields.size() + 1];
+  int * i = tmp;
+
+  OrderedFields::const_iterator iter;
+  for( iter = m_headerOrderedFields.begin(); iter != m_headerOrderedFields.end(); *(i++) = *(iter++) ) {}
+  *i = 0;
+
+  m_headerOrder = message_order(tmp);
+  delete [] tmp;
+
+  return m_headerOrder;
+}
+
+message_order const& DataDictionary::getTrailerOrderedFields() const throw( ConfigError )
+{
+  if( m_trailerOrder ) return m_trailerOrder;
+
+  if (m_trailerOrderedFields.size() == 0)
+    throw ConfigError("<Trailer> does not have a stored message order");
+
+  int * tmp = new int[m_trailerOrderedFields.size() + 1];
+  int * i = tmp;
+
+  OrderedFields::const_iterator iter;
+  for( iter = m_trailerOrderedFields.begin(); iter != m_trailerOrderedFields.end(); *(i++) = *(iter++) ) {}
+  *i = 0;
+
+  m_trailerOrder = message_order(tmp);
+  delete [] tmp;
+
+  return m_trailerOrder;
+}
+
+const message_order &DataDictionary::getMessageOrderedFields(const std::string & msgType) const throw( ConfigError )
+{
+  MsgTypeToOrderedFields::const_iterator iter = m_messageOrderedFields.find(msgType);
+  if (iter == m_messageOrderedFields.end())
+    throw ConfigError("<Message> " + msgType + " does not have a stored message order");
+
+  return iter->second.getMessageOrder();
+}
+
 int DataDictionary::lookupXMLFieldNumber( DOMDocument* pDoc, DOMNode* pNode ) const
 {
   DOMAttributesPtr attrs = pNode->getAttributes();
@@ -474,7 +537,7 @@ int DataDictionary::addXMLComponentFields( DOMDocument* pDoc, DOMNode* pNode,
   DOMNodePtr pComponentNode =
     pDoc->getNode("/fix/components/component[@name='" + name + "']");
   if(pComponentNode.get() == 0)
-    throw ConfigError("Component not found");
+    throw ConfigError("Component not found: " + name);
 
   DOMNodePtr pComponentFieldNode = pComponentNode->getFirstChildNode();
   while(pComponentFieldNode.get())

data/ext/quickfix/DataDictionary.h

@@ -54,6 +54,46 @@ class DataDictionary
   typedef std::set < int > Fields;
   typedef std::map < int, bool > NonBodyFields;
   typedef std::vector< int > OrderedFields;
+
+  struct MessageFieldsOrderHolder
+  {
+    MessageFieldsOrderHolder()
+    {}
+
+    ~MessageFieldsOrderHolder()
+    {}
+
+    void push_back(int field)
+    {
+      m_orderedFlds.push_back(field);
+    }
+
+    const message_order & getMessageOrder() const
+    {
+      if (m_msgOrder)
+        return m_msgOrder;
+
+      int * tmp = new int[m_orderedFlds.size() + 1];
+      int * i = tmp;
+
+      OrderedFields::const_iterator iter;
+      for( iter = m_orderedFlds.begin(); iter != m_orderedFlds.end(); *(i++) = *(iter++) ) {}
+      *i = 0;
+
+      m_msgOrder = message_order(tmp);
+      delete [] tmp;
+
+      return m_msgOrder;
+    }
+
+  private:
+
+    mutable message_order  m_msgOrder;
+    OrderedFields m_orderedFlds;
+  };
+
+  typedef std::map<std::string, MessageFieldsOrderHolder > MsgTypeToOrderedFields;
+
   typedef message_order OrderedFieldsArray;
   typedef std::map < int, TYPE::Type > FieldTypes;
   typedef std::set < std::string > Values;
@@ -72,15 +112,18 @@ class DataDictionary
 public:
   DataDictionary();
   DataDictionary( const DataDictionary& copy );
-  DataDictionary( std::istream& stream ) throw( ConfigError );
-  DataDictionary( const std::string& url ) throw( ConfigError );
+  DataDictionary(std::istream& stream , bool preserveMsgFldsOrder = false) throw( ConfigError );
+  DataDictionary(const std::string& url , bool preserveMsgFldsOrder = false) throw( ConfigError );
   virtual ~DataDictionary();
 
   void readFromURL( const std::string& url ) throw( ConfigError );
-  void readFromDocument( DOMDocumentPtr pDoc ) throw( ConfigError );
+  void readFromDocument( const DOMDocumentPtr &pDoc ) throw( ConfigError );
   void readFromStream( std::istream& stream ) throw( ConfigError );
 
   message_order const& getOrderedFields() const;
+  message_order const& getHeaderOrderedFields() const throw( ConfigError );
+  message_order const& getTrailerOrderedFields() const throw( ConfigError );
+  message_order const& getMessageOrderedFields(const std::string & msgType) const throw( ConfigError );
 
   // storage functions
   void setVersion( const std::string& beginString )
@@ -152,6 +195,11 @@ public:
 
   void addMsgField( const std::string& msgType, int field )
   {
+    if (m_storeMsgFieldsOrder)
+    {
+      m_messageOrderedFields[ msgType ].push_back(field);
+    }
+
     m_messageFields[ msgType ].insert( field );
   }
 
@@ -164,6 +212,11 @@ public:
 
   void addHeaderField( int field, bool required )
   {
+    if (m_storeMsgFieldsOrder)
+    {
+      m_headerOrderedFields.push_back(field);
+    }
+
     m_headerFields[ field ] = required;
   }
 
@@ -174,6 +227,11 @@ public:
 
   void addTrailerField( int field, bool required )
   {
+    if (m_storeMsgFieldsOrder)
+    {
+      m_trailerOrderedFields.push_back(field);
+    }
+
     m_trailerFields[ field ] = required;
   }
 
@@ -303,6 +361,12 @@ public:
   { m_checkFieldsHaveValues = value; }
   void checkUserDefinedFields( bool value )
   { m_checkUserDefinedFields = value; }
+  void allowUnknownMsgFields( bool value )
+  { m_allowUnknownMessageFields = value; }
+  void preserveMessageFieldsOrder( bool value )
+  { m_storeMsgFieldsOrder = value; }
+  bool isMessageFieldsOrderPreserved() const
+  { return m_storeMsgFieldsOrder; }
 
   /// Validate a message.
   static void validate( const Message& message,
@@ -330,7 +394,9 @@ private:
   /// If we need to check for the tag in the dictionary
   bool shouldCheckTag( const FieldBase& field ) const
   {
-    if( !m_checkUserDefinedFields && field.getField() >= FIELD::UserMin )
+    if( m_allowUnknownMessageFields && field.getTag() < FIELD::UserMin )
+      return false;
+    else if( !m_checkUserDefinedFields && field.getTag() >= FIELD::UserMin )
       return false;
     else
       return true;
@@ -340,8 +406,8 @@ private:
   void checkValidTagNumber( const FieldBase& field ) const
   throw( InvalidTagNumber )
   {
-    if( m_fields.find( field.getField() ) == m_fields.end() )
-      throw InvalidTagNumber( field.getField() );
+    if( m_fields.find( field.getTag() ) == m_fields.end() )
+      throw InvalidTagNumber( field.getTag() );
   }
 
   void checkValidFormat( const FieldBase& field ) const
@@ -350,7 +416,7 @@ private:
     try
     {
       TYPE::Type type = TYPE::Unknown;
-      getFieldType( field.getField(), type );
+      getFieldType( field.getTag(), type );
       switch ( type )
       {
       case TYPE::String:
@@ -417,17 +483,17 @@ private:
       }
     }
     catch ( FieldConvertError& )
-    { throw IncorrectDataFormat( field.getField(), field.getString() ); }
+    { throw IncorrectDataFormat( field.getTag(), field.getString() ); }
   }
 
   void checkValue( const FieldBase& field ) const
   throw( IncorrectTagValue )
   {
-    if ( !hasFieldValue( field.getField() ) ) return ;
+    if ( !hasFieldValue( field.getTag() ) ) return ;
 
     const std::string& value = field.getString();
-    if ( !isFieldValue( field.getField(), value ) )
-      throw IncorrectTagValue( field.getField() );
+    if ( !isFieldValue( field.getTag(), value ) )
+      throw IncorrectTagValue( field.getTag() );
   }
 
   /// Check if a field has a value.
@@ -435,7 +501,7 @@ private:
   throw( NoTagValue )
   {
     if ( m_checkFieldsHaveValues && !field.getString().length() )
-      throw NoTagValue( field.getField() );
+      throw NoTagValue( field.getTag() );
   }
 
   /// Check if a field is in this message type.
@@ -443,8 +509,8 @@ private:
   ( const FieldBase& field, const MsgType& msgType ) const
   throw( TagNotDefinedForMessage )
   {
-    if ( !isMsgField( msgType, field.getField() ) )
-      throw TagNotDefinedForMessage( field.getField() );
+    if ( !isMsgField( msgType, field.getTag() ) )
+      throw TagNotDefinedForMessage( field.getTag() );
   }
 
   /// Check if group count matches number of groups in
@@ -452,7 +518,7 @@ private:
   ( const FieldBase& field, const FieldMap& fieldMap, const MsgType& msgType ) const
   throw( RepeatingGroupCountMismatch )
   {
-    int fieldNum = field.getField();
+    int fieldNum = field.getTag();
     if( isGroup(msgType, fieldNum) )
     {
       if( (int)fieldMap.groupCount(fieldNum)
@@ -492,7 +558,7 @@ private:
         throw RequiredTagMissing( *iF );
     }
 
-    FieldMap::g_iterator groups;
+    FieldMap::g_const_iterator groups;
     for( groups = body.g_begin(); groups != body.g_end(); ++groups )
     {
       int delim;
@@ -517,6 +583,9 @@ private:
   bool m_checkFieldsOutOfOrder;
   bool m_checkFieldsHaveValues;
   bool m_checkUserDefinedFields;
+  bool m_allowUnknownMessageFields;
+  bool m_storeMsgFieldsOrder;
+  
   BeginString m_beginString;
   MsgTypeToField m_messageFields;
   MsgTypeToField m_requiredFields;
@@ -533,6 +602,11 @@ private:
   ValueToName m_valueNames;
   FieldToGroup m_groups;
   MsgFields m_dataFields;
+  OrderedFields m_headerOrderedFields;
+  mutable OrderedFieldsArray m_headerOrder;
+  OrderedFields m_trailerOrderedFields;
+  mutable OrderedFieldsArray m_trailerOrder;
+  MsgTypeToOrderedFields m_messageOrderedFields;
 };
 }