class Lock

Base lock wrapper type that provides the essential interface required by

Guard

<LockType

, Option> to perform locking and validation. This type wraps

an instance of LockType that is used to perform the actual synchronization.

When lock validation is enabled this type also stores the LockClassId for

the lock class this lock belongs to.

The "lock class" that each lock belongs to is created by each unique

instantiation of the types LockDep

<Class

, LockType, Index> or

SingletonLockDep

<Class

, LockType, LockFlags> below. These types subclass

Lock

<LockType

> to provide type erasure required when virtual accessors are

used to specify capabilities to Clang static lock analysis.

For example, the lock_ members of LockableType and AnotherLockableType below

are different types due to how LockDep

<

> instruments the lock members.

Both unique LockDep

<

> instantiations derive from the same Lock

<LockType

>,

providing a common capability type (erasing the LockDep

<

> type) that may be

used in static lock annotations with the expression "get_lock()".

struct LockableInterface {

virtual ~LockableInterface = 0;

virtual Lock

<fbl

::Mutex>* get_lock() = 0;

virtual void Clear() __TA_REQUIRES(get_lock()) = 0;

};

class LockableType : public LockableInterface {

public:

LockableType() = default;

~LockableType() override = default;

Lock

<fbl

::Mutex>* get_lock() override { return

&lock

_; }

void Clear() override { count_ = 0; }

void Increment() {

Guard

<fbl

::Mutex> guard{get_lock()};

count_++;

}

private:

LOCK_DEP_INSTRUMENT(LockableType, fbl::Mutex) lock_;

int count_ __TA_GUARDED(get_lock()) {0};

};

class AnotherLockableType : public LockableInterface {

public:

AnotherLockableType() = default;

~AnotherLockableType() override = default;

Lock

<fbl

::Mutex>* get_lock() override { return

&lock

_; }

void Clear() override { test_.clear(); }

void Append(const std::string

&

string) {

Guard

<fbl

::Mutex> guard{get_lock()};

text_.append(string)

}

private:

LOCK_DEP_INSTRUMENT(AnotherLockableType, fbl::Mutex) lock_;

std::string text_ __TA_GUARDED(get_lock()) {};

};