quickfix_ruby 1.14.3

data/ext/quickfix/PostgreSQLLog.h

@@ -0,0 +1,144 @@
+/* -*- 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 HAVE_POSTGRESQL
+#error PostgreSQLLog.h included, but HAVE_POSTGRESQL not defined
+#endif
+
+#ifdef HAVE_POSTGRESQL
+#ifndef FIX_POSTGRESQLLOG_H
+#define FIX_POSTGRESQLLOG_H
+
+#ifdef _MSC_VER
+#pragma warning( disable : 4503 4355 4786 4290 )
+#endif
+
+#include "Log.h"
+#include "SessionSettings.h"
+#include "PostgreSQLConnection.h"
+#include <fstream>
+#include <string>
+
+namespace FIX
+{
+/// PostgreSQL based implementation of Log.
+class PostgreSQLLog : public Log
+{
+public:
+  PostgreSQLLog( const SessionID& s, const DatabaseConnectionID& d, PostgreSQLConnectionPool* p );
+  PostgreSQLLog( const DatabaseConnectionID& d, PostgreSQLConnectionPool* p );
+  PostgreSQLLog( const SessionID& s, const std::string& database, const std::string& user,
+                 const std::string& password, const std::string& host, short port );
+  PostgreSQLLog( const std::string& database, const std::string& user,
+                 const std::string& password, const std::string& host, short port );
+
+  ~PostgreSQLLog();
+
+  void clear();
+  void backup();
+  void setIncomingTable( const std::string& incomingTable )
+  { m_incomingTable = incomingTable; }
+  void setOutgoingTable( const std::string& outgoingTable )
+  { m_outgoingTable = outgoingTable; }
+  void setEventTable( const std::string& eventTable )
+  { m_eventTable = eventTable; }
+
+  void onIncoming( const std::string& value )
+  { insert( m_incomingTable, value ); }
+  void onOutgoing( const std::string& value )
+  { insert( m_outgoingTable, value ); }
+  void onEvent( const std::string& value )
+  { insert( m_eventTable, value ); }
+
+private:
+  void init();
+  void insert( const std::string& table, const std::string value );
+
+  std::string m_incomingTable;
+  std::string m_outgoingTable;
+  std::string m_eventTable;
+  PostgreSQLConnection* m_pConnection;
+  PostgreSQLConnectionPool* m_pConnectionPool;
+  SessionID* m_pSessionID;
+};
+
+/// Creates a MySQL based implementation of Log.
+class PostgreSQLLogFactory : public LogFactory
+{
+public:
+  static const std::string DEFAULT_DATABASE;
+  static const std::string DEFAULT_USER;
+  static const std::string DEFAULT_PASSWORD;
+  static const std::string DEFAULT_HOST;
+  static const short DEFAULT_PORT;
+
+  PostgreSQLLogFactory( const SessionSettings& settings )
+: m_settings( settings ), m_useSettings( true ) 
+  {
+    bool poolConnections = false;
+    try { poolConnections = settings.get().getBool(POSTGRESQL_LOG_USECONNECTIONPOOL); }
+    catch( ConfigError& ) {}
+
+    m_connectionPoolPtr = PostgreSQLConnectionPoolPtr
+      ( new PostgreSQLConnectionPool(poolConnections) );
+  }
+
+  PostgreSQLLogFactory( 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 ),
+  m_useSettings( false ) 
+  {
+    m_connectionPoolPtr = PostgreSQLConnectionPoolPtr
+      ( new PostgreSQLConnectionPool(false) );
+  }
+
+  PostgreSQLLogFactory()
+: m_database( DEFAULT_DATABASE ), m_user( DEFAULT_USER ), m_password( DEFAULT_PASSWORD ),
+  m_host( DEFAULT_HOST ), m_port( DEFAULT_PORT ), m_useSettings( false ) 
+  {
+    m_connectionPoolPtr = PostgreSQLConnectionPoolPtr
+      ( new PostgreSQLConnectionPool(false) );
+  }
+
+  Log* create();
+  Log* create( const SessionID& );
+  void destroy( Log* );
+private:
+  void init( const Dictionary& settings, std::string& database,
+             std::string& user, std::string& password,
+             std::string& host, short& port );
+
+  void initLog( const Dictionary& settings, PostgreSQLLog& log );
+
+  PostgreSQLConnectionPoolPtr m_connectionPoolPtr;
+  SessionSettings m_settings;
+  std::string m_database;
+  std::string m_user;
+  std::string m_password;
+  std::string m_host;
+  short m_port;
+  bool m_useSettings;
+};
+}
+
+#endif //FIX_POSTGRESQLLOG_H
+#endif //HAVE_POSTGRESQL

data/ext/quickfix/PostgreSQLStore.cpp

@@ -0,0 +1,334 @@
+/****************************************************************************
+** 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
+
+#ifdef HAVE_POSTGRESQL
+
+#include "PostgreSQLStore.h"
+#include "SessionID.h"
+#include "SessionSettings.h"
+#include "FieldConvertors.h"
+#include "Parser.h"
+#include "Utility.h"
+#include "strptime.h"
+#include <fstream>
+
+namespace FIX
+{
+
+const std::string PostgreSQLStoreFactory::DEFAULT_DATABASE = "quickfix";
+const std::string PostgreSQLStoreFactory::DEFAULT_USER = "postgres";
+const std::string PostgreSQLStoreFactory::DEFAULT_PASSWORD = "";
+const std::string PostgreSQLStoreFactory::DEFAULT_HOST = "localhost";
+const short PostgreSQLStoreFactory::DEFAULT_PORT = 0;
+
+PostgreSQLStore::PostgreSQLStore
+( const SessionID& s, const DatabaseConnectionID& d, PostgreSQLConnectionPool* p )
+: m_pConnectionPool( p ), m_sessionID( s )
+{
+  m_pConnection = m_pConnectionPool->create( d );
+  populateCache();
+}
+
+PostgreSQLStore::PostgreSQLStore
+( const SessionID& s, const std::string& database, const std::string& user,
+  const std::string& password, const std::string& host, short port )
+  : m_pConnectionPool( 0 ), m_sessionID( s )
+{
+  m_pConnection = new PostgreSQLConnection( database, user, password, host, port );
+  populateCache();
+}
+
+PostgreSQLStore::~PostgreSQLStore()
+{
+  if( m_pConnectionPool )
+    m_pConnectionPool->destroy( m_pConnection );
+  else
+    delete m_pConnection;
+}
+
+void PostgreSQLStore::populateCache()
+{
+  std::stringstream queryString;
+
+  queryString << "SELECT creation_time, incoming_seqnum, outgoing_seqnum FROM sessions WHERE "
+  << "beginstring=" << "'" << m_sessionID.getBeginString().getValue() << "' and "
+  << "sendercompid=" << "'" << m_sessionID.getSenderCompID().getValue() << "' and "
+  << "targetcompid=" << "'" << m_sessionID.getTargetCompID().getValue() << "' and "
+  << "session_qualifier=" << "'" << m_sessionID.getSessionQualifier() << "'";
+
+  PostgreSQLQuery query( queryString.str() );
+  if( !m_pConnection->execute(query) )
+    throw ConfigError( "No entries found for session in database" );
+
+  int rows = query.rows();
+  if( rows > 1 )
+    throw ConfigError( "Multiple entries found for session in database" );
+
+  if( rows == 1 )
+  {
+    struct tm time;
+    std::string sqlTime = query.getValue( 0, 0 );
+    strptime( sqlTime.c_str(), "%Y-%m-%d %H:%M:%S", &time );
+    m_cache.setCreationTime (UtcTimeStamp (&time));
+    m_cache.setNextTargetMsgSeqNum( atol( query.getValue( 0, 1 ) ) );
+    m_cache.setNextSenderMsgSeqNum( atol( query.getValue( 0, 2 ) ) );
+  }
+  else
+  {
+    UtcTimeStamp time = m_cache.getCreationTime();
+    char sqlTime[ 20 ];
+    int year, month, day, hour, minute, second, millis;
+    time.getYMD (year, month, day);
+    time.getHMS (hour, minute, second, millis);
+    STRING_SPRINTF( sqlTime, "%d-%02d-%02d %02d:%02d:%02d",
+             year, month, day, hour, minute, second );
+    std::stringstream queryString2;
+    queryString2 << "INSERT INTO sessions (beginstring, sendercompid, targetcompid, session_qualifier,"
+    << "creation_time, incoming_seqnum, outgoing_seqnum) VALUES("
+    << "'" << m_sessionID.getBeginString().getValue() << "',"
+    << "'" << m_sessionID.getSenderCompID().getValue() << "',"
+    << "'" << m_sessionID.getTargetCompID().getValue() << "',"
+    << "'" << m_sessionID.getSessionQualifier() << "',"
+    << "'" << sqlTime << "',"
+    << m_cache.getNextTargetMsgSeqNum() << ","
+    << m_cache.getNextSenderMsgSeqNum() << ")";
+
+    PostgreSQLQuery query2( queryString2.str() );
+    if( !m_pConnection->execute(query2) )
+      throw ConfigError( "Unable to create session in database" );
+  }
+}
+
+MessageStore* PostgreSQLStoreFactory::create( const SessionID& s )
+{
+  if( m_useSettings )
+    return create( s, m_settings.get(s) );
+  else if( m_useDictionary )
+    return create( s, m_dictionary );
+  else
+  {
+    DatabaseConnectionID id( m_database, m_user, m_password, m_host, m_port );
+    return new PostgreSQLStore( s, id, m_connectionPoolPtr.get() );
+  }
+}
+
+MessageStore* PostgreSQLStoreFactory::create( const SessionID& s, const Dictionary& settings )
+{
+  std::string database = DEFAULT_DATABASE;
+  std::string user = DEFAULT_USER;
+  std::string password = DEFAULT_PASSWORD;
+  std::string host = DEFAULT_HOST;
+  short port = DEFAULT_PORT;
+
+  try { database = settings.getString( POSTGRESQL_STORE_DATABASE ); }
+  catch( ConfigError& ) {}
+
+  try { user = settings.getString( POSTGRESQL_STORE_USER ); }
+  catch( ConfigError& ) {}
+
+  try { password = settings.getString( POSTGRESQL_STORE_PASSWORD ); }
+  catch( ConfigError& ) {}
+
+  try { host = settings.getString( POSTGRESQL_STORE_HOST ); }
+  catch( ConfigError& ) {}
+
+  try { port = ( short ) settings.getInt( POSTGRESQL_STORE_PORT ); }
+  catch( ConfigError& ) {}
+
+  DatabaseConnectionID id( database, user, password, host, port );
+  return new PostgreSQLStore( s, id, m_connectionPoolPtr.get() );
+}
+
+void PostgreSQLStoreFactory::destroy( MessageStore* pStore )
+{
+  delete pStore;
+}
+
+bool PostgreSQLStore::set( int msgSeqNum, const std::string& msg )
+throw ( IOException )
+{
+  char* msgCopy = new char[ (msg.size() * 2) + 1 ];
+  PQescapeString( msgCopy, msg.c_str(), msg.size() );
+
+  std::stringstream queryString;
+  queryString << "INSERT INTO messages "
+  << "(beginstring, sendercompid, targetcompid, session_qualifier, msgseqnum, message) "
+  << "VALUES ("
+  << "'" << m_sessionID.getBeginString().getValue() << "',"
+  << "'" << m_sessionID.getSenderCompID().getValue() << "',"
+  << "'" << m_sessionID.getTargetCompID().getValue() << "',"
+  << "'" << m_sessionID.getSessionQualifier() << "',"
+  << msgSeqNum << ","
+  << "'" << msgCopy << "')";
+
+  delete [] msgCopy;
+
+  PostgreSQLQuery query( queryString.str() );
+  if( !m_pConnection->execute(query) )
+  {
+    std::stringstream queryString2;
+    queryString2 << "UPDATE messages SET message='" << msg << "' WHERE "
+    << "beginstring=" << "'" << m_sessionID.getBeginString().getValue() << "' and "
+    << "sendercompid=" << "'" << m_sessionID.getSenderCompID().getValue() << "' and "
+    << "targetcompid=" << "'" << m_sessionID.getTargetCompID().getValue() << "' and "
+    << "session_qualifier=" << "'" << m_sessionID.getSessionQualifier() << "' and "
+    << "msgseqnum=" << msgSeqNum;
+    PostgreSQLQuery query2( queryString2.str() );
+    if( !m_pConnection->execute(query2) )
+      query2.throwException();
+  }
+
+  return true;
+}
+
+void PostgreSQLStore::get( int begin, int end,
+                      std::vector < std::string > & result ) const
+throw ( IOException )
+{
+  result.clear();
+  std::stringstream queryString;
+  queryString << "SELECT message FROM messages WHERE "
+  << "beginstring=" << "'" << m_sessionID.getBeginString().getValue() << "' and "
+  << "sendercompid=" << "'" << m_sessionID.getSenderCompID().getValue() << "' and "
+  << "targetcompid=" << "'" << m_sessionID.getTargetCompID().getValue() << "' and "
+  << "session_qualifier=" << "'" << m_sessionID.getSessionQualifier() << "' and "
+  << "msgseqnum>=" << begin << " and " << "msgseqnum<=" << end << " "
+  << "ORDER BY msgseqnum";
+
+  PostgreSQLQuery query( queryString.str() );
+  if( !m_pConnection->execute(query) )
+    query.throwException();
+
+  int rows = query.rows();
+  for( int row = 0; row < rows; row++ )
+    result.push_back( query.getValue( row, 0 ) );
+}
+
+int PostgreSQLStore::getNextSenderMsgSeqNum() const throw ( IOException )
+{
+  return m_cache.getNextSenderMsgSeqNum();
+}
+
+int PostgreSQLStore::getNextTargetMsgSeqNum() const throw ( IOException )
+{
+  return m_cache.getNextTargetMsgSeqNum();
+}
+
+void PostgreSQLStore::setNextSenderMsgSeqNum( int value ) throw ( IOException )
+{
+  std::stringstream queryString;
+  queryString << "UPDATE sessions SET outgoing_seqnum=" << value << " WHERE "
+  << "beginstring=" << "'" << m_sessionID.getBeginString().getValue() << "' and "
+  << "sendercompid=" << "'" << m_sessionID.getSenderCompID().getValue() << "' and "
+  << "targetcompid=" << "'" << m_sessionID.getTargetCompID().getValue() << "' and "
+  << "session_qualifier=" << "'" << m_sessionID.getSessionQualifier() << "'";
+
+  PostgreSQLQuery query( queryString.str() );
+  if( !m_pConnection->execute(query) )
+    query.throwException();
+
+  m_cache.setNextSenderMsgSeqNum( value );
+}
+
+void PostgreSQLStore::setNextTargetMsgSeqNum( int value ) throw ( IOException )
+{
+  std::stringstream queryString;
+  queryString << "UPDATE sessions SET incoming_seqnum=" << value << " WHERE "
+  << "beginstring=" << "'" << m_sessionID.getBeginString().getValue() << "' and "
+  << "sendercompid=" << "'" << m_sessionID.getSenderCompID().getValue() << "' and "
+  << "targetcompid=" << "'" << m_sessionID.getTargetCompID().getValue() << "' and "
+  << "session_qualifier=" << "'" << m_sessionID.getSessionQualifier() << "'";
+
+  PostgreSQLQuery query( queryString.str() );
+  if( !m_pConnection->execute(query) )
+    query.throwException();
+
+  m_cache.setNextTargetMsgSeqNum( value );
+}
+
+void PostgreSQLStore::incrNextSenderMsgSeqNum() throw ( IOException )
+{
+  m_cache.incrNextSenderMsgSeqNum();
+  setNextSenderMsgSeqNum( m_cache.getNextSenderMsgSeqNum() );
+}
+
+void PostgreSQLStore::incrNextTargetMsgSeqNum() throw ( IOException )
+{
+  m_cache.incrNextTargetMsgSeqNum();
+  setNextTargetMsgSeqNum( m_cache.getNextTargetMsgSeqNum() );
+}
+
+UtcTimeStamp PostgreSQLStore::getCreationTime() const throw ( IOException )
+{
+  return m_cache.getCreationTime();
+}
+
+void PostgreSQLStore::reset() throw ( IOException )
+{
+  std::stringstream queryString;
+  queryString << "DELETE FROM messages WHERE "
+  << "beginstring=" << "'" << m_sessionID.getBeginString().getValue() << "' and "
+  << "sendercompid=" << "'" << m_sessionID.getSenderCompID().getValue() << "' and "
+  << "targetcompid=" << "'" << m_sessionID.getTargetCompID().getValue() << "' and "
+  << "session_qualifier=" << "'" << m_sessionID.getSessionQualifier() << "'";
+
+  PostgreSQLQuery query( queryString.str() );
+  if( !m_pConnection->execute(query) )
+    query.throwException();
+
+  m_cache.reset();
+  UtcTimeStamp time = m_cache.getCreationTime();
+
+  int year, month, day, hour, minute, second, millis;
+  time.getYMD( year, month, day );
+  time.getHMS( hour, minute, second, millis );
+
+  char sqlTime[ 20 ];
+  STRING_SPRINTF( sqlTime, "%d-%02d-%02d %02d:%02d:%02d",
+           year, month, day, hour, minute, second );
+
+  std::stringstream queryString2;
+  queryString2 << "UPDATE sessions SET creation_time='" << sqlTime << "', "
+  << "incoming_seqnum=" << m_cache.getNextTargetMsgSeqNum() << ", "
+  << "outgoing_seqnum=" << m_cache.getNextSenderMsgSeqNum() << " WHERE "
+  << "beginstring=" << "'" << m_sessionID.getBeginString().getValue() << "' and "
+  << "sendercompid=" << "'" << m_sessionID.getSenderCompID().getValue() << "' and "
+  << "targetcompid=" << "'" << m_sessionID.getTargetCompID().getValue() << "' and "
+  << "session_qualifier=" << "'" << m_sessionID.getSessionQualifier() << "'";
+
+  PostgreSQLQuery query2( queryString2.str() );
+  if( !m_pConnection->execute(query2) )
+    query2.throwException();
+}
+
+void PostgreSQLStore::refresh() throw ( IOException )
+{
+  m_cache.reset();
+  populateCache(); 
+}
+
+}
+
+#endif

data/ext/quickfix/PostgreSQLStore.h

@@ -0,0 +1,141 @@
+/* -*- 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 HAVE_POSTGRESQL
+#error PostgreSQLStore.h included, but HAVE_POSTGRESQL not defined
+#endif
+
+#ifdef HAVE_POSTGRESQL
+#ifndef FIX_POSTGRESQLSTORE_H
+#define FIX_POSTGRESQLSTORE_H
+
+#ifdef _MSC_VER
+#pragma warning( disable : 4503 4355 4786 4290 )
+#endif
+
+#include "MessageStore.h"
+#include "SessionSettings.h"
+#include "PostgreSQLConnection.h"
+#include <fstream>
+#include <string>
+
+namespace FIX
+{
+/// Creates a PostgreSQL based implementation of MessageStore.
+class PostgreSQLStoreFactory : public MessageStoreFactory
+{
+public:
+  static const std::string DEFAULT_DATABASE;
+  static const std::string DEFAULT_USER;
+  static const std::string DEFAULT_PASSWORD;
+  static const std::string DEFAULT_HOST;
+  static const short DEFAULT_PORT;
+
+  PostgreSQLStoreFactory( const SessionSettings& settings )
+: m_settings( settings ), m_useSettings( true ), m_useDictionary( false ) 
+  {
+    bool poolConnections = false;
+    try { poolConnections = settings.get().getBool(POSTGRESQL_STORE_USECONNECTIONPOOL); }
+    catch( ConfigError& ) {}
+
+    m_connectionPoolPtr = PostgreSQLConnectionPoolPtr
+      ( new PostgreSQLConnectionPool(poolConnections) );
+  }
+
+  PostgreSQLStoreFactory( const Dictionary& dictionary )
+: m_dictionary( dictionary ), m_useSettings( false ), m_useDictionary( true ) 
+  {
+    m_connectionPoolPtr = PostgreSQLConnectionPoolPtr
+      ( new PostgreSQLConnectionPool(false) );
+  }
+
+  PostgreSQLStoreFactory( 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 ),
+  m_useSettings( false ), m_useDictionary( false ) 
+  {
+    m_connectionPoolPtr = PostgreSQLConnectionPoolPtr
+      ( new PostgreSQLConnectionPool(false) );
+  }
+
+  PostgreSQLStoreFactory()
+: m_database( DEFAULT_DATABASE ), m_user( DEFAULT_USER ), m_password( DEFAULT_PASSWORD ),
+  m_host( DEFAULT_HOST ), m_port( DEFAULT_PORT ), m_useSettings( false ), m_useDictionary( false ) 
+  {
+    m_connectionPoolPtr = PostgreSQLConnectionPoolPtr
+      ( new PostgreSQLConnectionPool(false) );
+  }
+
+  MessageStore* create( const SessionID& );
+  void destroy( MessageStore* );
+private:
+  MessageStore* create( const SessionID& s, const Dictionary& );
+
+  PostgreSQLConnectionPoolPtr m_connectionPoolPtr;
+  SessionSettings m_settings;
+  Dictionary m_dictionary;
+  std::string m_database;
+  std::string m_user;
+  std::string m_password;
+  std::string m_host;
+  short m_port;
+  bool m_useSettings;
+  bool m_useDictionary;
+};
+/*! @} */
+
+/// PostgreSQL based implementation of MessageStore.
+class PostgreSQLStore : public MessageStore
+{
+public:
+  PostgreSQLStore( const SessionID& s, const DatabaseConnectionID& d, PostgreSQLConnectionPool* p );
+  PostgreSQLStore( const SessionID& s, const std::string& database, const std::string& user,
+                   const std::string& password, const std::string& host, short port );
+  ~PostgreSQLStore();
+
+  bool set( int, const std::string& ) throw ( IOException );
+  void get( int, int, std::vector < std::string > & ) const throw ( IOException );
+
+  int getNextSenderMsgSeqNum() const throw ( IOException );
+  int getNextTargetMsgSeqNum() const throw ( IOException );
+  void setNextSenderMsgSeqNum( int value ) throw ( IOException );
+  void setNextTargetMsgSeqNum( int value ) throw ( IOException );
+  void incrNextSenderMsgSeqNum() throw ( IOException );
+  void incrNextTargetMsgSeqNum() throw ( IOException );
+
+  UtcTimeStamp getCreationTime() const throw ( IOException );
+
+  void reset() throw ( IOException );
+  void refresh() throw ( IOException );
+
+private:
+  void populateCache();
+
+  MemoryStore m_cache;
+  PostgreSQLConnection* m_pConnection;
+  PostgreSQLConnectionPool* m_pConnectionPool;
+  SessionID m_sessionID;
+};
+}
+
+#endif //FIX_POSTGRESQLSTORE_H
+#endif //HAVE_POSTGRESQL

data/ext/quickfix/Queue.h

@@ -0,0 +1,75 @@
+/* -*- 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_QUEUE_H
+#define FIX_QUEUE_H
+
+#include "Utility.h"
+#include "Event.h"
+#include "Mutex.h"
+#include <queue>
+
+namespace FIX
+{
+/// A thread safe monitored queue
+template < typename T > class Queue
+{
+public:
+  void push( const T& value )
+  {
+    Locker locker( m_mutex );
+    m_queue.push( value );
+    signal();
+  }
+
+  bool pop( T& value )
+  {
+    Locker locker( m_mutex );
+    if ( !m_queue.size() ) return false;
+    value = m_queue.front();
+    m_queue.pop();
+    return true;
+  }
+
+  int size()
+  {
+    Locker locker( m_mutex );
+    return m_queue.size();
+  }
+
+  void wait( double s )
+  {
+    m_event.wait( s );
+  }
+
+  void signal()
+  {
+    m_event.signal();
+  }
+
+private:
+  Event m_event;
+  Mutex m_mutex;
+  std::queue < T > m_queue;
+};
+}
+
+#endif