*** This commit represents a complete reformatting of the LLDB source code

*** to conform to clang-format’s LLVM style.  This kind of mass change has
*** two obvious implications:

Firstly, merging this particular commit into a downstream fork may be a huge
effort.  Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit.  The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):

    find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
    find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;

The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.

Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit.  There are alternatives available that will attempt
to look through this change and find the appropriate prior commit.  YMMV.

llvm-svn: 280751

1 files changed, 280 insertions, 383 deletions

diff --git a/lldb/source/API/SBQueue.cpp b/lldb/source/API/SBQueue.cpp
index be4c5fd..c6f5305 100644
--- a/lldb/source/API/SBQueue.cpp
+++ b/lldb/source/API/SBQueue.cpp
@@ -12,8 +12,8 @@
 #include "lldb/API/SBQueue.h"
 
 #include "lldb/API/SBProcess.h"
-#include "lldb/API/SBThread.h"
 #include "lldb/API/SBQueueItem.h"
+#include "lldb/API/SBThread.h"
 
 #include "lldb/Core/Log.h"
 #include "lldb/Target/Process.h"
@@ -24,427 +24,324 @@
 using namespace lldb;
 using namespace lldb_private;
 
-namespace lldb_private
-{
-
-    class QueueImpl
-    {
-    public:
-        QueueImpl () :
-            m_queue_wp(),
-            m_threads(),
-            m_thread_list_fetched(false),
-            m_pending_items(),
-            m_pending_items_fetched(false)
-        {
-        }
-
-        QueueImpl (const lldb::QueueSP &queue_sp) :
-            m_queue_wp(),
-            m_threads(),
-            m_thread_list_fetched(false),
-            m_pending_items(),
-            m_pending_items_fetched(false)
-        {
-            m_queue_wp = queue_sp;
-        }
-
-        QueueImpl (const QueueImpl &rhs)
-        {
-            if (&rhs == this)
-                return;
-            m_queue_wp = rhs.m_queue_wp;
-            m_threads = rhs.m_threads;
-            m_thread_list_fetched = rhs.m_thread_list_fetched;
-            m_pending_items = rhs.m_pending_items;
-            m_pending_items_fetched = rhs.m_pending_items_fetched;
-        }
+namespace lldb_private {
 
-        ~QueueImpl ()
-        {
-        }
-
-        bool
-        IsValid ()
-        {
-            return m_queue_wp.lock() != NULL;
-        }
+class QueueImpl {
+public:
+  QueueImpl()
+      : m_queue_wp(), m_threads(), m_thread_list_fetched(false),
+        m_pending_items(), m_pending_items_fetched(false) {}
 
-        void
-        Clear ()
-        {
-            m_queue_wp.reset();
-            m_thread_list_fetched = false;
-            m_threads.clear();
-            m_pending_items_fetched = false;
-            m_pending_items.clear();
-        }
-
-        void
-        SetQueue (const lldb::QueueSP &queue_sp)
-        {
-            Clear();
-            m_queue_wp = queue_sp;
-        }
-
-        lldb::queue_id_t
-        GetQueueID () const
-        {
-            lldb::queue_id_t result = LLDB_INVALID_QUEUE_ID;
-            lldb::QueueSP queue_sp = m_queue_wp.lock();
-            if (queue_sp)
-            {
-                result = queue_sp->GetID();
-            }
-            Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-            if (log)
-                log->Printf ("SBQueue(%p)::GetQueueID () => 0x%" PRIx64,
-                             static_cast<const void*>(this), result);
-            return result;
-        }
-
-        uint32_t
-        GetIndexID () const
-        {
-            uint32_t result = LLDB_INVALID_INDEX32;
-            lldb::QueueSP queue_sp = m_queue_wp.lock();
-            if (queue_sp)
-            {
-                result = queue_sp->GetIndexID();
-            }
-            Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-            if (log)
-                log->Printf ("SBQueueImpl(%p)::GetIndexID () => %d",
-                             static_cast<const void*>(this), result);
-            return result;
-        }
-
-        const char *
-        GetName () const
-        {
-            const char *name = NULL;
-            lldb::QueueSP queue_sp = m_queue_wp.lock ();
-            if (queue_sp.get())
-            {
-                name = queue_sp->GetName();
-            }
-
-            Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-            if (log)
-                log->Printf ("SBQueueImpl(%p)::GetName () => %s",
-                             static_cast<const void*>(this),
-                             name ? name : "NULL");
-
-            return name;
-        }
-
-        void
-        FetchThreads ()
-        {
-            if (m_thread_list_fetched == false)
-            {
-                lldb::QueueSP queue_sp = m_queue_wp.lock();
-                if (queue_sp)
-                {
-                    Process::StopLocker stop_locker;
-                    if (stop_locker.TryLock (&queue_sp->GetProcess()->GetRunLock()))
-                    {
-                        const std::vector<ThreadSP> thread_list(queue_sp->GetThreads());
-                        m_thread_list_fetched = true;
-                        const uint32_t num_threads = thread_list.size();
-                        for (uint32_t idx = 0; idx < num_threads; ++idx)
-                        {
-                            ThreadSP thread_sp = thread_list[idx];
-                            if (thread_sp && thread_sp->IsValid())
-                            {
-                                m_threads.push_back (thread_sp);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        void
-        FetchItems ()
-        {
-            if (m_pending_items_fetched == false)
-            {
-                QueueSP queue_sp = m_queue_wp.lock();
-                if (queue_sp)
-                {
-                    Process::StopLocker stop_locker;
-                    if (stop_locker.TryLock (&queue_sp->GetProcess()->GetRunLock()))
-                    {
-                        const std::vector<QueueItemSP> queue_items(queue_sp->GetPendingItems());
-                        m_pending_items_fetched = true;
-                        const uint32_t num_pending_items = queue_items.size();
-                        for (uint32_t idx = 0; idx < num_pending_items; ++idx)
-                        {
-                            QueueItemSP item = queue_items[idx];
-                            if (item && item->IsValid())
-                            {
-                                m_pending_items.push_back (item);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        uint32_t
-        GetNumThreads ()
-        {
-            uint32_t result = 0;
-
-            FetchThreads();
-            if (m_thread_list_fetched)
-            {
-                result = m_threads.size();
-            }
-            return result;
-        }
-
-        lldb::SBThread
-        GetThreadAtIndex (uint32_t idx)
-        {
-            FetchThreads();
-
-            SBThread sb_thread;
-            QueueSP queue_sp = m_queue_wp.lock();
-            if (queue_sp && idx < m_threads.size())
-            {
-                ProcessSP process_sp = queue_sp->GetProcess();
-                if (process_sp)
-                {
-                    ThreadSP thread_sp = m_threads[idx].lock();
-                    if (thread_sp)
-                    {
-                        sb_thread.SetThread (thread_sp);
-                    }
-                }
-            }
-            return sb_thread;
-        }
+  QueueImpl(const lldb::QueueSP &queue_sp)
+      : m_queue_wp(), m_threads(), m_thread_list_fetched(false),
+        m_pending_items(), m_pending_items_fetched(false) {
+    m_queue_wp = queue_sp;
+  }
 
-        uint32_t
-        GetNumPendingItems ()
-        {
-            uint32_t result = 0;
-
-            QueueSP queue_sp = m_queue_wp.lock();
-            if (m_pending_items_fetched == false && queue_sp)
-            {
-                result = queue_sp->GetNumPendingWorkItems();
-            }
-            else
-            {
-                result = m_pending_items.size();
-            }
-            return result;
-        }
+  QueueImpl(const QueueImpl &rhs) {
+    if (&rhs == this)
+      return;
+    m_queue_wp = rhs.m_queue_wp;
+    m_threads = rhs.m_threads;
+    m_thread_list_fetched = rhs.m_thread_list_fetched;
+    m_pending_items = rhs.m_pending_items;
+    m_pending_items_fetched = rhs.m_pending_items_fetched;
+  }
+
+  ~QueueImpl() {}
+
+  bool IsValid() { return m_queue_wp.lock() != NULL; }
+
+  void Clear() {
+    m_queue_wp.reset();
+    m_thread_list_fetched = false;
+    m_threads.clear();
+    m_pending_items_fetched = false;
+    m_pending_items.clear();
+  }
+
+  void SetQueue(const lldb::QueueSP &queue_sp) {
+    Clear();
+    m_queue_wp = queue_sp;
+  }
+
+  lldb::queue_id_t GetQueueID() const {
+    lldb::queue_id_t result = LLDB_INVALID_QUEUE_ID;
+    lldb::QueueSP queue_sp = m_queue_wp.lock();
+    if (queue_sp) {
+      result = queue_sp->GetID();
+    }
+    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+    if (log)
+      log->Printf("SBQueue(%p)::GetQueueID () => 0x%" PRIx64,
+                  static_cast<const void *>(this), result);
+    return result;
+  }
+
+  uint32_t GetIndexID() const {
+    uint32_t result = LLDB_INVALID_INDEX32;
+    lldb::QueueSP queue_sp = m_queue_wp.lock();
+    if (queue_sp) {
+      result = queue_sp->GetIndexID();
+    }
+    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+    if (log)
+      log->Printf("SBQueueImpl(%p)::GetIndexID () => %d",
+                  static_cast<const void *>(this), result);
+    return result;
+  }
+
+  const char *GetName() const {
+    const char *name = NULL;
+    lldb::QueueSP queue_sp = m_queue_wp.lock();
+    if (queue_sp.get()) {
+      name = queue_sp->GetName();
+    }
+
+    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+    if (log)
+      log->Printf("SBQueueImpl(%p)::GetName () => %s",
+                  static_cast<const void *>(this), name ? name : "NULL");
 
-        lldb::SBQueueItem
-        GetPendingItemAtIndex (uint32_t idx)
-        {
-            SBQueueItem result;
-            FetchItems();
-            if (m_pending_items_fetched && idx < m_pending_items.size())
-            {
-                result.SetQueueItem (m_pending_items[idx]);
+    return name;
+  }
+
+  void FetchThreads() {
+    if (m_thread_list_fetched == false) {
+      lldb::QueueSP queue_sp = m_queue_wp.lock();
+      if (queue_sp) {
+        Process::StopLocker stop_locker;
+        if (stop_locker.TryLock(&queue_sp->GetProcess()->GetRunLock())) {
+          const std::vector<ThreadSP> thread_list(queue_sp->GetThreads());
+          m_thread_list_fetched = true;
+          const uint32_t num_threads = thread_list.size();
+          for (uint32_t idx = 0; idx < num_threads; ++idx) {
+            ThreadSP thread_sp = thread_list[idx];
+            if (thread_sp && thread_sp->IsValid()) {
+              m_threads.push_back(thread_sp);
             }
-            return result;
+          }
         }
-
-        uint32_t
-        GetNumRunningItems ()
-        {
-            uint32_t result = 0;
-            QueueSP queue_sp = m_queue_wp.lock();
-            if (queue_sp)
-                result = queue_sp->GetNumRunningWorkItems();
-            return result;
-        }
-
-        lldb::SBProcess
-        GetProcess ()
-        {
-            SBProcess result;
-            QueueSP queue_sp = m_queue_wp.lock();
-            if (queue_sp)
-            {
-                result.SetSP (queue_sp->GetProcess());
+      }
+    }
+  }
+
+  void FetchItems() {
+    if (m_pending_items_fetched == false) {
+      QueueSP queue_sp = m_queue_wp.lock();
+      if (queue_sp) {
+        Process::StopLocker stop_locker;
+        if (stop_locker.TryLock(&queue_sp->GetProcess()->GetRunLock())) {
+          const std::vector<QueueItemSP> queue_items(
+              queue_sp->GetPendingItems());
+          m_pending_items_fetched = true;
+          const uint32_t num_pending_items = queue_items.size();
+          for (uint32_t idx = 0; idx < num_pending_items; ++idx) {
+            QueueItemSP item = queue_items[idx];
+            if (item && item->IsValid()) {
+              m_pending_items.push_back(item);
             }
-            return result;
+          }
         }
-
-        lldb::QueueKind
-        GetKind ()
-        {
-            lldb::QueueKind kind = eQueueKindUnknown;
-            QueueSP queue_sp = m_queue_wp.lock();
-            if (queue_sp)
-                kind = queue_sp->GetKind();
-
-            return kind;
+      }
+    }
+  }
+
+  uint32_t GetNumThreads() {
+    uint32_t result = 0;
+
+    FetchThreads();
+    if (m_thread_list_fetched) {
+      result = m_threads.size();
+    }
+    return result;
+  }
+
+  lldb::SBThread GetThreadAtIndex(uint32_t idx) {
+    FetchThreads();
+
+    SBThread sb_thread;
+    QueueSP queue_sp = m_queue_wp.lock();
+    if (queue_sp && idx < m_threads.size()) {
+      ProcessSP process_sp = queue_sp->GetProcess();
+      if (process_sp) {
+        ThreadSP thread_sp = m_threads[idx].lock();
+        if (thread_sp) {
+          sb_thread.SetThread(thread_sp);
         }
-
-    private:
-        lldb::QueueWP                   m_queue_wp;
-        std::vector<lldb::ThreadWP>     m_threads;              // threads currently executing this queue's items
-        bool                            m_thread_list_fetched;  // have we tried to fetch the threads list already?
-        std::vector<lldb::QueueItemSP>  m_pending_items;       // items currently enqueued
-        bool                            m_pending_items_fetched;  // have we tried to fetch the item list already?
-    };
-
+      }
+    }
+    return sb_thread;
+  }
+
+  uint32_t GetNumPendingItems() {
+    uint32_t result = 0;
+
+    QueueSP queue_sp = m_queue_wp.lock();
+    if (m_pending_items_fetched == false && queue_sp) {
+      result = queue_sp->GetNumPendingWorkItems();
+    } else {
+      result = m_pending_items.size();
+    }
+    return result;
+  }
+
+  lldb::SBQueueItem GetPendingItemAtIndex(uint32_t idx) {
+    SBQueueItem result;
+    FetchItems();
+    if (m_pending_items_fetched && idx < m_pending_items.size()) {
+      result.SetQueueItem(m_pending_items[idx]);
+    }
+    return result;
+  }
+
+  uint32_t GetNumRunningItems() {
+    uint32_t result = 0;
+    QueueSP queue_sp = m_queue_wp.lock();
+    if (queue_sp)
+      result = queue_sp->GetNumRunningWorkItems();
+    return result;
+  }
+
+  lldb::SBProcess GetProcess() {
+    SBProcess result;
+    QueueSP queue_sp = m_queue_wp.lock();
+    if (queue_sp) {
+      result.SetSP(queue_sp->GetProcess());
+    }
+    return result;
+  }
+
+  lldb::QueueKind GetKind() {
+    lldb::QueueKind kind = eQueueKindUnknown;
+    QueueSP queue_sp = m_queue_wp.lock();
+    if (queue_sp)
+      kind = queue_sp->GetKind();
+
+    return kind;
+  }
+
+private:
+  lldb::QueueWP m_queue_wp;
+  std::vector<lldb::ThreadWP>
+      m_threads; // threads currently executing this queue's items
+  bool
+      m_thread_list_fetched; // have we tried to fetch the threads list already?
+  std::vector<lldb::QueueItemSP> m_pending_items; // items currently enqueued
+  bool m_pending_items_fetched; // have we tried to fetch the item list already?
+};
 }
 
-SBQueue::SBQueue () :
-    m_opaque_sp (new QueueImpl())
-{
-}
+SBQueue::SBQueue() : m_opaque_sp(new QueueImpl()) {}
 
-SBQueue::SBQueue (const QueueSP& queue_sp) :
-    m_opaque_sp (new QueueImpl (queue_sp))
-{
-}
+SBQueue::SBQueue(const QueueSP &queue_sp)
+    : m_opaque_sp(new QueueImpl(queue_sp)) {}
 
-SBQueue::SBQueue (const SBQueue &rhs)
-{
-    if (&rhs == this)
-        return;
+SBQueue::SBQueue(const SBQueue &rhs) {
+  if (&rhs == this)
+    return;
 
-    m_opaque_sp = rhs.m_opaque_sp;
+  m_opaque_sp = rhs.m_opaque_sp;
 }
 
-const lldb::SBQueue &
-SBQueue::operator = (const lldb::SBQueue &rhs)
-{
-    m_opaque_sp = rhs.m_opaque_sp;
-    return *this;
+const lldb::SBQueue &SBQueue::operator=(const lldb::SBQueue &rhs) {
+  m_opaque_sp = rhs.m_opaque_sp;
+  return *this;
 }
 
-SBQueue::~SBQueue()
-{
-}
+SBQueue::~SBQueue() {}
 
-bool
-SBQueue::IsValid() const
-{
-    bool is_valid = m_opaque_sp->IsValid ();
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    if (log)
-        log->Printf("SBQueue(0x%" PRIx64 ")::IsValid() == %s", m_opaque_sp->GetQueueID(),
-                    is_valid ? "true" : "false");
-    return is_valid;
+bool SBQueue::IsValid() const {
+  bool is_valid = m_opaque_sp->IsValid();
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  if (log)
+    log->Printf("SBQueue(0x%" PRIx64 ")::IsValid() == %s",
+                m_opaque_sp->GetQueueID(), is_valid ? "true" : "false");
+  return is_valid;
 }
 
-
-void
-SBQueue::Clear ()
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    if (log)
-        log->Printf("SBQueue(0x%" PRIx64 ")::Clear()", m_opaque_sp->GetQueueID());
-    m_opaque_sp->Clear();
+void SBQueue::Clear() {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  if (log)
+    log->Printf("SBQueue(0x%" PRIx64 ")::Clear()", m_opaque_sp->GetQueueID());
+  m_opaque_sp->Clear();
 }
 
-
-void
-SBQueue::SetQueue (const QueueSP& queue_sp)
-{
-    m_opaque_sp->SetQueue (queue_sp);
+void SBQueue::SetQueue(const QueueSP &queue_sp) {
+  m_opaque_sp->SetQueue(queue_sp);
 }
 
-lldb::queue_id_t
-SBQueue::GetQueueID () const
-{
-    lldb::queue_id_t qid = m_opaque_sp->GetQueueID ();
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    if (log)
-        log->Printf("SBQueue(0x%" PRIx64 ")::GetQueueID() == 0x%" PRIx64, m_opaque_sp->GetQueueID(), (uint64_t) qid);
-    return qid;
+lldb::queue_id_t SBQueue::GetQueueID() const {
+  lldb::queue_id_t qid = m_opaque_sp->GetQueueID();
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  if (log)
+    log->Printf("SBQueue(0x%" PRIx64 ")::GetQueueID() == 0x%" PRIx64,
+                m_opaque_sp->GetQueueID(), (uint64_t)qid);
+  return qid;
 }
 
-uint32_t
-SBQueue::GetIndexID () const
-{
-    uint32_t index_id = m_opaque_sp->GetIndexID ();
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    if (log)
-        log->Printf("SBQueue(0x%" PRIx64 ")::GetIndexID() == 0x%" PRIx32, m_opaque_sp->GetQueueID(), index_id);
-    return index_id;
+uint32_t SBQueue::GetIndexID() const {
+  uint32_t index_id = m_opaque_sp->GetIndexID();
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  if (log)
+    log->Printf("SBQueue(0x%" PRIx64 ")::GetIndexID() == 0x%" PRIx32,
+                m_opaque_sp->GetQueueID(), index_id);
+  return index_id;
 }
 
-const char *
-SBQueue::GetName () const
-{
-    const char *name = m_opaque_sp->GetName ();
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    if (log)
-        log->Printf("SBQueue(0x%" PRIx64 ")::GetName() == %s", m_opaque_sp->GetQueueID(), 
-                     name ? name : "");
-    return name;
+const char *SBQueue::GetName() const {
+  const char *name = m_opaque_sp->GetName();
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  if (log)
+    log->Printf("SBQueue(0x%" PRIx64 ")::GetName() == %s",
+                m_opaque_sp->GetQueueID(), name ? name : "");
+  return name;
 }
 
-uint32_t
-SBQueue::GetNumThreads ()
-{
-    uint32_t numthreads = m_opaque_sp->GetNumThreads ();
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    if (log)
-        log->Printf("SBQueue(0x%" PRIx64 ")::GetNumThreads() == %d", m_opaque_sp->GetQueueID(), numthreads);
-    return numthreads;
+uint32_t SBQueue::GetNumThreads() {
+  uint32_t numthreads = m_opaque_sp->GetNumThreads();
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  if (log)
+    log->Printf("SBQueue(0x%" PRIx64 ")::GetNumThreads() == %d",
+                m_opaque_sp->GetQueueID(), numthreads);
+  return numthreads;
 }
 
-SBThread
-SBQueue::GetThreadAtIndex (uint32_t idx)
-{
-    SBThread th = m_opaque_sp->GetThreadAtIndex (idx);
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    if (log)
-        log->Printf("SBQueue(0x%" PRIx64 ")::GetThreadAtIndex(%d)", m_opaque_sp->GetQueueID(), idx);
-    return th;
+SBThread SBQueue::GetThreadAtIndex(uint32_t idx) {
+  SBThread th = m_opaque_sp->GetThreadAtIndex(idx);
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  if (log)
+    log->Printf("SBQueue(0x%" PRIx64 ")::GetThreadAtIndex(%d)",
+                m_opaque_sp->GetQueueID(), idx);
+  return th;
 }
 
-
-uint32_t
-SBQueue::GetNumPendingItems ()
-{
-    uint32_t pending_items = m_opaque_sp->GetNumPendingItems ();
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    if (log)
-        log->Printf("SBQueue(0x%" PRIx64 ")::GetNumPendingItems() == %d", m_opaque_sp->GetQueueID(), pending_items);
-    return pending_items;
+uint32_t SBQueue::GetNumPendingItems() {
+  uint32_t pending_items = m_opaque_sp->GetNumPendingItems();
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  if (log)
+    log->Printf("SBQueue(0x%" PRIx64 ")::GetNumPendingItems() == %d",
+                m_opaque_sp->GetQueueID(), pending_items);
+  return pending_items;
 }
 
-SBQueueItem
-SBQueue::GetPendingItemAtIndex (uint32_t idx)
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    if (log)
-        log->Printf("SBQueue(0x%" PRIx64 ")::GetPendingItemAtIndex(%d)", m_opaque_sp->GetQueueID(),  idx);
-    return m_opaque_sp->GetPendingItemAtIndex (idx);
+SBQueueItem SBQueue::GetPendingItemAtIndex(uint32_t idx) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  if (log)
+    log->Printf("SBQueue(0x%" PRIx64 ")::GetPendingItemAtIndex(%d)",
+                m_opaque_sp->GetQueueID(), idx);
+  return m_opaque_sp->GetPendingItemAtIndex(idx);
 }
 
-uint32_t
-SBQueue::GetNumRunningItems ()
-{
-    uint32_t running_items = m_opaque_sp->GetNumRunningItems ();
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    if (log)
-        log->Printf("SBQueue(0x%" PRIx64 ")::GetNumRunningItems() == %d", m_opaque_sp->GetQueueID(), running_items);
-    return running_items;
+uint32_t SBQueue::GetNumRunningItems() {
+  uint32_t running_items = m_opaque_sp->GetNumRunningItems();
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  if (log)
+    log->Printf("SBQueue(0x%" PRIx64 ")::GetNumRunningItems() == %d",
+                m_opaque_sp->GetQueueID(), running_items);
+  return running_items;
 }
 
-SBProcess
-SBQueue::GetProcess ()
-{
-    return m_opaque_sp->GetProcess();
-}
+SBProcess SBQueue::GetProcess() { return m_opaque_sp->GetProcess(); }
 
-lldb::QueueKind
-SBQueue::GetKind ()
-{
-    return m_opaque_sp->GetKind();
-}
+lldb::QueueKind SBQueue::GetKind() { return m_opaque_sp->GetKind(); }