class ChainLock

Acquires the lock without backoff, spinning until acquired. This method may be used for the

first chain lock acquired in a transaction as an optimization, since backoff is unnecessary

when no other chain locks are held.

Asserts if a cycle is detected or if any chain locks are currently held.

Acquires the lock, spinning until acquired or returning failure because the caller should

backoff due to contention with a higher priority transaction. Returns true if the lock was

acquired or false if the current transaction should back off. Asserts if a cycle is detected.

Acquires the lock, spinning until acquired or returning failure and backoff or cycle as an out

parameter. Returns true if the lock was acquired or false if acquiring the lock failed.

Attempts to acquire the lock. Returns true if the lock was acquired or false if acquiring the

lock failed. Asserts if a cycle is detected.

Releases the lock.

Asserts that the lock is held by the current transaction.

Asserts that the lock is held by the current transaction and must be released by the

appropriately annotated scope.

A no-op version of assert held. USE WITH EXTREME CAUTION. This tells the static analyzer that

we are holding the lock, but makes no actual runtime effort to verify this.

There are very few places where it is OK to use this method, but here are two examples.

Example 1: We just verified that we have the lock.

```

if (const ChainLock::Result res = my_obj.lock_.Acquire(token);

res != ChainLock::Result::Ok) {

return SomeError;

}

my_obj.lock_MarkHeld();

```

It is OK to skip the actual assert operations here because we just checked to make sure that

the operation succeeded. There is not much point in wasting cycles to do any more.

Example 2: The analyzer is confused about which lock is which because of some tricky code, like

a dynamic downcast.

```

Obj* GetObj(BaseClass* base) TA_REQ(base->lock_) {

DerivedClass* derived = DowncastToDerived(base);

if (derived) {

derived->lock_.MarkHeld();

derived->protected_obj_;

}

return nullptr;

}

```

In this case, we have a base class with a lock, and a derived class with a member which is

protected by the base class's lock. We are also operating in an environment where RTTI is

disabled, so we cannot use dynamic_cast. Instead, we need to write our own dynamic downcast

function using some internal mechanism to ensure that we can do so safely.

We are attempting to fetch the protected member from the derived class, but only if exists,

which is may not if the base class pointer we have does not actually point to an instance of

the derived class.

We have already statically required that the base class instance be locked, but when we perform

our downcast, the static analyzer is not smart enough to understand that base->lock_ is the

same thing as derived->lock_, we we use the no-op form of AssertHeld to satisfy it instead.

Complementary function to MarkNeedsRelease to assure static analysis that the lock is released.

Conditionally marks the lock as held if held by the current transaction.

Returns true if the lock is held by the current transaction.

Returns true if the lock is unlocked.

Syncs the held token value of this lock with the current transaction token. Used for saving and

restoring state in special circumstances that use reserved tokens.