make to clang format

Author: Interstellarss

smart-ptr/cpp_utility.h

@@ -1,32 +1,45 @@
 #ifndef CPP_UTILITY_H
 #define CPP_UTILITY_H
 
-namespace utility{
+namespace utility {
 
 // remove_reference
-template <class T> struct remove_reference {using type = T;};
-template <class T> struct remove_reference<T&> {using type = T;};
-template <class T> struct remove_reference<T&&> {using type = T;};
-
+template <class T> struct remove_reference
+{
+    using type = T;
+};
+template <class T> struct remove_reference<T&>
+{
+    using type = T;
+};
+template <class T> struct remove_reference<T&&>
+{
+    using type = T;
+};
 
 // move
 template <class T>
-constexpr typename remove_reference<T>::type&& move(T&& t) noexcept{
+constexpr typename remove_reference<T>::type&&
+move(T&& t) noexcept
+{
     return static_cast<typename remove_reference<T>::type&&>(t);
 }
 
-
 // forward (optional, for perfect forwarding)
 template <class T>
-constexpr T&& forward(typename remove_reference<T>::type& t) noexcept{
+constexpr T&&
+forward(typename remove_reference<T>::type& t) noexcept
+{
     return static_cast<T&&>(t);
 }
 
 template <class T>
-constexpr T&& forward(typename remove_reference<T>::type&& t) noexcept{
+constexpr T&&
+forward(typename remove_reference<T>::type&& t) noexcept
+{
     return static_cast<T&&>(t);
 }
 
-}
+} // namespace utility
 
-#endif //CPP_UTILITY_H
+#endif // CPP_UTILITY_H

smart-ptr/main.cpp

@@ -2,13 +2,16 @@
 #include <cassert>
 #include "smart_ptr.h"
 
-struct Test {
+struct Test
+{
     int x;
     Test(int v) : x(v) { std::cout << "Test(" << x << ") constructed\n"; }
     ~Test() { std::cout << "Test(" << x << ") destroyed\n"; }
 };
 
-int main() {
+int
+main()
+{
     std::cout << "--- Testing SharedPtr ---\\n";
     {
         SharedPtr<Test> sp1(new Test(10));
@@ -38,15 +41,15 @@ int main() {
         SharedPtr<Test> sp = MakeShared<Test>(30);
         WeakPtr<Test> wp = sp;
         assert(!wp.expired());
-        
+
         SharedPtr<Test> sp2 = wp.lock();
         assert(sp2);
         assert(sp2->x == 30);
         assert(sp.use_count() == 2);
-        
+
         sp2 = nullptr; // release one reference
         assert(sp.use_count() == 1);
-        
+
         sp = nullptr; // release last reference
         assert(wp.expired());
         assert(wp.lock().get() == nullptr);

smart-ptr/ref_block_base.h

@@ -8,51 +8,66 @@
 
 #include "cpp_utility.h"
 
-
-struct RefBlockBase {
+struct RefBlockBase
+{
     // atomic operation
-    std::atomic<size_t> m_shared_count{1};   // when init, create the shared_ptr and own it
-    std::atomic<size_t> m_weak_count{1};    // when init, m_shared_count as one "weak reference"
+    std::atomic<size_t> m_shared_count{1}; // when init, create the shared_ptr and own it
+    std::atomic<size_t> m_weak_count{1};   // when init, m_shared_count as one "weak reference"
 
     virtual ~RefBlockBase() = default;
 
     // type erasure
-    virtual void dispose_resource() = 0;
-    virtual void destroy_self() = 0;
-    virtual void* get_resource_ptr() { return nullptr; }
-
+    virtual void
+    dispose_resource() = 0;
+    virtual void
+    destroy_self() = 0;
+    virtual void*
+    get_resource_ptr()
+    {
+        return nullptr;
+    }
 
     // ---- thread safe counter operation ----
-    void increment_shared() noexcept{
+    void
+    increment_shared() noexcept
+    {
         m_shared_count.fetch_add(1, std::memory_order_relaxed);
     }
 
-    void increment_weak() noexcept{
+    void
+    increment_weak() noexcept
+    {
         m_weak_count.fetch_add(1, std::memory_order_relaxed);
     }
 
-    void decrement_shared() noexcept {
+    void
+    decrement_shared() noexcept
+    {
         // fetch_sub return the value before minus
         // use  acq_rel (Acquire-Release) ensure memory safe
-        if(m_shared_count.fetch_sub(1, std::memory_order_acq_rel) == 1){
+        if (m_shared_count.fetch_sub(1, std::memory_order_acq_rel) == 1) {
             dispose_resource();
             decrement_weak();
         }
     }
 
-    void decrement_weak() noexcept{
-        if (m_weak_count.fetch_sub(1, std::memory_order_acq_rel) == 1){
+    void
+    decrement_weak() noexcept
+    {
+        if (m_weak_count.fetch_sub(1, std::memory_order_acq_rel) == 1) {
             // weak counter oges 0, destroy control block
             destroy_self();
         }
     }
 
-    bool try_increment_shared() noexcept {
+    bool
+    try_increment_shared() noexcept
+    {
         size_t count = m_shared_count.load(std::memory_order_relaxed);
 
-        while(count != 0){
+        while (count != 0) {
             // try to replace count with count + 1
-            if(m_shared_count.compare_exchange_weak(count, count + 1, std::memory_order_acq_rel)){
+            if (m_shared_count.compare_exchange_weak(count, count + 1, std::memory_order_acq_rel)) {
                 return true; // success
             }
         }
@@ -62,44 +77,52 @@ struct RefBlockBase {
 
 // for 'new'
 // Y is the actual type, D is the del type
-template <typename Y, typename D>
-struct RefBlockImpl : public RefBlockBase {
+template <typename Y, typename D> struct RefBlockImpl : public RefBlockBase
+{
     Y* m_resource;
     D m_deleter;
 
-    RefBlockImpl(Y* res, D del)
-        : m_resource(res), m_deleter(utility::move(del)){}
+    RefBlockImpl(Y* res, D del) : m_resource(res), m_deleter(utility::move(del)) {}
 
-    void dispose_resource() override {
+    void
+    dispose_resource() override
+    {
         // call the deleter
         m_deleter(m_resource);
     }
 
-    void destroy_self() override {
+    void
+    destroy_self() override
+    {
         // destroy self
         delete this;
     }
 };
 
-template <typename T>
-struct RefBlockMakeShared : public RefBlockBase{
+template <typename T> struct RefBlockMakeShared : public RefBlockBase
+{
     // T's data will followed directly after this struct
     // use an aligned char array for padding
     alignas(T) char m_storage[sizeof(T)];
 
-    void* get_resource_ptr() override{
+    void*
+    get_resource_ptr() override
+    {
         return reinterpret_cast<T*>(m_storage);
     }
 
-    void dispose_resource() override {
+    void
+    dispose_resource() override
+    {
         // call the deconstruct but not release the memory
-        reinterpret_cast<T*>(m_storage) -> ~T();
+        reinterpret_cast<T*>(m_storage)->~T();
     }
 
-    void destroy_self() override{
+    void
+    destroy_self() override
+    {
         delete this;
     }
 };
 
 #endif
-