chore(profiling): run clang-format

Author: KowalskiThomas

ddtrace/internal/datadog/profiling/stack_v2/echion/echion/cache.h

@@ -13,28 +13,31 @@
 
 #define CACHE_MAX_ENTRIES 2048
 
-template <typename K, typename V>
+template<typename K, typename V>
 class LRUCache
 {
-public:
-    LRUCache(size_t capacity) : capacity(capacity) {}
+  public:
+    LRUCache(size_t capacity)
+      : capacity(capacity)
+    {
+    }
 
     Result<std::reference_wrapper<V>> lookup(const K& k);
 
     void store(const K& k, std::unique_ptr<V> v);
 
-private:
+  private:
     size_t capacity;
     std::list<std::pair<K, std::unique_ptr<V>>> items;
     std::unordered_map<K, typename std::list<std::pair<K, std::unique_ptr<V>>>::iterator> index;
 };
 
-template <typename K, typename V>
-void LRUCache<K, V>::store(const K& k, std::unique_ptr<V> v)
+template<typename K, typename V>
+void
+LRUCache<K, V>::store(const K& k, std::unique_ptr<V> v)
 {
     // Check if cache is full
-    if (items.size() >= capacity)
-    {
+    if (items.size() >= capacity) {
         index.erase(items.back().first);
         items.pop_back();
     }
@@ -46,8 +49,9 @@ void LRUCache<K, V>::store(const K& k, std::unique_ptr<V> v)
     index[k] = items.begin();
 }
 
-template <typename K, typename V>
-Result<std::reference_wrapper<V>> LRUCache<K, V>::lookup(const K& k)
+template<typename K, typename V>
+Result<std::reference_wrapper<V>>
+LRUCache<K, V>::lookup(const K& k)
 {
     auto itr = index.find(k);
     if (itr == index.end())

ddtrace/internal/datadog/profiling/stack_v2/echion/echion/config.h

@@ -21,7 +21,8 @@ inline bool ignore_non_running_threads = true;
 inline unsigned int max_frames = 2048;
 
 // ----------------------------------------------------------------------------
-static PyObject* set_interval(PyObject* Py_UNUSED(m), PyObject* args)
+static PyObject*
+set_interval(PyObject* Py_UNUSED(m), PyObject* args)
 {
     unsigned int new_interval;
     if (!PyArg_ParseTuple(args, "I", &new_interval))
@@ -33,19 +34,22 @@ static PyObject* set_interval(PyObject* Py_UNUSED(m), PyObject* args)
 }
 
 // ----------------------------------------------------------------------------
-inline void _set_cpu(int new_cpu)
+inline void
+_set_cpu(int new_cpu)
 {
     cpu = new_cpu;
 }
 
 // ----------------------------------------------------------------------------
-inline void _set_ignore_non_running_threads(bool new_ignore_non_running_threads)
+inline void
+_set_ignore_non_running_threads(bool new_ignore_non_running_threads)
 {
     ignore_non_running_threads = new_ignore_non_running_threads;
 }
 
 // ----------------------------------------------------------------------------
-static PyObject* set_cpu(PyObject* Py_UNUSED(m), PyObject* args)
+static PyObject*
+set_cpu(PyObject* Py_UNUSED(m), PyObject* args)
 {
     int new_cpu;
     if (!PyArg_ParseTuple(args, "p", &new_cpu))
@@ -57,7 +61,8 @@ static PyObject* set_cpu(PyObject* Py_UNUSED(m), PyObject* args)
 }
 
 // ----------------------------------------------------------------------------
-static PyObject* set_max_frames(PyObject* Py_UNUSED(m), PyObject* args)
+static PyObject*
+set_max_frames(PyObject* Py_UNUSED(m), PyObject* args)
 {
     unsigned int new_max_frames;
     if (!PyArg_ParseTuple(args, "I", &new_max_frames))

ddtrace/internal/datadog/profiling/stack_v2/echion/echion/cpython/tasks.h

@@ -28,70 +28,55 @@ enum class ErrorKind
     RendererError,
 };
 
-template <typename T>
+template<typename T>
 class [[nodiscard]] Result
 {
-public:
+  public:
     // Factories
-    static Result ok(const T& v)
-    {
-        return Result(v);
-    }
-    static Result ok(T&& v)
-    {
-        return Result(std::move(v));
-    }
-    static Result error(ErrorKind e) noexcept
-    {
-        return Result(e);
-    }
+    static Result ok(const T& v) { return Result(v); }
+    static Result ok(T&& v) { return Result(std::move(v)); }
+    static Result error(ErrorKind e) noexcept { return Result(e); }
 
     // Constructors
-    Result(const T& v) noexcept(std::is_nothrow_copy_constructible<T>::value) : success_(true)
+    Result(const T& v) noexcept(std::is_nothrow_copy_constructible<T>::value)
+      : success_(true)
     {
         ::new (static_cast<void*>(std::addressof(value_))) T(v);
     }
 
-    Result(T&& v) noexcept(std::is_nothrow_move_constructible<T>::value) : success_(true)
+    Result(T&& v) noexcept(std::is_nothrow_move_constructible<T>::value)
+      : success_(true)
     {
         ::new (static_cast<void*>(std::addressof(value_))) T(std::move(v));
     }
 
-    Result(ErrorKind e) noexcept : success_(false)
+    Result(ErrorKind e) noexcept
+      : success_(false)
     {
         error_ = e;
     }
 
     // Destructor
-    ~Result()
-    {
-        reset();
-    }
+    ~Result() { reset(); }
 
     // Copy ctor
     Result(const Result& other) noexcept(std::is_nothrow_copy_constructible<T>::value)
-        : success_(other.success_)
+      : success_(other.success_)
     {
-        if (success_)
-        {
+        if (success_) {
             ::new (static_cast<void*>(std::addressof(value_))) T(other.value_);
-        }
-        else
-        {
+        } else {
             error_ = other.error_;
         }
     }
 
     // Move ctor
     Result(Result&& other) noexcept(std::is_nothrow_move_constructible<T>::value)
-        : success_(other.success_)
+      : success_(other.success_)
     {
-        if (success_)
-        {
+        if (success_) {
             ::new (static_cast<void*>(std::addressof(value_))) T(std::move(other.value_));
-        }
-        else
-        {
+        } else {
             error_ = other.error_;
         }
     }
@@ -103,23 +88,16 @@ class [[nodiscard]] Result
         if (this == &other)
             return *this;
 
-        if (success_ && other.success_)
-        {
+        if (success_ && other.success_) {
             value_ = other.value_;
-        }
-        else if (success_ && !other.success_)
-        {
+        } else if (success_ && !other.success_) {
             value_.~T();
             success_ = false;
             error_ = other.error_;
-        }
-        else if (!success_ && other.success_)
-        {
+        } else if (!success_ && other.success_) {
             ::new (static_cast<void*>(std::addressof(value_))) T(other.value_);
             success_ = true;
-        }
-        else
-        {  // both errors
+        } else { // both errors
             error_ = other.error_;
         }
         return *this;
@@ -132,75 +110,44 @@ class [[nodiscard]] Result
         if (this == &other)
             return *this;
 
-        if (success_ && other.success_)
-        {
+        if (success_ && other.success_) {
             value_ = std::move(other.value_);
-        }
-        else if (success_ && !other.success_)
-        {
+        } else if (success_ && !other.success_) {
             value_.~T();
             success_ = false;
             error_ = other.error_;
-        }
-        else if (!success_ && other.success_)
-        {
+        } else if (!success_ && other.success_) {
             ::new (static_cast<void*>(std::addressof(value_))) T(std::move(other.value_));
             success_ = true;
-        }
-        else
-        {  // both errors
+        } else { // both errors
             error_ = other.error_;
         }
         return *this;
     }
 
     // Observers
-    explicit operator bool() const noexcept
-    {
-        return success_;
-    }
+    explicit operator bool() const noexcept { return success_; }
 
-    T& operator*() &
-    {
-        return value_;
-    }
-    const T& operator*() const&
-    {
-        return value_;
-    }
-    T&& operator*() &&
-    {
-        return std::move(value_);
-    }
+    T& operator*() & { return value_; }
+    const T& operator*() const& { return value_; }
+    T&& operator*() && { return std::move(value_); }
 
-    T* operator->()
-    {
-        return std::addressof(value_);
-    }
-    const T* operator->() const
-    {
-        return std::addressof(value_);
-    }
+    T* operator->() { return std::addressof(value_); }
+    const T* operator->() const { return std::addressof(value_); }
 
-    bool has_value() const noexcept
-    {
-        return success_;
-    }
+    bool has_value() const noexcept { return success_; }
 
     // If in error, returns default_value
-    template <typename U>
+    template<typename U>
     T value_or(U&& default_value) const
     {
         return success_ ? value_ : static_cast<T>(std::forward<U>(default_value));
     }
 
     // Returns ErrorKind::Undefined when holding a value
-    ErrorKind error() const noexcept
-    {
-        return success_ ? ErrorKind::Undefined : error_;
-    }
+    ErrorKind error() const noexcept { return success_ ? ErrorKind::Undefined : error_; }
 
-private:
+  private:
     // Active member is tracked by success_
     union
     {
@@ -211,46 +158,38 @@ class [[nodiscard]] Result
 
     void reset() noexcept
     {
-        if (success_)
-        {
+        if (success_) {
             value_.~T();
         }
     }
 };
 
 // Specialization for void
-template <>
+template<>
 class [[nodiscard]] Result<void>
 {
-public:
-    static Result ok() noexcept
+  public:
+    static Result ok() noexcept { return Result(true, ErrorKind::Undefined); }
+    static Result error(ErrorKind e) noexcept { return Result(false, e); }
+    Result(ErrorKind e) noexcept
+      : success_(false)
+      , error_(e)
     {
-        return Result(true, ErrorKind::Undefined);
     }
-    static Result error(ErrorKind e) noexcept
-    {
-        return Result(false, e);
-    }
-    Result(ErrorKind e) noexcept : success_(false), error_(e) {}
 
-    explicit operator bool() const noexcept
-    {
-        return success_;
-    }
-    bool has_value() const noexcept
-    {
-        return success_;
-    }
+    explicit operator bool() const noexcept { return success_; }
+    bool has_value() const noexcept { return success_; }
 
     // Returns ErrorKind::Undefined when success
-    ErrorKind error() const noexcept
-    {
-        return success_ ? ErrorKind::Undefined : error_;
-    }
+    ErrorKind error() const noexcept { return success_ ? ErrorKind::Undefined : error_; }
 
-private:
+  private:
     bool success_;
     ErrorKind error_;
 
-    explicit Result(bool s, ErrorKind e) noexcept : success_(s), error_(e) {}
+    explicit Result(bool s, ErrorKind e) noexcept
+      : success_(s)
+      , error_(e)
+    {
+    }
 };