QPID-3858: WIP: Added smoke test to cmake, code format tidy-up

git-svn-id: https://svn.apache.org/repos/asf/qpid/branches/asyncstore@1368541 13f79535-47bb-0310-9956-ffa450edef68

28 files changed, 188 insertions, 377 deletions

diff --git a/cpp/src/qpid/asyncStore/AsyncOperation.cpp b/cpp/src/qpid/asyncStore/AsyncOperation.cpp
index 0e3586854c..3a53b4df1b 100644
--- a/cpp/src/qpid/asyncStore/AsyncOperation.cpp
+++ b/cpp/src/qpid/asyncStore/AsyncOperation.cpp
@@ -35,24 +35,20 @@ AsyncOperation::AsyncOperation(boost::shared_ptr<qpid::broker::BrokerAsyncContex
         m_brokerCtxt(brokerCtxt)
 {}
 
-AsyncOperation::~AsyncOperation()
-{}
+AsyncOperation::~AsyncOperation() {}
 
-boost::shared_ptr<qpid::broker::BrokerAsyncContext> AsyncOperation::getBrokerContext() const
-{
+boost::shared_ptr<qpid::broker::BrokerAsyncContext> AsyncOperation::getBrokerContext() const {
     return m_brokerCtxt;
 }
 
 void
-AsyncOperation::submitResult()
-{
+AsyncOperation::submitResult() {
     return submitResult(0, "");
 }
 
 void
 AsyncOperation::submitResult(const int errNo,
-                             const std::string& errMsg)
-{
+                             const std::string& errMsg) {
     if (m_brokerCtxt.get()) {
         qpid::broker::AsyncResultQueue* const arq = m_brokerCtxt->getAsyncResultQueue();
         if (arq) {
diff --git a/cpp/src/qpid/asyncStore/AsyncStoreImpl.cpp b/cpp/src/qpid/asyncStore/AsyncStoreImpl.cpp
index 2ee1d23025..5c62782278 100644
--- a/cpp/src/qpid/asyncStore/AsyncStoreImpl.cpp
+++ b/cpp/src/qpid/asyncStore/AsyncStoreImpl.cpp
@@ -51,54 +51,45 @@ AsyncStoreImpl::AsyncStoreImpl(boost::shared_ptr<qpid::sys::Poller> poller,
         m_operations(m_poller)
 {}
 
-AsyncStoreImpl::~AsyncStoreImpl()
-{}
+AsyncStoreImpl::~AsyncStoreImpl() {}
 
 void
-AsyncStoreImpl::initialize()
-{}
+AsyncStoreImpl::initialize() {}
 
 uint64_t
-AsyncStoreImpl::getNextRid()
-{
+AsyncStoreImpl::getNextRid() {
     return m_ridCntr.next();
 }
 
 void
-AsyncStoreImpl::initManagement(qpid::broker::Broker* /*broker*/)
-{}
+AsyncStoreImpl::initManagement(qpid::broker::Broker* /*broker*/) {}
 
 qpid::broker::TxnHandle
-AsyncStoreImpl::createTxnHandle()
-{
+AsyncStoreImpl::createTxnHandle() {
     return qpid::broker::TxnHandle(new TxnHandleImpl);
 }
 
 qpid::broker::TxnHandle
-AsyncStoreImpl::createTxnHandle(qpid::broker::SimpleTxnBuffer* tb)
-{
+AsyncStoreImpl::createTxnHandle(qpid::broker::SimpleTxnBuffer* tb) {
     return qpid::broker::TxnHandle(new TxnHandleImpl(tb));
 }
 
 qpid::broker::TxnHandle
 AsyncStoreImpl::createTxnHandle(const std::string& xid,
-                                const bool tpcFlag)
-{
+                                const bool tpcFlag) {
     return qpid::broker::TxnHandle(new TxnHandleImpl(xid, tpcFlag));
 }
 
 qpid::broker::TxnHandle
 AsyncStoreImpl::createTxnHandle(const std::string& xid,
                                 const bool tpcFlag,
-                                qpid::broker::SimpleTxnBuffer* tb)
-{
+                                qpid::broker::SimpleTxnBuffer* tb) {
     return qpid::broker::TxnHandle(new TxnHandleImpl(xid, tpcFlag, tb));
 }
 
 void
 AsyncStoreImpl::submitPrepare(qpid::broker::TxnHandle& txnHandle,
-                              boost::shared_ptr<qpid::broker::TpcTxnAsyncContext> TxnCtxt)
-{
+                              boost::shared_ptr<qpid::broker::TpcTxnAsyncContext> TxnCtxt) {
     boost::shared_ptr<const AsyncOperation> op(new AsyncOpTxnPrepare(txnHandle, TxnCtxt));
     TxnCtxt->setOpStr(op->getOpStr());
     m_operations.submit(op);
@@ -106,8 +97,7 @@ AsyncStoreImpl::submitPrepare(qpid::broker::TxnHandle& txnHandle,
 
 void
 AsyncStoreImpl::submitCommit(qpid::broker::TxnHandle& txnHandle,
-                             boost::shared_ptr<qpid::broker::TxnAsyncContext> TxnCtxt)
-{
+                             boost::shared_ptr<qpid::broker::TxnAsyncContext> TxnCtxt) {
     boost::shared_ptr<const AsyncOperation> op(new AsyncOpTxnCommit(txnHandle, TxnCtxt));
     TxnCtxt->setOpStr(op->getOpStr());
     m_operations.submit(op);
@@ -115,54 +105,46 @@ AsyncStoreImpl::submitCommit(qpid::broker::TxnHandle& txnHandle,
 
 void
 AsyncStoreImpl::submitAbort(qpid::broker::TxnHandle& txnHandle,
-                            boost::shared_ptr<qpid::broker::TxnAsyncContext> TxnCtxt)
-{
+                            boost::shared_ptr<qpid::broker::TxnAsyncContext> TxnCtxt) {
     boost::shared_ptr<const AsyncOperation> op(new AsyncOpTxnAbort(txnHandle, TxnCtxt));
     TxnCtxt->setOpStr(op->getOpStr());
     m_operations.submit(op);
 }
 
 qpid::broker::ConfigHandle
-AsyncStoreImpl::createConfigHandle()
-{
+AsyncStoreImpl::createConfigHandle() {
     return qpid::broker::ConfigHandle(new ConfigHandleImpl());
 }
 
 qpid::broker::EnqueueHandle
 AsyncStoreImpl::createEnqueueHandle(qpid::broker::MessageHandle& msgHandle,
-                                    qpid::broker::QueueHandle& queueHandle)
-{
+                                    qpid::broker::QueueHandle& queueHandle) {
     return qpid::broker::EnqueueHandle(new EnqueueHandleImpl(msgHandle,
                                                              queueHandle));
 }
 
 qpid::broker::EventHandle
 AsyncStoreImpl::createEventHandle(qpid::broker::QueueHandle& queueHandle,
-                                  const std::string& key)
-{
+                                  const std::string& key) {
     return qpid::broker::EventHandle(new EventHandleImpl(queueHandle,
                                                          key));
 }
 
 qpid::broker::MessageHandle
-AsyncStoreImpl::createMessageHandle(const qpid::broker::DataSource* const dataSrc)
-
-{
+AsyncStoreImpl::createMessageHandle(const qpid::broker::DataSource* const dataSrc) {
     return qpid::broker::MessageHandle(new MessageHandleImpl(dataSrc));
 }
 
 qpid::broker::QueueHandle
 AsyncStoreImpl::createQueueHandle(const std::string& name,
-                                  const qpid::types::Variant::Map& opts)
-{
+                                  const qpid::types::Variant::Map& opts) {
     return qpid::broker::QueueHandle(new QueueHandleImpl(name, opts));
 }
 
 void
 AsyncStoreImpl::submitCreate(qpid::broker::ConfigHandle& cfgHandle,
                              const qpid::broker::DataSource* const dataSrc,
-                             boost::shared_ptr<qpid::broker::BrokerAsyncContext> brokerCtxt)
-{
+                             boost::shared_ptr<qpid::broker::BrokerAsyncContext> brokerCtxt) {
     boost::shared_ptr<const AsyncOperation> op(new AsyncOpConfigCreate(cfgHandle, dataSrc, brokerCtxt));
     brokerCtxt->setOpStr(op->getOpStr());
     m_operations.submit(op);
@@ -170,8 +152,7 @@ AsyncStoreImpl::submitCreate(qpid::broker::ConfigHandle& cfgHandle,
 
 void
 AsyncStoreImpl::submitDestroy(qpid::broker::ConfigHandle& cfgHandle,
-                              boost::shared_ptr<qpid::broker::BrokerAsyncContext> brokerCtxt)
-{
+                              boost::shared_ptr<qpid::broker::BrokerAsyncContext> brokerCtxt) {
     boost::shared_ptr<const AsyncOperation> op(new AsyncOpConfigDestroy(cfgHandle, brokerCtxt));
     brokerCtxt->setOpStr(op->getOpStr());
     m_operations.submit(op);
@@ -180,8 +161,7 @@ AsyncStoreImpl::submitDestroy(qpid::broker::ConfigHandle& cfgHandle,
 void
 AsyncStoreImpl::submitCreate(qpid::broker::QueueHandle& queueHandle,
                              const qpid::broker::DataSource* const dataSrc,
-                             boost::shared_ptr<qpid::broker::QueueAsyncContext> QueueCtxt)
-{
+                             boost::shared_ptr<qpid::broker::QueueAsyncContext> QueueCtxt) {
     boost::shared_ptr<const AsyncOperation> op(new AsyncOpQueueCreate(queueHandle, dataSrc, QueueCtxt));
     QueueCtxt->setOpStr(op->getOpStr());
     m_operations.submit(op);
@@ -189,8 +169,7 @@ AsyncStoreImpl::submitCreate(qpid::broker::QueueHandle& queueHandle,
 
 void
 AsyncStoreImpl::submitDestroy(qpid::broker::QueueHandle& queueHandle,
-                              boost::shared_ptr<qpid::broker::QueueAsyncContext> QueueCtxt)
-{
+                              boost::shared_ptr<qpid::broker::QueueAsyncContext> QueueCtxt) {
     boost::shared_ptr<const AsyncOperation> op(new AsyncOpQueueDestroy(queueHandle, QueueCtxt));
     QueueCtxt->setOpStr(op->getOpStr());
     m_operations.submit(op);
@@ -198,8 +177,7 @@ AsyncStoreImpl::submitDestroy(qpid::broker::QueueHandle& queueHandle,
 
 void
 AsyncStoreImpl::submitFlush(qpid::broker::QueueHandle& queueHandle,
-                            boost::shared_ptr<qpid::broker::QueueAsyncContext> QueueCtxt)
-{
+                            boost::shared_ptr<qpid::broker::QueueAsyncContext> QueueCtxt) {
     boost::shared_ptr<const AsyncOperation> op(new AsyncOpQueueFlush(queueHandle, QueueCtxt));
     QueueCtxt->setOpStr(op->getOpStr());
     m_operations.submit(op);
@@ -209,8 +187,7 @@ void
 AsyncStoreImpl::submitCreate(qpid::broker::EventHandle& eventHandle,
                              const qpid::broker::DataSource* const dataSrc,
                              qpid::broker::TxnHandle& txnHandle,
-                             boost::shared_ptr<qpid::broker::BrokerAsyncContext> brokerCtxt)
-{
+                             boost::shared_ptr<qpid::broker::BrokerAsyncContext> brokerCtxt) {
     boost::shared_ptr<const AsyncOperation> op(new AsyncOpEventCreate(eventHandle, dataSrc, txnHandle, brokerCtxt));
     brokerCtxt->setOpStr(op->getOpStr());
     m_operations.submit(op);
@@ -219,8 +196,7 @@ AsyncStoreImpl::submitCreate(qpid::broker::EventHandle& eventHandle,
 void
 AsyncStoreImpl::submitDestroy(qpid::broker::EventHandle& eventHandle,
                               qpid::broker::TxnHandle& txnHandle,
-                              boost::shared_ptr<qpid::broker::BrokerAsyncContext> brokerCtxt)
-{
+                              boost::shared_ptr<qpid::broker::BrokerAsyncContext> brokerCtxt) {
     boost::shared_ptr<const AsyncOperation> op(new AsyncOpEventDestroy(eventHandle, txnHandle, brokerCtxt));
     brokerCtxt->setOpStr(op->getOpStr());
     m_operations.submit(op);
@@ -229,8 +205,7 @@ AsyncStoreImpl::submitDestroy(qpid::broker::EventHandle& eventHandle,
 void
 AsyncStoreImpl::submitEnqueue(qpid::broker::EnqueueHandle& enqHandle,
                               qpid::broker::TxnHandle& txnHandle,
-                              boost::shared_ptr<qpid::broker::QueueAsyncContext> QueueCtxt)
-{
+                              boost::shared_ptr<qpid::broker::QueueAsyncContext> QueueCtxt) {
     boost::shared_ptr<const AsyncOperation> op(new AsyncOpMsgEnqueue(enqHandle, txnHandle, QueueCtxt));
     QueueCtxt->setOpStr(op->getOpStr());
     m_operations.submit(op);
@@ -239,8 +214,7 @@ AsyncStoreImpl::submitEnqueue(qpid::broker::EnqueueHandle& enqHandle,
 void
 AsyncStoreImpl::submitDequeue(qpid::broker::EnqueueHandle& enqHandle,
                               qpid::broker::TxnHandle& txnHandle,
-                              boost::shared_ptr<qpid::broker::QueueAsyncContext> QueueCtxt)
-{
+                              boost::shared_ptr<qpid::broker::QueueAsyncContext> QueueCtxt) {
     boost::shared_ptr<const AsyncOperation> op(new AsyncOpMsgDequeue(enqHandle, txnHandle, QueueCtxt));
     QueueCtxt->setOpStr(op->getOpStr());
     m_operations.submit(op);
@@ -251,8 +225,7 @@ AsyncStoreImpl::loadContent(qpid::broker::MessageHandle& /*msgHandle*/,
                             qpid::broker::QueueHandle& /*queueHandle*/,
                             char* /*data*/,
                             uint64_t /*offset*/,
-                            const uint64_t /*length*/)
-{
+                            const uint64_t /*length*/) {
     return 0;
 }
 
diff --git a/cpp/src/qpid/asyncStore/AsyncStoreOptions.cpp b/cpp/src/qpid/asyncStore/AsyncStoreOptions.cpp
index 7037ca226f..ea953da0dc 100644
--- a/cpp/src/qpid/asyncStore/AsyncStoreOptions.cpp
+++ b/cpp/src/qpid/asyncStore/AsyncStoreOptions.cpp
@@ -43,24 +43,20 @@ AsyncStoreOptions::AsyncStoreOptions(const std::string& storeDir,
         m_storeDir(storeDir)
 {}
 
-AsyncStoreOptions::~AsyncStoreOptions()
-{}
+AsyncStoreOptions::~AsyncStoreOptions() {}
 
 void
-AsyncStoreOptions::printVals(std::ostream& os) const
-{
+AsyncStoreOptions::printVals(std::ostream& os) const {
     os << "ASYNC STORE OPTIONS:" << std::endl;
     os << "      Store directory location for persistence [store-dir]: \"" <<  m_storeDir << "\"" << std::endl;
 }
 
 void
-AsyncStoreOptions::validate()
-{}
+AsyncStoreOptions::validate() {}
 
 // private static
 std::string&
-AsyncStoreOptions::getDefaultStoreDir()
-{
+AsyncStoreOptions::getDefaultStoreDir() {
     static std::string s_defaultStoreDir = "/tmp";
     return s_defaultStoreDir;
 }
diff --git a/cpp/src/qpid/asyncStore/ConfigHandleImpl.cpp b/cpp/src/qpid/asyncStore/ConfigHandleImpl.cpp
index fc47f330a4..94984965e0 100644
--- a/cpp/src/qpid/asyncStore/ConfigHandleImpl.cpp
+++ b/cpp/src/qpid/asyncStore/ConfigHandleImpl.cpp
@@ -26,10 +26,8 @@
 namespace qpid {
 namespace asyncStore {
 
-ConfigHandleImpl::ConfigHandleImpl()
-{}
+ConfigHandleImpl::ConfigHandleImpl() {}
 
-ConfigHandleImpl::~ConfigHandleImpl()
-{}
+ConfigHandleImpl::~ConfigHandleImpl() {}
 
 }} // namespace qpid::asyncStore
diff --git a/cpp/src/qpid/asyncStore/EnqueueHandleImpl.cpp b/cpp/src/qpid/asyncStore/EnqueueHandleImpl.cpp
index be87831520..44ab5da26a 100644
--- a/cpp/src/qpid/asyncStore/EnqueueHandleImpl.cpp
+++ b/cpp/src/qpid/asyncStore/EnqueueHandleImpl.cpp
@@ -32,7 +32,6 @@ EnqueueHandleImpl::EnqueueHandleImpl(qpid::broker::MessageHandle& msgHandle,
         m_queueHandle(queueHandle)
 {}
 
-EnqueueHandleImpl::~EnqueueHandleImpl()
-{}
+EnqueueHandleImpl::~EnqueueHandleImpl() {}
 
 }} // namespace qpid::asyncStore
diff --git a/cpp/src/qpid/asyncStore/EventHandleImpl.cpp b/cpp/src/qpid/asyncStore/EventHandleImpl.cpp
index 4fd8805912..fec98dcfdf 100644
--- a/cpp/src/qpid/asyncStore/EventHandleImpl.cpp
+++ b/cpp/src/qpid/asyncStore/EventHandleImpl.cpp
@@ -32,12 +32,10 @@ EventHandleImpl::EventHandleImpl(qpid::broker::QueueHandle& queueHandle,
         m_key(key)
 {}
 
-EventHandleImpl::~EventHandleImpl()
-{}
+EventHandleImpl::~EventHandleImpl() {}
 
 const std::string&
-EventHandleImpl::getKey() const
-{
+EventHandleImpl::getKey() const {
     return m_key;
 }
 
diff --git a/cpp/src/qpid/asyncStore/MessageHandleImpl.cpp b/cpp/src/qpid/asyncStore/MessageHandleImpl.cpp
index a926aa161f..3ea3333dd1 100644
--- a/cpp/src/qpid/asyncStore/MessageHandleImpl.cpp
+++ b/cpp/src/qpid/asyncStore/MessageHandleImpl.cpp
@@ -30,7 +30,6 @@ MessageHandleImpl::MessageHandleImpl(const qpid::broker::DataSource* dataSrc) :
         m_dataSrc(dataSrc)
 {}
 
-MessageHandleImpl::~MessageHandleImpl()
-{}
+MessageHandleImpl::~MessageHandleImpl() {}
 
 }} // namespace qpid::asyncStore
diff --git a/cpp/src/qpid/asyncStore/OperationQueue.cpp b/cpp/src/qpid/asyncStore/OperationQueue.cpp
index b7b8970c39..09fa8c7048 100644
--- a/cpp/src/qpid/asyncStore/OperationQueue.cpp
+++ b/cpp/src/qpid/asyncStore/OperationQueue.cpp
@@ -36,21 +36,18 @@ OperationQueue::OperationQueue(const boost::shared_ptr<qpid::sys::Poller>& polle
     m_opQueue.start();
 }
 
-OperationQueue::~OperationQueue()
-{
+OperationQueue::~OperationQueue() {
     m_opQueue.stop();
 }
 
 void
-OperationQueue::submit(boost::shared_ptr<const AsyncOperation> op)
-{
+OperationQueue::submit(boost::shared_ptr<const AsyncOperation> op) {
     m_opQueue.push(op);
 }
 
 // private
 OperationQueue::OpQueue::Batch::const_iterator
-OperationQueue::handle(const OperationQueue::OpQueue::Batch& e)
-{
+OperationQueue::handle(const OperationQueue::OpQueue::Batch& e) {
     try {
         for (OpQueue::Batch::const_iterator i = e.begin(); i != e.end(); ++i) {
             boost::shared_ptr<qpid::broker::BrokerAsyncContext> bc = (*i)->getBrokerContext();
diff --git a/cpp/src/qpid/asyncStore/Plugin.cpp b/cpp/src/qpid/asyncStore/Plugin.cpp
index 400237df75..a577e6c040 100644
--- a/cpp/src/qpid/asyncStore/Plugin.cpp
+++ b/cpp/src/qpid/asyncStore/Plugin.cpp
@@ -31,8 +31,7 @@ namespace qpid {
 namespace broker {
 
 void
-Plugin::earlyInitialize(Target& target)
-{
+Plugin::earlyInitialize(Target& target) {
     Broker* broker = dynamic_cast<Broker*>(&target);
     if (!broker) return;
     DataDir& dataDir = broker->getDataDir ();
@@ -52,8 +51,7 @@ Plugin::earlyInitialize(Target& target)
 }
 
 void
-Plugin::initialize(Target& target)
-{
+Plugin::initialize(Target& target) {
     Broker* broker = dynamic_cast<Broker*>(&target);
     if (!broker || !m_store) return;
 
@@ -67,14 +65,12 @@ Plugin::initialize(Target& target)
 }
 
 void
-Plugin::finalize()
-{
+Plugin::finalize() {
     m_store.reset();
 }
 
 qpid::Options*
-Plugin::getOptions()
-{
+Plugin::getOptions() {
     return &m_options;
 }
 
diff --git a/cpp/src/qpid/asyncStore/QueueHandleImpl.cpp b/cpp/src/qpid/asyncStore/QueueHandleImpl.cpp
index 3781329b92..ddb10be7b3 100644
--- a/cpp/src/qpid/asyncStore/QueueHandleImpl.cpp
+++ b/cpp/src/qpid/asyncStore/QueueHandleImpl.cpp
@@ -32,12 +32,10 @@ QueueHandleImpl::QueueHandleImpl(const std::string& name,
         m_opts(opts)
 {}
 
-QueueHandleImpl::~QueueHandleImpl()
-{}
+QueueHandleImpl::~QueueHandleImpl() {}
 
 const std::string&
-QueueHandleImpl::getName() const
-{
+QueueHandleImpl::getName() const {
     return m_name;
 }
 
diff --git a/cpp/src/qpid/asyncStore/RunState.cpp b/cpp/src/qpid/asyncStore/RunState.cpp
index 737d8eb367..9ad05655ed 100644
--- a/cpp/src/qpid/asyncStore/RunState.cpp
+++ b/cpp/src/qpid/asyncStore/RunState.cpp
@@ -42,49 +42,41 @@ RunState::RunState(const RunState& s) :
         qpid::asyncStore::jrnl2::State<RunState_t>(s)
 {}
 
-RunState::~RunState()
-{}
+RunState::~RunState() {}
 
 void
-RunState::setInitializing()
-{
+RunState::setInitializing() {
     set(RS_INITIALIZING);
 }
 
 void
-RunState::setRestoring()
-{
+RunState::setRestoring() {
     set(RS_RESTORING);
 }
 
 void
-RunState::setRunning()
-{
+RunState::setRunning() {
     set(RS_RUNNING);
 }
 
 void
-RunState::setStopping()
-{
+RunState::setStopping() {
     set(RS_STOPPING);
 }
 
 void
-RunState::setStopped()
-{
+RunState::setStopped() {
     set(RS_STOPPED);
 }
 
 const char*
-RunState::getAsStr() const
-{
+RunState::getAsStr() const {
     return s_toStr(m_state);
 }
 
 //static
 const char*
-RunState::s_toStr(const RunState_t s)
-{
+RunState::s_toStr(const RunState_t s) {
     switch (s) {
     case RS_NONE:
         return "WR_NONE";
@@ -107,8 +99,7 @@ RunState::s_toStr(const RunState_t s)
 
 // private
 void
-RunState::set(const RunState_t s)
-{
+RunState::set(const RunState_t s) {
     // State transition logic: set stateError to true if an invalid transition is attempted
     bool stateTransitionError = false;
     switch (m_state) {
diff --git a/cpp/src/qpid/asyncStore/TxnHandleImpl.cpp b/cpp/src/qpid/asyncStore/TxnHandleImpl.cpp
index 50dce1b2af..8f41d4ce81 100644
--- a/cpp/src/qpid/asyncStore/TxnHandleImpl.cpp
+++ b/cpp/src/qpid/asyncStore/TxnHandleImpl.cpp
@@ -50,18 +50,15 @@ TxnHandleImpl::TxnHandleImpl(const std::string& xid,
         m_txnBuffer(tb)
 {}
 
-TxnHandleImpl::~TxnHandleImpl()
-{}
+TxnHandleImpl::~TxnHandleImpl() {}
 
 const std::string&
-TxnHandleImpl::getXid() const
-{
+TxnHandleImpl::getXid() const {
     return m_xid;
 }
 
 bool
-TxnHandleImpl::is2pc() const
-{
+TxnHandleImpl::is2pc() const {
     return m_tpcFlag;
 }
 
diff --git a/cpp/src/qpid/asyncStore/jrnl2/AsyncJournal.cpp b/cpp/src/qpid/asyncStore/jrnl2/AsyncJournal.cpp
index 979b91579f..2f879bb333 100644
--- a/cpp/src/qpid/asyncStore/jrnl2/AsyncJournal.cpp
+++ b/cpp/src/qpid/asyncStore/jrnl2/AsyncJournal.cpp
@@ -36,8 +36,7 @@ namespace asyncStore {
 namespace jrnl2 {
 
 std::string
-g_ioResAsString(const jrnlOpRes /*res*/)
-{
+g_ioResAsString(const jrnlOpRes /*res*/) {
     /// \todo TODO - provide implementation
     return ".[g_ioResAsString].";
 }
@@ -56,45 +55,38 @@ AsyncJournal::AsyncJournal(const std::string& jrnlId,
 }
 
 std::string
-AsyncJournal::getId() const
-{
+AsyncJournal::getId() const {
     return m_jrnlId;
 }
 
 JournalDirectory
-AsyncJournal::getJournalDir() const
-{
+AsyncJournal::getJournalDir() const {
     return m_jrnlDir;
 }
 
 std::string
-AsyncJournal::getJournalDirName() const
-{
+AsyncJournal::getJournalDirName() const {
     return m_jrnlDir.getFqName();
 }
 
 std::string
-AsyncJournal::getBaseFileName() const
-{
+AsyncJournal::getBaseFileName() const {
     return m_baseFileName;
 }
 
 const JournalRunState&
-AsyncJournal::getState() const
-{
+AsyncJournal::getState() const {
     return m_jrnlState;
 }
 
 const JournalParameters*
-AsyncJournal::getParameters() const
-{
+AsyncJournal::getParameters() const {
     return m_jrnlParamsPtr;
 }
 
 void
 AsyncJournal::initialize(const JournalParameters* jpPtr,
-                         AioCallback* const aiocbPtr)
-{
+                         AioCallback* const aiocbPtr) {
     m_jrnlParamsPtr = jpPtr;
     m_aioCallbackPtr = aiocbPtr;
     // --- temp code ---
@@ -108,8 +100,7 @@ AsyncJournal::enqueue(DataToken* dtokPtr,
                       const std::size_t /*dataLen*/,
                       const void* /*tidPtr*/,
                       const std::size_t /*tidLen*/,
-                      const bool /*transientFlag*/)
-{
+                      const bool /*transientFlag*/) {
     dtokPtr->getDataOpState().enqueue();
     // --- temp code ---
     { // --- START OF CRITICAL SECTION ---
@@ -127,8 +118,7 @@ AsyncJournal::enqueue(DataToken* dtokPtr,
 jrnlOpRes
 AsyncJournal::dequeue(DataToken* const dtokPtr,
                       const void* /*tidPtr*/,
-                      const std::size_t /*tidLen*/)
-{
+                      const std::size_t /*tidLen*/) {
     dtokPtr->getDataOpState().dequeue();
     dtokPtr->setDequeueRecordId(dtokPtr->getRecordId());
     // --- temp code ---
@@ -145,22 +135,19 @@ AsyncJournal::dequeue(DataToken* const dtokPtr,
 }
 
 jrnlOpRes
-AsyncJournal::commit()
-{
+AsyncJournal::commit() {
     /// \todo TODO - provide implementation
     return 0;
 }
 
 jrnlOpRes
-AsyncJournal::abort()
-{
+AsyncJournal::abort() {
     /// \todo TODO - provide implementation
     return 0;
 }
 
 jrnlOpRes
-AsyncJournal::flush()
-{
+AsyncJournal::flush() {
     // --- temp code ---
     // --- START OF CRITICAL SECTION ---
     ScopedTryLock l(m_writeDataTokensLock);
@@ -174,8 +161,7 @@ AsyncJournal::flush()
 
 // protected
 jrnlOpRes
-AsyncJournal::flushNoLock()
-{
+AsyncJournal::flushNoLock() {
     // --- temp code ---
     // Normally the page would be written to disk using libaio here (still to do).
     uint32_t cnt = 0UL;
@@ -190,8 +176,7 @@ AsyncJournal::flushNoLock()
 }
 
 jrnlOpRes
-AsyncJournal::sync(const double timeout)
-{
+AsyncJournal::sync(const double timeout) {
     // --- temp code ---
     // --- START OF CRITICAL SECTION ---
     ScopedTryLock l(m_writeDataTokensLock);
@@ -205,8 +190,7 @@ AsyncJournal::sync(const double timeout)
 
 // protected
 jrnlOpRes
-AsyncJournal::syncNoLock(const double /*timeout*/)
-{
+AsyncJournal::syncNoLock(const double /*timeout*/) {
     // --- temp code ---
     if (m_callbackDataTokens.size()) {
         processCompletedAioWriteEvents();
@@ -216,8 +200,7 @@ AsyncJournal::syncNoLock(const double /*timeout*/)
 }
 
 void
-AsyncJournal::processCompletedAioWriteEvents(const double /*timeout*/)
-{
+AsyncJournal::processCompletedAioWriteEvents(const double /*timeout*/) {
     // --- temp code ---
     // --- START OF CRITICAL SECTION 1 ---
     ScopedLock l1(m_callbackDataTokensLock);
diff --git a/cpp/src/qpid/asyncStore/jrnl2/DataOpState.cpp b/cpp/src/qpid/asyncStore/jrnl2/DataOpState.cpp
index fc7946de5a..5123077d67 100644
--- a/cpp/src/qpid/asyncStore/jrnl2/DataOpState.cpp
+++ b/cpp/src/qpid/asyncStore/jrnl2/DataOpState.cpp
@@ -43,31 +43,26 @@ DataOpState::DataOpState(const DataOpState& s) :
         State<opState_t>(s)
 {}
 
-DataOpState::~DataOpState()
-{}
+DataOpState::~DataOpState() {}
 
 void
-DataOpState::enqueue()
-{
+DataOpState::enqueue() {
     set(OP_ENQUEUE);
 }
 
 void
-DataOpState::dequeue()
-{
+DataOpState::dequeue() {
     set(OP_DEQUEUE);
 }
 
 const char*
-DataOpState::getAsStr() const
-{
+DataOpState::getAsStr() const {
     return s_toStr(m_state);
 }
 
 // static
 const char*
-DataOpState::s_toStr(const opState_t s)
-{
+DataOpState::s_toStr(const opState_t s) {
     switch (s) {
     case OP_NONE:
         return "OP_NONE";
@@ -84,8 +79,7 @@ DataOpState::s_toStr(const opState_t s)
 
 // private
 void
-DataOpState::set(const opState_t s)
-{
+DataOpState::set(const opState_t s) {
     // State transition logic: set stateError to true if an invalid transition is attempted
     bool stateTransitionError = false;
     switch(m_state) {
diff --git a/cpp/src/qpid/asyncStore/jrnl2/DataToken.cpp b/cpp/src/qpid/asyncStore/jrnl2/DataToken.cpp
index cd4969a7fc..c129a1dd37 100644
--- a/cpp/src/qpid/asyncStore/jrnl2/DataToken.cpp
+++ b/cpp/src/qpid/asyncStore/jrnl2/DataToken.cpp
@@ -42,81 +42,68 @@ DataToken::DataToken(const recordId_t rid) :
 DataToken::~DataToken() {}
 
 const DataOpState&
-DataToken::getDataOpState() const
-{
+DataToken::getDataOpState() const {
     return m_dataOpState;
 }
 
 DataOpState&
-DataToken::getDataOpState()
-{
+DataToken::getDataOpState() {
     return m_dataOpState;
 }
 
 const DataWrComplState&
-DataToken::getDataWrComplState() const
-{
+DataToken::getDataWrComplState() const {
     return m_dataWrComplState;
 }
 
 DataWrComplState&
-DataToken::getDataWrComplState()
-{
+DataToken::getDataWrComplState() {
     return m_dataWrComplState;
 }
 
 bool
-DataToken::isTransient() const
-{
+DataToken::isTransient() const {
     return m_transientFlag;
 }
 
 bool
-DataToken::isExternal() const
-{
+DataToken::isExternal() const {
     return m_externalFlag;
 }
 
 const std::string&
-DataToken::getExternalLocation() const
-{
+DataToken::getExternalLocation() const {
     return m_externalLocation;
 }
 
 recordId_t
-DataToken::getRecordId() const
-{
+DataToken::getRecordId() const {
     return m_recordId;
 }
 
 bool
-DataToken::isRecordIdExternal() const
-{
+DataToken::isRecordIdExternal() const {
     return m_externalRecordIdFlag;
 }
 
 recordId_t
-DataToken::getDequeueRecordId() const
-{
+DataToken::getDequeueRecordId() const {
     return m_dequeueRecordId;
 }
 
 void
-DataToken::setRecordId(const recordId_t rid)
-{
+DataToken::setRecordId(const recordId_t rid) {
     m_recordId = rid;
     m_externalRecordIdFlag = true;
 }
 
 void
-DataToken::setDequeueRecordId(const recordId_t drid)
-{
+DataToken::setDequeueRecordId(const recordId_t drid) {
     m_dequeueRecordId = drid;
 }
 
 void
-DataToken::toStream(std::ostream& os) const
-{
+DataToken::toStream(std::ostream& os) const {
     /// \todo TODO: Implementation required
     os << "status string";
 }
diff --git a/cpp/src/qpid/asyncStore/jrnl2/DataWrComplState.cpp b/cpp/src/qpid/asyncStore/jrnl2/DataWrComplState.cpp
index c6cedc4782..f4d06360bd 100644
--- a/cpp/src/qpid/asyncStore/jrnl2/DataWrComplState.cpp
+++ b/cpp/src/qpid/asyncStore/jrnl2/DataWrComplState.cpp
@@ -43,31 +43,26 @@ DataWrComplState::DataWrComplState(const DataWrComplState& s) :
         State<wrComplState_t>(s)
 {}
 
-DataWrComplState::~DataWrComplState()
-{}
+DataWrComplState::~DataWrComplState() {}
 
 void
-DataWrComplState::complete()
-{
+DataWrComplState::complete() {
     set(WR_COMPLETE);
 }
 
 void
-DataWrComplState::partComplete()
-{
+DataWrComplState::partComplete() {
     set(WR_PART);
 }
 
 const char*
-DataWrComplState::getAsStr() const
-{
+DataWrComplState::getAsStr() const {
     return s_toStr(m_state);
 }
 
 // static
 const char*
-DataWrComplState::s_toStr(const wrComplState_t s)
-{
+DataWrComplState::s_toStr(const wrComplState_t s) {
     switch (s) {
     case WR_NONE:
         return "WR_NONE";
@@ -84,8 +79,7 @@ DataWrComplState::s_toStr(const wrComplState_t s)
 
 // protected
 void
-DataWrComplState::set(const wrComplState_t s)
-{
+DataWrComplState::set(const wrComplState_t s) {
     // State transition logic: set stateError to true if an invalid transition is attempted
     bool stateTransitionError = false;
     switch(m_state) {
diff --git a/cpp/src/qpid/asyncStore/jrnl2/DequeueHeader.cpp b/cpp/src/qpid/asyncStore/jrnl2/DequeueHeader.cpp
index bf8ef5fc7f..402f48c24e 100644
--- a/cpp/src/qpid/asyncStore/jrnl2/DequeueHeader.cpp
+++ b/cpp/src/qpid/asyncStore/jrnl2/DequeueHeader.cpp
@@ -55,34 +55,29 @@ DequeueHeader::DequeueHeader(const DequeueHeader& dh) :
         m_xidSize(dh.m_xidSize)
 {}
 
-DequeueHeader::~DequeueHeader()
-{}
+DequeueHeader::~DequeueHeader() {}
 
 void
-DequeueHeader::copy(const DequeueHeader& dh)
-{
+DequeueHeader::copy(const DequeueHeader& dh) {
     RecordHeader::copy(dh);
     m_dequeuedRecordId = dh.m_dequeuedRecordId;
     m_xidSize = dh.m_xidSize;
 }
 
 void
-DequeueHeader::reset()
-{
+DequeueHeader::reset() {
     RecordHeader::reset();
     m_dequeuedRecordId = 0;
     m_xidSize = 0;
 }
 
 bool
-DequeueHeader::getTplCommitOnTxnComplFlag() const
-{
+DequeueHeader::getTplCommitOnTxnComplFlag() const {
     return m_flags & DEQ_HDR_TPL_COMMIT_ON_TXN_COMPL_MASK;
 }
 
 void
-DequeueHeader::setTplCommitOnTxnComplFlag(const bool commitOnTxnCompl)
-{
+DequeueHeader::setTplCommitOnTxnComplFlag(const bool commitOnTxnCompl) {
     m_flags = commitOnTxnCompl ?
               m_flags | DEQ_HDR_TPL_COMMIT_ON_TXN_COMPL_MASK :
               m_flags & (~DEQ_HDR_TPL_COMMIT_ON_TXN_COMPL_MASK);
@@ -90,20 +85,17 @@ DequeueHeader::setTplCommitOnTxnComplFlag(const bool commitOnTxnCompl)
 
 //static
 uint64_t
-DequeueHeader::getHeaderSize()
-{
+DequeueHeader::getHeaderSize() {
     return static_cast<uint64_t>(sizeof(DequeueHeader));
 }
 
 uint64_t
-DequeueHeader::getBodySize() const
-{
+DequeueHeader::getBodySize() const {
     return m_xidSize;
 }
 
 uint64_t
-DequeueHeader::getRecordSize() const
-{
+DequeueHeader::getRecordSize() const {
     return getHeaderSize() + (getBodySize() > 0LL ?
                               getBodySize() + RecordTail::getSize() :
                               0);
diff --git a/cpp/src/qpid/asyncStore/jrnl2/EnqueueHeader.cpp b/cpp/src/qpid/asyncStore/jrnl2/EnqueueHeader.cpp
index 213821ebe2..b2ebe95c43 100644
--- a/cpp/src/qpid/asyncStore/jrnl2/EnqueueHeader.cpp
+++ b/cpp/src/qpid/asyncStore/jrnl2/EnqueueHeader.cpp
@@ -49,32 +49,27 @@ EnqueueHeader::EnqueueHeader(const EnqueueHeader& eh) :
         EventHeader(eh)
 {}
 
-EnqueueHeader::~EnqueueHeader()
-{}
+EnqueueHeader::~EnqueueHeader() {}
 
 bool
-EnqueueHeader::getTransientFlag() const
-{
+EnqueueHeader::getTransientFlag() const {
     return m_flags & ENQ_HDR_TRANSIENT_MASK;
 }
 
 void
-EnqueueHeader::setTransientFlag(const bool transient)
-{
+EnqueueHeader::setTransientFlag(const bool transient) {
     m_flags = transient ?
               m_flags | ENQ_HDR_TRANSIENT_MASK :
               m_flags & (~ENQ_HDR_TRANSIENT_MASK);
 }
 
 bool
-EnqueueHeader::getExternalFlag() const
-{
+EnqueueHeader::getExternalFlag() const {
     return m_flags & ENQ_HDR_EXTERNAL_MASK;
 }
 
 void
-EnqueueHeader::setExternalFlag(const bool external)
-{
+EnqueueHeader::setExternalFlag(const bool external) {
     m_flags = external ?
               m_flags | ENQ_HDR_EXTERNAL_MASK :
               m_flags & (~ENQ_HDR_EXTERNAL_MASK);
@@ -82,8 +77,7 @@ EnqueueHeader::setExternalFlag(const bool external)
 
 //static
 uint64_t
-EnqueueHeader::getHeaderSize()
-{
+EnqueueHeader::getHeaderSize() {
     return sizeof(EnqueueHeader);
 }
 
diff --git a/cpp/src/qpid/asyncStore/jrnl2/EventHeader.cpp b/cpp/src/qpid/asyncStore/jrnl2/EventHeader.cpp
index 374d161af9..0b9c2e14d4 100644
--- a/cpp/src/qpid/asyncStore/jrnl2/EventHeader.cpp
+++ b/cpp/src/qpid/asyncStore/jrnl2/EventHeader.cpp
@@ -52,20 +52,17 @@ EventHeader::EventHeader(const EventHeader& eh) :
         m_dataSize(eh.m_dataSize)
 {}
 
-EventHeader::~EventHeader()
-{}
+EventHeader::~EventHeader() {}
 
 void
-EventHeader::copy(const EventHeader& e)
-{
+EventHeader::copy(const EventHeader& e) {
     RecordHeader::copy(e);
     m_xidSize = e.m_xidSize;
     m_dataSize = e.m_dataSize;
 }
 
 void
-EventHeader::reset()
-{
+EventHeader::reset() {
     RecordHeader::reset();
     m_xidSize = 0;
     m_dataSize = 0;
@@ -73,20 +70,17 @@ EventHeader::reset()
 
 //static
 uint64_t
-EventHeader::getHeaderSize()
-{
+EventHeader::getHeaderSize() {
     return sizeof(EventHeader);
 }
 
 uint64_t
-EventHeader::getBodySize() const
-{
+EventHeader::getBodySize() const {
     return m_xidSize + m_dataSize;
 }
 
 uint64_t
-EventHeader::getRecordSize() const
-{
+EventHeader::getRecordSize() const {
     return getHeaderSize() + (getBodySize() ?
            getBodySize() + RecordTail::getSize() :
            0);
diff --git a/cpp/src/qpid/asyncStore/jrnl2/FileHeader.cpp b/cpp/src/qpid/asyncStore/jrnl2/FileHeader.cpp
index 1b601c4cd7..169e3b4ab4 100644
--- a/cpp/src/qpid/asyncStore/jrnl2/FileHeader.cpp
+++ b/cpp/src/qpid/asyncStore/jrnl2/FileHeader.cpp
@@ -73,12 +73,10 @@ FileHeader::FileHeader(const FileHeader& fh) :
         m_reserved(fh.m_reserved)
 {}
 
-FileHeader::~FileHeader()
-{}
+FileHeader::~FileHeader() {}
 
 void
-FileHeader::copy(const FileHeader& fh)
-{
+FileHeader::copy(const FileHeader& fh) {
     RecordHeader::copy(fh);
     m_physicalFileId = fh.m_physicalFileId;
     m_logicalFileId = fh.m_logicalFileId;
@@ -89,8 +87,7 @@ FileHeader::copy(const FileHeader& fh)
 }
 
 void
-FileHeader::reset()
-{
+FileHeader::reset() {
     RecordHeader::reset();
     m_physicalFileId = 0;
     m_logicalFileId = 0;
@@ -102,26 +99,22 @@ FileHeader::reset()
 
 //static
 uint64_t
-FileHeader::getHeaderSize()
-{
+FileHeader::getHeaderSize() {
     return sizeof(FileHeader);
 }
 
 uint64_t
-FileHeader::getBodySize() const
-{
+FileHeader::getBodySize() const {
     return 0;
 }
 
 uint64_t
-FileHeader::getRecordSize() const
-{
+FileHeader::getRecordSize() const {
     return getHeaderSize();
 }
 
 void
-FileHeader::setTimestamp()
-{
+FileHeader::setTimestamp() {
     /// \todo TODO: Standardize on method for getting time that does not require a context switch.
     timespec ts;
     if (::clock_gettime(CLOCK_REALTIME, &ts)) {
@@ -133,8 +126,7 @@ FileHeader::setTimestamp()
 }
 
 void
-FileHeader::setTimestamp(const timespec& ts)
-{
+FileHeader::setTimestamp(const timespec& ts) {
     m_timestampSeconds = static_cast<uint64_t>(ts.tv_sec);
     m_timestampNanoSeconds = static_cast<uint32_t>(ts.tv_nsec);
 }
diff --git a/cpp/src/qpid/asyncStore/jrnl2/JournalDirectory.cpp b/cpp/src/qpid/asyncStore/jrnl2/JournalDirectory.cpp
index 0ec576805d..98fe84c87d 100644
--- a/cpp/src/qpid/asyncStore/jrnl2/JournalDirectory.cpp
+++ b/cpp/src/qpid/asyncStore/jrnl2/JournalDirectory.cpp
@@ -42,16 +42,14 @@ JournalDirectory::JournalDirectory(const std::string& fqName) :
 {}
 
 const
-std::string JournalDirectory::getFqName() const
-{
+std::string JournalDirectory::getFqName() const {
     return m_fqName;
 }
 
 void
 JournalDirectory::setFqName(const std::string newFqName,
                             const bool createNew,
-                            const bool destroyExisting)
-{
+                            const bool destroyExisting) {
     if (m_fqName.compare(newFqName) != 0) {
         if (destroyExisting) {
             destroy();
@@ -66,8 +64,7 @@ JournalDirectory::setFqName(const std::string newFqName,
 // static
 bool
 JournalDirectory::s_exists(const std::string& fqName,
-                           const bool checkIsWritable)
-{
+                           const bool checkIsWritable) {
     struct stat buff;
     if (::lstat(fqName.c_str(), &buff)) {
         if (errno == ENOENT) // No such dir or file
@@ -83,8 +80,7 @@ JournalDirectory::s_exists(const std::string& fqName,
 
 // static
 void
-JournalDirectory::s_create(const std::string& fqName)
-{
+JournalDirectory::s_create(const std::string& fqName) {
     std::size_t fdp = fqName.find_last_of('/');
     if (fdp != std::string::npos) {
         std::string parent_dir = fqName.substr(0, fdp);
@@ -100,8 +96,7 @@ JournalDirectory::s_create(const std::string& fqName)
 }
 
 void
-JournalDirectory::create()
-{
+JournalDirectory::create() {
     s_create(m_fqName);
     m_verified = true;
 }
@@ -109,14 +104,12 @@ JournalDirectory::create()
 //static
 void
 JournalDirectory::s_clear(const std::string& fqName,
-                          const bool recursiveDelete)
-{
+                          const bool recursiveDelete) {
     s_destroy(fqName, recursiveDelete, true);
 }
 
 void
-JournalDirectory::clear(const bool recursiveDelete)
-{
+JournalDirectory::clear(const bool recursiveDelete) {
     s_clear(m_fqName, recursiveDelete);
 }
 
@@ -124,8 +117,7 @@ JournalDirectory::clear(const bool recursiveDelete)
 void
 JournalDirectory::s_destroy(const std::string& fqName,
                             const bool recursiveDelete,
-                            const bool childrenOnly)
-{
+                            const bool childrenOnly) {
     if (s_exists(fqName)) {
         DIR* dir = ::opendir(fqName.c_str());
         if (dir) {
@@ -161,8 +153,7 @@ JournalDirectory::s_destroy(const std::string& fqName,
 
 void
 JournalDirectory::destroy(const bool recursiveDelete,
-                          const bool childrenOnly)
-{
+                          const bool childrenOnly) {
     if (m_verified) {
         s_destroy(m_fqName, recursiveDelete, childrenOnly);
         m_verified = false;
@@ -170,8 +161,7 @@ JournalDirectory::destroy(const bool recursiveDelete,
 }
 
 bool
-JournalDirectory::isVerified() const
-{
+JournalDirectory::isVerified() const {
     return m_verified;
 }
 
diff --git a/cpp/src/qpid/asyncStore/jrnl2/JournalError.cpp b/cpp/src/qpid/asyncStore/jrnl2/JournalError.cpp
index 3c64148b5b..24d840ea2b 100644
--- a/cpp/src/qpid/asyncStore/jrnl2/JournalError.cpp
+++ b/cpp/src/qpid/asyncStore/jrnl2/JournalError.cpp
@@ -126,49 +126,41 @@ JournalError::JournalError(const uint32_t errorCode,
     formatWhatStr();
 }
 
-JournalError::~JournalError() throw ()
-{}
+JournalError::~JournalError() throw () {}
 
 const char*
-JournalError::what() const throw ()
-{
+JournalError::what() const throw () {
     return m_what.c_str();
 }
 
 uint32_t
-JournalError::getErrorCode() const throw ()
-{
+JournalError::getErrorCode() const throw () {
     return m_errorCode;
 }
 
 const std::string
-JournalError::getAdditionalInfo() const throw ()
-{
+JournalError::getAdditionalInfo() const throw () {
     return m_additionalInfo;
 }
 
 const std::string
-JournalError::getThrowingClass() const throw ()
-{
+JournalError::getThrowingClass() const throw () {
     return m_throwingClass;
 }
 
 const std::string
-JournalError::getThrowingFunction() const throw ()
-{
+JournalError::getThrowingFunction() const throw () {
     return m_throwingFunction;
 }
 
 void
-JournalError::toStream(std::ostream& os) const
-{
+JournalError::toStream(std::ostream& os) const {
     os << what();
 }
 
 // protected
 void
-JournalError::formatWhatStr() throw ()
-{
+JournalError::formatWhatStr() throw () {
     try {
         const bool ai = !m_additionalInfo.empty();
         const bool tc = !m_throwingClass.empty();
@@ -198,8 +190,7 @@ JournalError::formatWhatStr() throw ()
 
 // protected
 const char*
-JournalError::className()
-{
+JournalError::className() {
     return s_className;
 }
 
@@ -229,8 +220,7 @@ const uint32_t JournalError::JERR_DIRNOTEMPTY       = 0x0208;
 
 // static
 const char*
-JournalError::s_errorMessage(const uint32_t err_no) throw ()
-{
+JournalError::s_errorMessage(const uint32_t err_no) throw () {
     s_errorMapIterator = s_errorMap.find(err_no);
     if (s_errorMapIterator == s_errorMap.end())
         return "<Unknown error code>";
@@ -243,8 +233,7 @@ bool JournalError::s_initializedFlag = JournalError::s_initialize();
 
 // private static
 bool
-JournalError::s_initialize()
-{
+JournalError::s_initialize() {
     s_errorMap[JERR_PTHREAD] = "JERR_PTHREAD: pthread operation failure";
     s_errorMap[JERR_RTCLOCK] = "JERR_RTCLOCK: realtime clock operation failure";
 
diff --git a/cpp/src/qpid/asyncStore/jrnl2/JournalRunState.cpp b/cpp/src/qpid/asyncStore/jrnl2/JournalRunState.cpp
index fcc6a57528..4a0d2cfd7f 100644
--- a/cpp/src/qpid/asyncStore/jrnl2/JournalRunState.cpp
+++ b/cpp/src/qpid/asyncStore/jrnl2/JournalRunState.cpp
@@ -43,55 +43,46 @@ JournalRunState::JournalRunState(const journalState_t s) :
         State<journalState_t>(s)
 {}
 
-JournalRunState::~JournalRunState()
-{}
+JournalRunState::~JournalRunState() {}
 
 void
-JournalRunState::initialize()
-{
+JournalRunState::initialize() {
     set(JS_INITIALIZING);
 }
 
 void
-JournalRunState::recoverPhase1()
-{
+JournalRunState::recoverPhase1() {
     set(JS_RECOVERING_PHASE_1);
 }
 
 void
-JournalRunState::recoverPhase2()
-{
+JournalRunState::recoverPhase2() {
     set(JS_RECOVERING_PHASE_2);
 }
 
 void
-JournalRunState::run()
-{
+JournalRunState::run() {
     set(JS_RUNNING);
 }
 
 void
-JournalRunState::stop()
-{
+JournalRunState::stop() {
     set(JS_STOPPING);
 }
 
 void
-JournalRunState::stopped()
-{
+JournalRunState::stopped() {
     set(JS_STOPPED);
 }
 
 const char*
-JournalRunState::getAsStr() const
-{
+JournalRunState::getAsStr() const {
     return s_toStr(m_state);
 }
 
 // static
 const char*
-JournalRunState::s_toStr(const journalState_t s)
-{
+JournalRunState::s_toStr(const journalState_t s) {
     switch (s) {
     case JS_NONE:
         return "JS_NONE";
@@ -116,8 +107,7 @@ JournalRunState::s_toStr(const journalState_t s)
 
 // private
 void
-JournalRunState::set(const journalState_t s)
-{
+JournalRunState::set(const journalState_t s) {
     // State transition logic: set stateError to true if an invalid transition is attempted
     bool stateTransitionError = false;
     switch(m_state) {
diff --git a/cpp/src/qpid/asyncStore/jrnl2/RecordHeader.cpp b/cpp/src/qpid/asyncStore/jrnl2/RecordHeader.cpp
index 3317eb8438..e12a0c96d8 100644
--- a/cpp/src/qpid/asyncStore/jrnl2/RecordHeader.cpp
+++ b/cpp/src/qpid/asyncStore/jrnl2/RecordHeader.cpp
@@ -56,12 +56,10 @@ RecordHeader::RecordHeader(const RecordHeader& rh) :
         m_recordId(rh.m_recordId)
 {}
 
-RecordHeader::~RecordHeader()
-{}
+RecordHeader::~RecordHeader() {}
 
 void
-RecordHeader::copy(const RecordHeader& rh)
-{
+RecordHeader::copy(const RecordHeader& rh) {
     m_magic = rh.m_magic;
     m_version = rh.m_version;
     m_bigEndianFlag = rh.m_bigEndianFlag;
@@ -70,8 +68,7 @@ RecordHeader::copy(const RecordHeader& rh)
 }
 
 void
-RecordHeader::reset()
-{
+RecordHeader::reset() {
     m_magic = 0;
     m_version = 0;
     m_bigEndianFlag = 0;
@@ -80,14 +77,12 @@ RecordHeader::reset()
 }
 
 bool
-RecordHeader::getOverwriteIndicator() const
-{
+RecordHeader::getOverwriteIndicator() const {
     return m_flags & HDR_OVERWRITE_INDICATOR_MASK;
 }
 
 void
-RecordHeader::setOverwriteIndicator(const bool owi)
-{
+RecordHeader::setOverwriteIndicator(const bool owi) {
     m_flags = owi ?
               m_flags | HDR_OVERWRITE_INDICATOR_MASK :
               m_flags & (~HDR_OVERWRITE_INDICATOR_MASK);
@@ -95,14 +90,12 @@ RecordHeader::setOverwriteIndicator(const bool owi)
 
 //static
 uint64_t
-RecordHeader::getHeaderSize()
-{
+RecordHeader::getHeaderSize() {
     return static_cast<uint64_t>(sizeof(RecordHeader));
 }
 
 uint32_t
-RecordHeader::getCheckSum(uint32_t initialValue) const
-{
+RecordHeader::getCheckSum(uint32_t initialValue) const {
     uint32_t cs = initialValue;
     for (unsigned char* p = (unsigned char*)this;
                         p < (unsigned char*)this + getHeaderSize() + getBodySize();
diff --git a/cpp/src/qpid/asyncStore/jrnl2/RecordTail.cpp b/cpp/src/qpid/asyncStore/jrnl2/RecordTail.cpp
index fe33d47b13..39e8ba5dcf 100644
--- a/cpp/src/qpid/asyncStore/jrnl2/RecordTail.cpp
+++ b/cpp/src/qpid/asyncStore/jrnl2/RecordTail.cpp
@@ -57,16 +57,14 @@ RecordTail::RecordTail(const RecordTail& rt) :
 {}
 
 void
-RecordTail::copy(const RecordTail& rt)
-{
+RecordTail::copy(const RecordTail& rt) {
     m_xMagic = rt.m_xMagic;
     m_checkSum = rt.m_checkSum;
     m_recordId = rt.m_recordId;
 }
 
 void
-RecordTail::reset()
-{
+RecordTail::reset() {
     m_xMagic = 0xffffffff;
     m_checkSum = 0;
     m_recordId = 0;
@@ -74,8 +72,7 @@ RecordTail::reset()
 
 //static
 uint64_t
-RecordTail::getSize()
-{
+RecordTail::getSize() {
     return sizeof(RecordTail);
 }
 
diff --git a/cpp/src/qpid/asyncStore/jrnl2/ScopedLock.cpp b/cpp/src/qpid/asyncStore/jrnl2/ScopedLock.cpp
index 4acba534ef..90509f1754 100644
--- a/cpp/src/qpid/asyncStore/jrnl2/ScopedLock.cpp
+++ b/cpp/src/qpid/asyncStore/jrnl2/ScopedLock.cpp
@@ -40,14 +40,12 @@ ScopedMutex::ScopedMutex()
     PTHREAD_CHK(::pthread_mutex_init(&m_mutex, 0), "::pthread_mutex_init", "ScopedMutex", "ScopedMutex");
 }
 
-ScopedMutex::~ScopedMutex()
-{
+ScopedMutex::~ScopedMutex() {
     PTHREAD_CHK(::pthread_mutex_destroy(&m_mutex), "::pthread_mutex_destroy", "ScopedMutex", "~ScopedMutex");
 }
 
 ::pthread_mutex_t*
-ScopedMutex::get() const
-{
+ScopedMutex::get() const {
     return &m_mutex;
 }
 
@@ -58,8 +56,7 @@ ScopedMutexContainer::ScopedMutexContainer(const ScopedMutex& sm) :
         m_scopedMutexRef(sm)
 {}
 
-::pthread_mutex_t* ScopedMutexContainer::get() const
-{
+::pthread_mutex_t* ScopedMutexContainer::get() const {
     return m_scopedMutexRef.get();
 }
 
@@ -72,8 +69,7 @@ ScopedLock::ScopedLock(const ScopedMutex& sm) :
     PTHREAD_CHK(::pthread_mutex_lock(m_scopedMutexRef.get()), "::pthread_mutex_lock", "ScopedLock", "ScopedLock");
 }
 
-ScopedLock::~ScopedLock()
-{
+ScopedLock::~ScopedLock() {
     PTHREAD_CHK(::pthread_mutex_unlock(m_scopedMutexRef.get()), "::pthread_mutex_unlock", "ScopedLock", "~ScopedLock");
 }
 
@@ -91,16 +87,14 @@ ScopedTryLock::ScopedTryLock(const ScopedMutex& sm) :
     }
 }
 
-ScopedTryLock::~ScopedTryLock()
-{
+ScopedTryLock::~ScopedTryLock() {
     if (m_lockedFlag)
         PTHREAD_CHK(::pthread_mutex_unlock(m_scopedMutexRef.get()), "::pthread_mutex_unlock", "ScopedTryLock",
                     "~ScopedTryLock");
 }
 
 bool
-ScopedTryLock::isLocked() const
-{
+ScopedTryLock::isLocked() const {
     return m_lockedFlag;
 }
 
diff --git a/cpp/src/qpid/asyncStore/jrnl2/Streamable.cpp b/cpp/src/qpid/asyncStore/jrnl2/Streamable.cpp
index 0ee86223b1..a153797c96 100644
--- a/cpp/src/qpid/asyncStore/jrnl2/Streamable.cpp
+++ b/cpp/src/qpid/asyncStore/jrnl2/Streamable.cpp
@@ -29,27 +29,23 @@ namespace qpid {
 namespace asyncStore {
 namespace jrnl2 {
 
-Streamable::~Streamable()
-{}
+Streamable::~Streamable() {}
 
 std::string
-Streamable::toString() const
-{
+Streamable::toString() const {
     std::ostringstream oss;
     toStream(oss);
     return oss.str();
 }
 
 std::ostream&
-operator<<(std::ostream& os, const Streamable& s)
-{
+operator<<(std::ostream& os, const Streamable& s) {
     s.toStream(os);
     return os;
 }
 
 std::ostream&
-operator<<(std::ostream& os, const Streamable* sPtr)
-{
+operator<<(std::ostream& os, const Streamable* sPtr) {
     sPtr->toStream(os);
     return os;
 }
diff --git a/cpp/src/qpid/asyncStore/jrnl2/TransactionHeader.cpp b/cpp/src/qpid/asyncStore/jrnl2/TransactionHeader.cpp
index 9de9f2656c..6becbeea9c 100644
--- a/cpp/src/qpid/asyncStore/jrnl2/TransactionHeader.cpp
+++ b/cpp/src/qpid/asyncStore/jrnl2/TransactionHeader.cpp
@@ -47,39 +47,33 @@ TransactionHeader::TransactionHeader(const TransactionHeader& th) :
         m_xidSize(th.m_xidSize)
 {}
 
-TransactionHeader::~TransactionHeader()
-{}
+TransactionHeader::~TransactionHeader() {}
 
 void
-TransactionHeader::copy(const TransactionHeader& th)
-{
+TransactionHeader::copy(const TransactionHeader& th) {
     RecordHeader::copy(th);
     m_xidSize = th.m_xidSize;
 }
 
 void
-TransactionHeader::reset()
-{
+TransactionHeader::reset() {
     RecordHeader::reset();
     m_xidSize = 0;
 }
 
 //static
 uint64_t
-TransactionHeader::getHeaderSize()
-{
+TransactionHeader::getHeaderSize() {
     return sizeof(TransactionHeader);
 }
 
 uint64_t
-TransactionHeader::getBodySize() const
-{
+TransactionHeader::getBodySize() const {
     return m_xidSize;
 }
 
 uint64_t
-TransactionHeader::getRecordSize() const
-{
+TransactionHeader::getRecordSize() const {
     // By definition, TransactionRecords must always have an xid, hence a record
     // tail as well. No check on body size required in this case.
     return getHeaderSize() + getBodySize() + RecordTail::getSize();