quickfix_ruby 1.14.3

data/ext/quickfix/DatabaseConnectionID.h

@@ -0,0 +1,105 @@
+/* -*- 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 <string>
+#include <map>
+
+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 );
+}
+}
+
+#endif

data/ext/quickfix/DatabaseConnectionPool.h

@@ -0,0 +1,91 @@
+/* -*- 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 <string>
+#include <map>
+
+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;
+};
+}
+
+#endif

data/ext/quickfix/Dictionary.cpp

@@ -0,0 +1,162 @@
+/****************************************************************************
+** 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
+throw( 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
+throw( 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
+throw( 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
+throw( 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
+throw( ConfigError, FieldConvertError )
+{
+  try
+  {
+    std::string value = getString(key);
+    if( value.size() < 2 ) throw FieldConvertError(0);
+    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;
+    if( value.size() < 2 ) throw FieldConvertError(0);
+  }
+  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;
+}
+}

data/ext/quickfix/Dictionary.h

@@ -0,0 +1,94 @@
+/* -*- 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 <map>
+#include <string>
+#include "Exceptions.h"
+
+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;
+
+  /// 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
+  throw( ConfigError, FieldConvertError );
+  /// Get a value as a int.
+  int getInt( const std::string& ) const
+  throw( ConfigError, FieldConvertError );
+  /// Get a value as a double.
+  double getDouble( const std::string& ) const
+  throw( ConfigError, FieldConvertError );
+  /// Get a value as a bool
+  bool getBool( const std::string& ) const
+  throw( ConfigError, FieldConvertError );
+  /// Get a value as a day of week
+  int getDay( const std::string& ) const
+  throw( 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;
+};
+/*! @} */
+}
+
+#endif //FIX_DICTIONARY_H

data/ext/quickfix/Event.h

@@ -0,0 +1,95 @@
+/* -*- 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 <pthread.h>
+#include <cmath>
+#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
+};
+}
+
+#endif