init

unitree_SDK/include/unitree/common/lock/lock.hpp

@@ -0,0 +1,198 @@
+#ifndef __UT_LOCK_HPP__
+#define __UT_LOCK_HPP__
+
+#include <unitree/common/decl.hpp>
+
+namespace unitree
+{
+namespace common
+{
+enum
+{
+    UT_LOCK_MODE_READ   = 0,
+    UT_LOCK_MODE_WRITE  = 1,
+    UT_LOCK_MODE_UNLCK  = 2
+};
+
+enum
+{
+    UT_LOCK_ENO_INTR     = EINTR,
+    UT_LOCK_ENO_BUSY     = EBUSY,
+    UT_LOCK_ENO_TIMEDOUT = ETIMEDOUT
+};
+
+class Spinlock
+{
+public:
+    explicit Spinlock();
+    ~Spinlock();
+
+    void Lock();
+    void Unlock();
+
+    bool Trylock();
+
+    pthread_spinlock_t & GetNative();
+
+private:
+    pthread_spinlock_t mNative;
+};
+
+class CaspinLock
+{
+public:
+    explicit CaspinLock();
+    ~CaspinLock();
+
+    void Lock();
+    void Unlock();
+
+    bool Trylock();
+
+private:
+    volatile int32_t mData;
+};
+
+class Mutex
+{
+public:
+    explicit Mutex();
+    ~Mutex();
+
+    void Lock();
+    void Unlock();
+
+    bool Trylock();
+
+    pthread_mutex_t & GetNative();
+
+private:
+    pthread_mutex_t mNative;
+};
+
+class Cond
+{
+public:
+    explicit Cond();
+    ~Cond();
+
+    void Wait(Mutex& mutex);
+    bool Wait(Mutex& mutex, uint64_t microsec);
+
+    void Notify();
+    void NotifyAll();
+
+private:
+    pthread_cond_t mNative;
+};
+
+class MutexCond
+{
+public:
+    explicit MutexCond();
+    ~MutexCond();
+
+    void Lock();
+    void Unlock();
+
+    bool Wait(int64_t microsec = 0);
+    void Notify();
+    void NotifyAll();
+
+private:
+    Mutex mMutex;
+    Cond mCond;
+};
+
+class Rwlock
+{
+public:
+    explicit Rwlock();
+    ~Rwlock();
+
+    void Lock(int32_t mode);
+    void Unlock();
+
+    bool Trylock(int32_t mode);
+
+    pthread_rwlock_t & GetNative();
+
+private:
+    pthread_rwlock_t mNative;
+};
+
+class Filelock
+{
+public:
+    explicit Filelock(const std::string& fileName);
+    explicit Filelock(int32_t fd);
+    ~Filelock();
+
+    void Lock(int32_t mode, int64_t start = 0, int64_t len = 0);
+    void Unlock();
+
+    bool Trylock(int32_t mode, int64_t start = 0, int64_t len = 0);
+
+private:
+    void SetLockMember(int32_t mode, int64_t start, int64_t len);
+    void SetLockMode(int32_t mode);
+
+private:
+    int32_t mFd;
+    bool mCloseFd;
+    struct flock mLock;
+};
+
+template<typename LOCK_TYPE>
+class LockGuard
+{
+public:
+    explicit LockGuard(LOCK_TYPE& lockPtr)
+    {
+        mLockPtr = &lockPtr;
+        mLockPtr->Lock();
+    }
+
+    explicit LockGuard(LOCK_TYPE* lockPtr)
+    {
+        mLockPtr = lockPtr;
+        mLockPtr->Lock();
+    }
+
+    ~LockGuard()
+    {
+        mLockPtr->Unlock();
+    }
+
+private:
+    LOCK_TYPE* mLockPtr;
+};
+
+template<typename LOCK_TYPE>
+class RwLockGuard
+{
+public:
+    explicit RwLockGuard(LOCK_TYPE& lockPtr, int32_t mode)
+    {
+        mLockPtr = &lockPtr;
+        lockPtr.Lock(mode);
+    }
+
+    explicit RwLockGuard(LOCK_TYPE* lockPtr, int32_t mode)
+    {
+        mLockPtr = lockPtr;
+        lockPtr->Lock(mode);
+    }
+
+    ~RwLockGuard()
+    {
+        mLockPtr->Unlock();
+    }
+
+private:
+    LOCK_TYPE* mLockPtr;
+};
+}
+}
+
+#endif//__UT_LOCK_HPP__