summaryrefslogtreecommitdiff
path: root/src/qcam/assets/feathericons/cloud-drizzle.svg
diff options
context:
space:
mode:
Diffstat (limited to 'src/qcam/assets/feathericons/cloud-drizzle.svg')
0 files changed, 0 insertions, 0 deletions
href='#n57'>57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134
/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
 * Copyright (C) 2021, Google Inc.
 *
 * mutex.h - Mutex classes with clang thread safety annotation
 */

#pragma once

#include <condition_variable>
#include <mutex>

#include <libcamera/base/private.h>

#include <libcamera/base/thread_annotations.h>

namespace libcamera {

/* \todo using Mutex = std::mutex if libc++ is used. */

#ifndef __DOXYGEN__

class LIBCAMERA_TSA_CAPABILITY("mutex") Mutex final
{
public:
	constexpr Mutex()
	{
	}

	void lock() LIBCAMERA_TSA_ACQUIRE()
	{
		mutex_.lock();
	}

	void unlock() LIBCAMERA_TSA_RELEASE()
	{
		mutex_.unlock();
	}

private:
	friend class MutexLocker;

	std::mutex mutex_;
};

class LIBCAMERA_TSA_SCOPED_CAPABILITY MutexLocker final
{
public:
	explicit MutexLocker(Mutex &mutex) LIBCAMERA_TSA_ACQUIRE(mutex)
		: lock_(mutex.mutex_)
	{
	}

	MutexLocker(Mutex &mutex, std::defer_lock_t t) noexcept LIBCAMERA_TSA_EXCLUDES(mutex)
		: lock_(mutex.mutex_, t)
	{
	}

	~MutexLocker() LIBCAMERA_TSA_RELEASE()
	{
	}

	void lock() LIBCAMERA_TSA_ACQUIRE()
	{
		lock_.lock();
	}

	bool try_lock() LIBCAMERA_TSA_TRY_ACQUIRE(true)
	{
		return lock_.try_lock();
	}

	void unlock() LIBCAMERA_TSA_RELEASE()
	{
		lock_.unlock();
	}

private:
	friend class ConditionVariable;

	std::unique_lock<std::mutex> lock_;
};

class ConditionVariable final
{
public:
	ConditionVariable()
	{
	}

	void notify_one() noexcept
	{
		cv_.notify_one();
	}

	void notify_all() noexcept
	{
		cv_.notify_all();
	}

	template<class Predicate>
	void wait(MutexLocker &locker, Predicate stopWaiting)
	{
		cv_.wait(locker.lock_, stopWaiting);
	}

	template<class Rep, class Period, class Predicate>
	bool wait_for(MutexLocker &locker,
		      const std::chrono::duration<Rep, Period> &relTime,
		      Predicate stopWaiting)
	{
		return cv_.wait_for(locker.lock_, relTime, stopWaiting);
	}

private:
	std::condition_variable cv_;
};

#else /* __DOXYGEN__ */

class Mutex final
{
};

class MutexLocker final
{
};

class ConditionVariable final
{
};

#endif /* __DOXYGEN__ */
} /* namespace libcamera */