quickfix_ruby_ud 2.0.7-aarch64-linux

data/ext/quickfix/OdbcStore.cpp

@@ -0,0 +1,313 @@
+/****************************************************************************
+** 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_ODBC
+
+#include "FieldConvertors.h"
+#include "OdbcStore.h"
+#include "Parser.h"
+#include "SessionID.h"
+#include "SessionSettings.h"
+#include "Utility.h"
+#include "strptime.h"
+#include <fstream>
+
+namespace FIX {
+
+const std::string OdbcStoreFactory::DEFAULT_USER = "sa";
+const std::string OdbcStoreFactory::DEFAULT_PASSWORD = "";
+const std::string OdbcStoreFactory::DEFAULT_CONNECTION_STRING = "DATABASE=quickfix;DRIVER={SQL Server};SERVER=(local);";
+
+OdbcStore::OdbcStore(
+    const UtcTimeStamp &now,
+    const SessionID &sessionID,
+    const std::string &user,
+    const std::string &password,
+    const std::string &connectionString)
+    : m_cache(now),
+      m_sessionID(sessionID) {
+  m_pConnection = new OdbcConnection(user, password, connectionString);
+  populateCache();
+}
+
+OdbcStore::~OdbcStore() { delete m_pConnection; }
+
+void OdbcStore::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() << "'";
+
+  OdbcQuery query(queryString.str());
+
+  if (!m_pConnection->execute(query)) {
+    throw ConfigError("Unable to query sessions table");
+  }
+
+  int rows = 0;
+  while (query.fetch()) {
+    rows++;
+    if (rows > 1) {
+      throw ConfigError("Multiple entries found for session in database");
+    }
+
+    SQL_TIMESTAMP_STRUCT creationTime;
+    SQLLEN creationTimeLength;
+    SQLGetData(query.statement(), 1, SQL_C_TYPE_TIMESTAMP, &creationTime, 0, &creationTimeLength);
+    SQLUBIGINT incomingSeqNum;
+    SQLLEN incomingSeqNumLength;
+    SQLGetData(query.statement(), 2, SQL_C_UBIGINT, &incomingSeqNum, 0, &incomingSeqNumLength);
+
+    SQLUBIGINT outgoingSeqNum;
+    SQLLEN outgoingSeqNumLength;
+    SQLGetData(query.statement(), 3, SQL_C_UBIGINT, &outgoingSeqNum, 0, &outgoingSeqNumLength);
+
+    UtcTimeStamp time = UtcTimeStamp::now();
+    time.setYMD(creationTime.year, creationTime.month, creationTime.day);
+    time.setHMS(creationTime.hour, creationTime.minute, creationTime.second, creationTime.fraction);
+    m_cache.setCreationTime(time);
+    m_cache.setNextTargetMsgSeqNum(incomingSeqNum);
+    m_cache.setNextSenderMsgSeqNum(outgoingSeqNum);
+  }
+  query.close();
+
+  if (rows == 0) {
+    UtcTimeStamp time = m_cache.getCreationTime();
+    char sqlTime[100];
+    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() << "',"
+                 << "{ts '" << sqlTime << "'}," << m_cache.getNextTargetMsgSeqNum() << ","
+                 << m_cache.getNextSenderMsgSeqNum() << ")";
+
+    OdbcQuery query2(queryString2.str());
+    if (!m_pConnection->execute(query2)) {
+      throw ConfigError("Unable to create session in database");
+    }
+  }
+}
+
+MessageStore *OdbcStoreFactory::create(const UtcTimeStamp &now, const SessionID &sessionID) {
+  if (m_useSettings) {
+    return create(now, sessionID, m_settings.get(sessionID));
+  } else if (m_useDictionary) {
+    return create(now, sessionID, m_dictionary);
+  } else {
+    return new OdbcStore(now, sessionID, m_user, m_password, m_connectionString);
+  }
+}
+
+void OdbcStoreFactory::destroy(MessageStore *pStore) { delete pStore; }
+
+MessageStore *OdbcStoreFactory::create(
+    const UtcTimeStamp &now,
+    const SessionID &sessionID,
+    const Dictionary &settings) {
+  std::string user = DEFAULT_USER;
+  std::string password = DEFAULT_PASSWORD;
+  std::string connectionString = DEFAULT_CONNECTION_STRING;
+
+  try {
+    user = settings.getString(ODBC_STORE_USER);
+  } catch (ConfigError &) {}
+
+  try {
+    password = settings.getString(ODBC_STORE_PASSWORD);
+  } catch (ConfigError &) {}
+
+  try {
+    connectionString = settings.getString(ODBC_STORE_CONNECTION_STRING);
+  } catch (ConfigError &) {}
+
+  return new OdbcStore(now, sessionID, user, password, connectionString);
+}
+
+bool OdbcStore::set(SEQNUM msgSeqNum, const std::string &msg) EXCEPT(IOException) {
+  std::string msgCopy = msg;
+  string_replace("'", "''", msgCopy);
+
+  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 << "')";
+
+  OdbcQuery query(queryString.str());
+  if (!m_pConnection->execute(query)) {
+    query.close();
+    std::stringstream queryString2;
+    queryString2 << "UPDATE messages SET message='" << msgCopy << "' 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;
+    OdbcQuery query2(queryString2.str());
+    if (!m_pConnection->execute(query2)) {
+      query2.throwException();
+    }
+  }
+  return true;
+}
+
+void OdbcStore::get(SEQNUM begin, SEQNUM end, std::vector<std::string> &result) const EXCEPT(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";
+
+  OdbcQuery query(queryString.str());
+
+  if (!m_pConnection->execute(query)) {
+    query.throwException();
+  }
+
+  while (query.fetch()) {
+    std::string message;
+    SQLVARCHAR messageBuffer[4096];
+    SQLLEN messageLength;
+
+    while (odbcSuccess(SQLGetData(query.statement(), 1, SQL_C_CHAR, &messageBuffer, 4095, &messageLength))) {
+      messageBuffer[messageLength] = 0;
+      message += (char *)messageBuffer;
+    }
+
+    result.push_back(message);
+  }
+}
+
+SEQNUM OdbcStore::getNextSenderMsgSeqNum() const EXCEPT(IOException) { return m_cache.getNextSenderMsgSeqNum(); }
+
+SEQNUM OdbcStore::getNextTargetMsgSeqNum() const EXCEPT(IOException) { return m_cache.getNextTargetMsgSeqNum(); }
+
+void OdbcStore::setNextSenderMsgSeqNum(SEQNUM value) EXCEPT(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() << "'";
+  OdbcQuery query(queryString.str());
+  if (!m_pConnection->execute(query)) {
+    query.throwException();
+  }
+  m_cache.setNextSenderMsgSeqNum(value);
+}
+
+void OdbcStore::setNextTargetMsgSeqNum(SEQNUM value) EXCEPT(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() << "'";
+
+  OdbcQuery query(queryString.str());
+  if (!m_pConnection->execute(query)) {
+    query.throwException();
+  }
+
+  m_cache.setNextTargetMsgSeqNum(value);
+}
+
+void OdbcStore::incrNextSenderMsgSeqNum() EXCEPT(IOException) {
+  m_cache.incrNextSenderMsgSeqNum();
+  setNextSenderMsgSeqNum(m_cache.getNextSenderMsgSeqNum());
+}
+
+void OdbcStore::incrNextTargetMsgSeqNum() EXCEPT(IOException) {
+  m_cache.incrNextTargetMsgSeqNum();
+  setNextTargetMsgSeqNum(m_cache.getNextTargetMsgSeqNum());
+}
+
+UtcTimeStamp OdbcStore::getCreationTime() const EXCEPT(IOException) { return m_cache.getCreationTime(); }
+
+void OdbcStore::reset(const UtcTimeStamp &now) EXCEPT(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() << "'";
+
+  OdbcQuery query(queryString.str());
+  if (!m_pConnection->execute(query)) {
+    query.throwException();
+  }
+  query.close();
+
+  m_cache.reset(now);
+  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[100];
+  STRING_SPRINTF(sqlTime, "%d-%02d-%02d %02d:%02d:%02d", year, month, day, hour, minute, second);
+
+  std::stringstream queryString2;
+  queryString2 << "UPDATE sessions SET creation_time={ts '" << 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() << "'";
+
+  OdbcQuery query2(queryString2.str());
+  if (!m_pConnection->execute(query2)) {
+    query2.throwException();
+  }
+}
+
+void OdbcStore::refresh() EXCEPT(IOException) {
+  m_cache.reset(UtcTimeStamp::now());
+  populateCache();
+}
+
+} // namespace FIX
+
+#endif

data/ext/quickfix/OdbcStore.h

@@ -0,0 +1,124 @@
+/* -*- 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_ODBC
+#error OdbcStore.h included, but HAVE_ODBC not defined
+#endif
+
+#ifdef HAVE_ODBC
+#ifndef FIX_ODBCSTORE_H
+#define FIX_ODBCSTORE_H
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4503 4355 4786 4290)
+#endif
+
+#include "MessageStore.h"
+#include "OdbcConnection.h"
+#include "SessionSettings.h"
+#include <fstream>
+#include <string>
+
+namespace FIX {
+/// Creates a Odbc based implementation of MessageStore.
+class OdbcStoreFactory : public MessageStoreFactory {
+public:
+  static const std::string DEFAULT_USER;
+  static const std::string DEFAULT_PASSWORD;
+  static const std::string DEFAULT_CONNECTION_STRING;
+
+  OdbcStoreFactory(const SessionSettings &settings)
+      : m_settings(settings),
+        m_useSettings(true),
+        m_useDictionary(false) {}
+
+  OdbcStoreFactory(const Dictionary &dictionary)
+      : m_dictionary(dictionary),
+        m_useSettings(false),
+        m_useDictionary(true) {}
+
+  OdbcStoreFactory(const std::string &user, const std::string &password, const std::string &connectionString)
+      : m_user(user),
+        m_password(password),
+        m_connectionString(connectionString),
+        m_useSettings(false),
+        m_useDictionary(false) {}
+
+  OdbcStoreFactory()
+      : m_user(DEFAULT_USER),
+        m_password(DEFAULT_PASSWORD),
+        m_connectionString(DEFAULT_CONNECTION_STRING),
+        m_useSettings(false),
+        m_useDictionary(false) {}
+
+  MessageStore *create(const UtcTimeStamp &, const SessionID &);
+  void destroy(MessageStore *);
+
+private:
+  MessageStore *create(const UtcTimeStamp &, const SessionID &sessionID, const Dictionary &);
+
+  Dictionary m_dictionary;
+  SessionSettings m_settings;
+  std::string m_user;
+  std::string m_password;
+  std::string m_connectionString;
+  bool m_useSettings;
+  bool m_useDictionary;
+};
+/*! @} */
+
+/// Odbc based implementation of MessageStore.
+class OdbcStore : public MessageStore {
+public:
+  OdbcStore(
+      const UtcTimeStamp &now,
+      const SessionID &sessionID,
+      const std::string &user,
+      const std::string &password,
+      const std::string &connectionString);
+  ~OdbcStore();
+
+  bool set(SEQNUM, const std::string &) EXCEPT(IOException);
+  void get(SEQNUM, SEQNUM, std::vector<std::string> &) const EXCEPT(IOException);
+
+  SEQNUM getNextSenderMsgSeqNum() const EXCEPT(IOException);
+  SEQNUM getNextTargetMsgSeqNum() const EXCEPT(IOException);
+  void setNextSenderMsgSeqNum(SEQNUM value) EXCEPT(IOException);
+  void setNextTargetMsgSeqNum(SEQNUM value) EXCEPT(IOException);
+  void incrNextSenderMsgSeqNum() EXCEPT(IOException);
+  void incrNextTargetMsgSeqNum() EXCEPT(IOException);
+
+  UtcTimeStamp getCreationTime() const EXCEPT(IOException);
+
+  void reset(const UtcTimeStamp &now) EXCEPT(IOException);
+  void refresh() EXCEPT(IOException);
+
+private:
+  void populateCache();
+
+  MemoryStore m_cache;
+  SessionID m_sessionID;
+  OdbcConnection *m_pConnection;
+};
+} // namespace FIX
+
+#endif
+#endif

data/ext/quickfix/PUGIXML_DOMDocument.cpp

@@ -0,0 +1,112 @@
+/****************************************************************************
+** 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 "PUGIXML_DOMDocument.h"
+#include <sstream>
+
+namespace FIX
+{
+  bool PUGIXML_DOMAttributes::get( const std::string& name, std::string& value )
+  {
+    pugi::xml_attribute result = m_pNode.attribute(name.c_str());
+    if( !result ) return false;
+    value = result.value();
+    return true;
+  }
+
+  DOMAttributes::map PUGIXML_DOMAttributes::toMap()
+  {
+    return DOMAttributes::map();
+  }
+
+  DOMNodePtr PUGIXML_DOMNode::getFirstChildNode()
+  {
+    pugi::xml_node pNode = m_pNode.first_child();
+    if( !pNode ) return DOMNodePtr();
+    return DOMNodePtr(new PUGIXML_DOMNode(pNode));
+  }
+
+  DOMNodePtr PUGIXML_DOMNode::getNextSiblingNode()
+  {
+    pugi::xml_node pNode = m_pNode.next_sibling();
+    if( !pNode ) return DOMNodePtr();
+    return DOMNodePtr(new PUGIXML_DOMNode(pNode));
+  }
+
+  DOMAttributesPtr PUGIXML_DOMNode::getAttributes()
+  {
+    return DOMAttributesPtr(new PUGIXML_DOMAttributes(m_pNode));
+  }
+
+  std::string PUGIXML_DOMNode::getName()
+  {
+    return m_pNode.name();
+  }
+
+  std::string PUGIXML_DOMNode::getText()
+  {
+    return m_pNode.value();
+  }
+
+  PUGIXML_DOMDocument::PUGIXML_DOMDocument() EXCEPT ( ConfigError )
+  {
+  }
+
+  PUGIXML_DOMDocument::~PUGIXML_DOMDocument()
+  {
+    //xmlFreeDoc(m_pDoc);
+  }
+
+  bool PUGIXML_DOMDocument::load( std::istream& stream )
+  {
+    try
+    {
+      return m_pDoc.load(stream);
+    }
+    catch( ... ) { return false; }
+  }
+
+  bool PUGIXML_DOMDocument::load( const std::string& url )
+  {
+    try
+    {
+      return m_pDoc.load_file(url.c_str());
+    }
+    catch( ... ) { return false; }
+  }
+
+  bool PUGIXML_DOMDocument::xml( std::ostream& out )
+  {
+    return false;
+  }
+
+  DOMNodePtr PUGIXML_DOMDocument::getNode( const std::string& XPath )
+  {
+    pugi::xpath_node result = m_pDoc.select_node(XPath.c_str());
+    if( !result ) return DOMNodePtr();
+
+    return DOMNodePtr(new PUGIXML_DOMNode(result.node()));
+  }
+}

data/ext/quickfix/PUGIXML_DOMDocument.h

@@ -0,0 +1,81 @@
+/* -*- 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_PUGIXMLDOMDOCUMENT_H
+#define FIX_PUGIXMLDOMDOCUMENT_H
+
+#include "DOMDocument.h"
+#include "Exceptions.h"
+#include "pugixml.hpp"
+
+namespace FIX
+{
+  /// XML attribute as represented by pugixml.
+  class PUGIXML_DOMAttributes : public DOMAttributes
+  {
+  public:
+    PUGIXML_DOMAttributes( pugi::xml_node pNode )
+    : m_pNode(pNode) {}
+
+    bool get( const std::string&, std::string& );
+    DOMAttributes::map toMap();
+
+  private:
+    pugi::xml_node m_pNode;
+  };
+
+  /// XML node as represented by pugixml.
+  class PUGIXML_DOMNode : public DOMNode
+  {
+  public:
+    PUGIXML_DOMNode( pugi::xml_node pNode )
+    : m_pNode(pNode) {}
+    ~PUGIXML_DOMNode() {}
+
+    DOMNodePtr getFirstChildNode();
+    DOMNodePtr getNextSiblingNode();
+    DOMAttributesPtr getAttributes();
+    std::string getName();
+    std::string getText();
+
+  private:
+    pugi::xml_node m_pNode;
+  };
+
+  /// XML document as represented by pugixml.
+  class PUGIXML_DOMDocument : public DOMDocument
+  {
+  public:
+    PUGIXML_DOMDocument() EXCEPT ( ConfigError );
+    ~PUGIXML_DOMDocument();
+
+    bool load( std::istream& );
+    bool load( const std::string& );
+    bool xml( std::ostream& );
+
+    DOMNodePtr getNode( const std::string& );
+
+  private:
+    pugi::xml_document m_pDoc;
+  };
+}
+
+#endif