[components][kconfig] 整理Kconfig目录名称和结构 (#5698)

1 files changed, 0 insertions, 512 deletions

diff --git a/components/cplusplus/cpp11/gcc/mutex b/components/cplusplus/cpp11/gcc/mutex
deleted file mode 100644
index 3fdf86632b..0000000000
--- a/components/cplusplus/cpp11/gcc/mutex
+++ /dev/null
@@ -1,512 +0,0 @@
-#pragma once
-
-#if __cplusplus < 201103L
-#error "C++ version lower than C++11"
-#endif
-
-//#if defined(RT_USING_PTHREADS)
-
-#include <pthread.h>
-
-#include <system_error>
-#include <chrono>
-#include <utility>
-#include <functional>
-
-#include "__utils.h"
-
-#define rt_cpp_mutex_t  pthread_mutex_t
-
-namespace std 
-{
-    // Base class on which to build std::mutex and std::timed_mutex
-    class __mutex_base
-    {
-        protected:
-            typedef rt_cpp_mutex_t  __native_type;
-
-            __native_type _m_mutex = PTHREAD_MUTEX_INITIALIZER;
-
-            constexpr __mutex_base() noexcept = default;
-            __mutex_base(const __mutex_base&) = delete;
-            __mutex_base& operator=(const __mutex_base&) = delete;
-    };
-
-    
-    class mutex : private __mutex_base
-    {
-        public:
-            constexpr mutex() = default;
-            ~mutex() = default;
-
-            mutex(const mutex&) = delete;
-            mutex& operator=(const mutex&) = delete;
-
-            void lock()
-            {
-                int err  = pthread_mutex_lock(&_m_mutex);
-
-                if (err)
-                {
-                    throw_system_error(err, "mutex:lock failed.");
-                }
-            }
-
-            bool try_lock() noexcept
-            {
-                return !pthread_mutex_trylock(&_m_mutex);
-            }
-
-            void unlock() noexcept
-            {
-                pthread_mutex_unlock(&_m_mutex);
-            }
-
-            typedef __native_type* native_handle_type;
-
-            native_handle_type native_handle() 
-            {
-                return &_m_mutex;
-            };
-
-    };
-
-    inline int __rt_cpp_recursive_mutex_init(rt_cpp_mutex_t* m)
-    {
-        pthread_mutexattr_t attr;
-        int res;
-
-        res = pthread_mutexattr_init(&attr);
-        if (res)
-            return res;
-        res = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
-        if (res)
-            goto attr_cleanup;
-        res = pthread_mutex_init(m, &attr);
-
-        attr_cleanup:
-            int err = pthread_mutexattr_destroy(&attr);
-            return res ? res : err;
-    }
-
-    class __recursive_mutex_base
-    {
-        protected:
-            typedef rt_cpp_mutex_t __native_type;
-
-            __native_type _m_recursive_mutex;
-
-            __recursive_mutex_base(const __recursive_mutex_base&) = delete;
-            __recursive_mutex_base& operator=(const __recursive_mutex_base&) = delete;
-
-            __recursive_mutex_base()
-            {
-                int err = __rt_cpp_recursive_mutex_init(&_m_recursive_mutex);
-                if (err)
-                    throw_system_error(err, "Recursive mutex failed to construct");
-            }
-
-            ~__recursive_mutex_base()
-            {
-                pthread_mutex_destroy(&_m_recursive_mutex);
-            }
-    };
-
-    class recursive_mutex : private __recursive_mutex_base
-    {
-        public:
-            typedef __native_type* native_handle_type; 
-            recursive_mutex() = default;
-            ~recursive_mutex() = default;
-
-            recursive_mutex(const recursive_mutex&) = delete;
-            recursive_mutex& operator=(const recursive_mutex&) = delete;
-            void lock()
-            {
-                int err = pthread_mutex_lock(&_m_recursive_mutex);
-
-                if (err)
-                    throw_system_error(err, "recursive_mutex::lock failed");
-            }
-
-            bool try_lock() noexcept
-            {
-                return !pthread_mutex_trylock(&_m_recursive_mutex);
-            }
-
-            void unlock() noexcept
-            {
-                pthread_mutex_unlock(&_m_recursive_mutex);
-            }
-
-            native_handle_type native_handle()
-            { return &_m_recursive_mutex; }
-    };
-
-#ifdef RT_PTHREAD_TIMED_MUTEX
-
-    class timed_mutex;
-
-    class recursive_timed_mutex;
-
-#endif // RT_PTHREAD_TIMED_MUTEX
-
-    
-    struct defer_lock_t {};
-    struct try_to_lock_t {};
-    struct adopt_lock_t {}; // take ownership of a locked mtuex
-
-    constexpr defer_lock_t defer_lock { };
-    constexpr try_to_lock_t try_to_lock { };
-    constexpr adopt_lock_t adopt_lock { };
-
-    template <class Mutex> 
-    class lock_guard
-    {
-        public:
-            typedef Mutex mutex_type;
-
-            explicit lock_guard(mutex_type& m) : pm(m) { pm.lock(); }
-            lock_guard(mutex_type& m, adopt_lock_t) noexcept : pm(m)
-            { }
-            ~lock_guard() 
-            { pm.unlock(); }
-
-            lock_guard(lock_guard const&) = delete;
-            lock_guard& operator=(lock_guard const&) = delete;
-
-        private:
-            mutex_type& pm;
-
-    };
-
-    template <class Mutex>
-    class unique_lock
-    {
-        public:
-            typedef Mutex mutex_type;
-
-            unique_lock() noexcept : pm(nullptr), owns(false) { }
-            
-            explicit unique_lock(mutex_type& m) 
-                : pm(std::addressof(m)), owns(false)
-            {
-                lock();
-                owns = true;
-            }
-
-            unique_lock(mutex_type& m, defer_lock_t) noexcept 
-                : pm(std::addressof(m)), owns(false)
-            { }
-
-            unique_lock(mutex_type& m, try_to_lock_t) noexcept
-                : pm(std::addressof(m)), owns(pm->try_lock())
-            { }
-
-            unique_lock(mutex_type& m, adopt_lock_t) noexcept
-                : pm(std::addressof(m)), owns(true)
-            { }
-
-            // any lock-involving timed mutex API is currently only for custom implementations
-            // the standard ones are not available
-            template <class Clock, class Duration>
-            unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time) noexcept
-                : pm(std::addressof(m)), owns(pm->try_lock_until(abs_time))
-            { }
-
-            template <class Rep, class Period>
-            unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time) noexcept
-                : pm(std::addressof(m)), owns(pm->try_lock_for(rel_time))
-            { }
-            
-            ~unique_lock()
-            {
-                if (owns)
-                    unlock();
-            }
-            
-            unique_lock(unique_lock const&) = delete;
-            unique_lock& operator=(unique_lock const&) = delete;
-
-            unique_lock(unique_lock&& u) noexcept
-                : pm(u.pm), owns(u.owns)
-            {
-                u.pm = nullptr;
-                u.owns = false;
-            }
-
-            unique_lock& operator=(unique_lock&& u) noexcept                
-            {
-                if (owns)
-                    unlock();
-                
-                unique_lock(std::move(u)).swap(*this);
-
-                u.pm = nullptr;
-                u.owns = false;
-
-                return *this;
-            }
-
-            void lock()
-            {
-                if (!pm)
-                    throw_system_error(int(errc::operation_not_permitted), 
-                                        "unique_lock::lock: references null mutex");
-                else if (owns)
-                    throw_system_error(int(errc::resource_deadlock_would_occur),
-                                        "unique_lock::lock: already locked" );
-                else {
-                    pm->lock();
-                    owns = true;
-                }
-            }
-
-            bool try_lock()
-            {
-                if (!pm)
-                    throw_system_error(int(errc::operation_not_permitted), 
-                                        "unique_lock::try_lock: references null mutex");
-                else if (owns)
-                    throw_system_error(int(errc::resource_deadlock_would_occur),
-                                        "unique_lock::try_lock: already locked" );
-                else {
-                    owns = pm->try_lock();
-                }
-                return owns;
-            }
-
-            template <class Rep, class Period>
-            bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
-            {
-                if (!pm)
-                    throw_system_error(int(errc::operation_not_permitted),
-                                        "unique_lock::try_lock_for: references null mutex");
-                else if (owns)
-                    throw_system_error(int(errc::resource_deadlock_would_occur),
-                                        "unique_lock::try_lock_for: already locked");
-                else {
-                    owns = pm->try_lock_for(rel_time);
-                }
-                return owns;
-            }
-            
-            template <class Clock, class Duration>
-            bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time)
-            {
-                if (!pm)
-                    throw_system_error(int(errc::operation_not_permitted),
-                                        "unique_lock::try_lock_until: references null mutex");
-                else if (owns)
-                    throw_system_error(int(errc::resource_deadlock_would_occur),
-                                        "unique_lock::try_lock_until: already locked");
-                else {
-                    owns = pm->try_lock_until(abs_time);
-                }
-                return owns;
-            }
-            
-            void unlock()
-            {
-                if (!owns)
-                    throw_system_error(int(errc::operation_not_permitted), 
-                                        "unique_lock::unlock: not locked");
-                else {
-                    pm->unlock();
-                    owns = false;
-                }
-            }
-
-            void swap(unique_lock& u) noexcept
-            {
-                std::swap(pm, u.pm);
-                std::swap(owns, u.owns);
-            }
-
-            mutex_type *release() noexcept
-            {
-                mutex_type* ret_mutex = pm;
-                pm = nullptr;
-                owns = false;
-                
-                return ret_mutex;
-            }
-
-            bool owns_lock() const noexcept
-            { return owns; }
-
-            explicit operator bool() const noexcept
-            { return owns_lock(); }
-
-            mutex_type* mutex() const noexcept
-            { return pm; }
-            
-            
-        private:
-            mutex_type *pm; 
-            bool owns;
-    };
-
-    template <class Mutex>
-    void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y)
-    {
-        x.swap(y);
-    }
-
-    template <class L0, class L1>
-    int try_lock(L0& l0, L1& l1)
-    {
-        unique_lock<L0> u0(l0, try_to_lock); // try to lock the first Lockable
-        // using unique_lock since we don't want to unlock l0 manually if l1 fails to lock
-        if (u0.owns_lock())
-        {
-            if (l1.try_lock()) // lock the second one
-            {
-                u0.release(); // do not let RAII of a unique_lock unlock l0
-                return -1;
-            }
-            else
-                return 1; 
-        }
-        return 0;
-    } 
-
-    
-    template <class L0, class L1, class L2, class... L3>
-    int try_lock(L0& l0, L1& l1, L2& l2, L3&... l3)
-    {
-        int r = 0;
-        unique_lock<L0> u0(l0, try_to_lock);
-        // automatically unlock is done through RAII of unique_lock
-        if (u0.owns_lock())
-        {
-            r = try_lock(l1, l2, l3...);
-            if (r == -1)
-                u0.release();
-            else
-                ++r;
-        }
-        return r;
-    }
-
-    template <class L0, class L1, class L2, class ...L3>
-    void
-    __lock_first(int i, L0& l0, L1& l1, L2& l2, L3&... l3)
-    {
-        while (true)
-        {
-            // we first lock the one that is the most difficult to lock 
-            switch (i) 
-            {
-            case 0:
-                {
-                    unique_lock<L0> u0(l0);
-                    i = try_lock(l1, l2, l3...);
-                    if (i == -1)
-                    {
-                        u0.release();
-                        return;
-                    }
-                }
-                ++i;
-                sched_yield();
-                break;
-            case 1:
-                {
-                    unique_lock<L1> u1(l1);
-                    i = try_lock(l2, l3..., l0);
-                    if (i == -1)
-                    {
-                        u1.release();
-                        return;
-                    }
-                }
-                if (i == sizeof...(L3) + 1) // all except l0 are locked
-                    i = 0;
-                else
-                    i += 2; // since i was two-based above
-                sched_yield();
-                break;
-            default:
-                __lock_first(i - 2, l2, l3..., l0, l1);
-                return;
-            }
-        }
-    }
-
-
-    template <class L0, class L1>
-    void lock(L0& l0, L1& l1)
-    {
-        while (true)
-        {
-            {
-                unique_lock<L0> u0(l0);
-                if (l1.try_lock())
-                {
-                    u0.release();
-                    break;
-                }
-            }
-            sched_yield();
-            // wait and try the other way
-            {
-                unique_lock<L1> u1(l1);
-                if (l0.try_lock())
-                {
-                    u1.release();
-                    break;
-                }
-            }
-            sched_yield();
-        }
-    }
-
-    template <class L0, class L1, class... L2>
-    void lock(L0& l0, L1& l1, L2&... l2)
-    {
-        __lock_first(0, l0, l1, l2...);
-    }
-
-    struct once_flag 
-    {
-        constexpr once_flag() noexcept = default;
-
-        once_flag(const once_flag&) = delete;
-        once_flag& operator=(const once_flag&) = delete;
-
-        template <class Callable, class... Args>
-        friend void call_once(once_flag& flag, Callable&& func, Args&&... args);
-
-        private:
-            pthread_once_t _m_once = PTHREAD_ONCE_INIT;
-    };
-
-    mutex& get_once_mutex();
-    extern function<void()> once_functor;
-    extern void set_once_functor_lock_ptr(unique_lock<mutex>*);
-
-    extern "C" void once_proxy(); // passed into pthread_once
-
-    template <class Callable, class... Args>
-    void call_once(once_flag& flag, Callable&& func, Args&&... args)
-    {
-        // use a lock to ensure the call to the functor
-        // is exclusive to only the first calling thread
-        unique_lock<mutex> functor_lock(get_once_mutex()); 
-
-        auto call_wrapper = std::bind(std::forward<Callable>(func), std::forward<Args>(args)...);
-        once_functor = [&]() { call_wrapper(); };
-
-        set_once_functor_lock_ptr(&functor_lock); // so as to unlock when actually calling
-
-        int err = pthread_once(&flag._m_once, &once_proxy);
-
-        if (functor_lock)
-            set_once_functor_lock_ptr(nullptr);
-        if (err)
-            throw_system_error(err, "call_once failed");
-    }
-}
-
-//#endif //(RT_USING_PTHREADS)
\ No newline at end of file