From patchwork Sun Jul 25 17:18:23 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Laurent Pinchart X-Patchwork-Id: 13112 Return-Path: X-Original-To: parsemail@patchwork.libcamera.org Delivered-To: parsemail@patchwork.libcamera.org Received: from lancelot.ideasonboard.com (lancelot.ideasonboard.com [92.243.16.209]) by patchwork.libcamera.org (Postfix) with ESMTPS id 8A4D1C322C for ; Sun, 25 Jul 2021 17:18:41 +0000 (UTC) Received: from lancelot.ideasonboard.com (localhost [IPv6:::1]) by lancelot.ideasonboard.com (Postfix) with ESMTP id 057A5687BF; Sun, 25 Jul 2021 19:18:39 +0200 (CEST) Authentication-Results: lancelot.ideasonboard.com; dkim=fail reason="signature verification failed" (1024-bit key; unprotected) header.d=ideasonboard.com header.i=@ideasonboard.com header.b="NNpgTHfR"; dkim-atps=neutral Received: from perceval.ideasonboard.com (perceval.ideasonboard.com [213.167.242.64]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id 3DA366877B for ; Sun, 25 Jul 2021 19:18:37 +0200 (CEST) Received: from pendragon.lan (62-78-145-57.bb.dnainternet.fi [62.78.145.57]) by perceval.ideasonboard.com (Postfix) with ESMTPSA id C58524A8 for ; Sun, 25 Jul 2021 19:18:36 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com; s=mail; t=1627233516; bh=vLytBX/gZIMllE5STYAdBUWnekiqZDrwcVoIeNj9CF0=; h=From:To:Subject:Date:In-Reply-To:References:From; b=NNpgTHfRFbDJmO3LR+HA026yBOUzmBJAm5v5IckULaa0dsOpuKA/rGQPY0A1gBx+J MeHsQpR0ICXPYYMOF/a3yUFSWQMIC4niqm0yB2kx8kg70ux3qNRVbltuq89ctFr/+F 435/6QpfQTgag1UnQFLvS4z4HnPll2uODVfQ8CMo= From: Laurent Pinchart To: libcamera-devel@lists.libcamera.org Date: Sun, 25 Jul 2021 20:18:23 +0300 Message-Id: <20210725171827.23643-2-laurent.pinchart@ideasonboard.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210725171827.23643-1-laurent.pinchart@ideasonboard.com> References: <20210725171827.23643-1-laurent.pinchart@ideasonboard.com> MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH v2 1/5] libcamera: flags: Add type-safe enum-based flags X-BeenThere: libcamera-devel@lists.libcamera.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: libcamera-devel-bounces@lists.libcamera.org Sender: "libcamera-devel" Add a Flags template class that provide type-safe bitwise operators on enum values. This allows using enum types for bit fields, without giving away type-safety as usually done when storing combined flags in integer variables. Signed-off-by: Laurent Pinchart Reviewed-by: Niklas Söderlund Reviewed-by: Jacopo Mondi --- include/libcamera/base/flags.h | 195 +++++++++++++++++++++++++++++ include/libcamera/base/meson.build | 1 + src/libcamera/base/flags.cpp | 192 ++++++++++++++++++++++++++++ src/libcamera/base/meson.build | 1 + 4 files changed, 389 insertions(+) create mode 100644 include/libcamera/base/flags.h create mode 100644 src/libcamera/base/flags.cpp diff --git a/include/libcamera/base/flags.h b/include/libcamera/base/flags.h new file mode 100644 index 000000000000..adec549dccc9 --- /dev/null +++ b/include/libcamera/base/flags.h @@ -0,0 +1,195 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2020, Google Inc. + * + * flags.h - Type-safe enum-based bitfields + */ +#ifndef __LIBCAMERA_BASE_FLAGS_H__ +#define __LIBCAMERA_BASE_FLAGS_H__ + +#include + +namespace libcamera { + +template +class Flags +{ +public: + static_assert(std::is_enum::value, + "Flags<> template parameter must be an enum"); + + using Type = std::underlying_type_t; + + constexpr Flags() + : value_(0) + { + } + + constexpr Flags(E flag) + : value_(static_cast(flag)) + { + } + + constexpr Flags &operator&=(E flag) + { + value_ &= static_cast(flag); + return *this; + } + + constexpr Flags &operator&=(Flags other) + { + value_ &= other.value_; + return *this; + } + + constexpr Flags &operator|=(E flag) + { + value_ |= static_cast(flag); + return *this; + } + + constexpr Flags &operator|=(Flags other) + { + value_ |= other.value_; + return *this; + } + + constexpr Flags &operator^=(E flag) + { + value_ ^= static_cast(flag); + return *this; + } + + constexpr Flags &operator^=(Flags other) + { + value_ ^= other.value_; + return *this; + } + + constexpr bool operator==(E flag) + { + return value_ == static_cast(flag); + } + + constexpr bool operator==(Flags other) + { + return value_ == static_cast(other); + } + + constexpr bool operator!=(E flag) + { + return value_ != static_cast(flag); + } + + constexpr bool operator!=(Flags other) + { + return value_ != static_cast(other); + } + + constexpr explicit operator Type() const + { + return value_; + } + + constexpr explicit operator bool() const + { + return !!value_; + } + + constexpr Flags operator&(E flag) const + { + return Flags(static_cast(value_ & static_cast(flag))); + } + + constexpr Flags operator&(Flags other) const + { + return Flags(static_cast(value_ & other.value_)); + } + + constexpr Flags operator|(E flag) const + { + return Flags(static_cast(value_ | static_cast(flag))); + } + + constexpr Flags operator|(Flags other) const + { + return Flags(static_cast(value_ | other.value_)); + } + + constexpr Flags operator^(E flag) const + { + return Flags(static_cast(value_ ^ static_cast(flag))); + } + + constexpr Flags operator^(Flags other) const + { + return Flags(static_cast(value_ ^ other.value_)); + } + + constexpr Flags operator~() const + { + return Flags(static_cast(~value_)); + } + + constexpr bool operator!() const + { + return !value_; + } + +private: + Type value_; +}; + +#ifndef __DOXYGEN__ +template +struct flags_enable_operators { + static const bool enable = false; +}; + +template +typename std::enable_if_t::enable, Flags> +operator|(E lhs, E rhs) +{ + using type = std::underlying_type_t; + return Flags(static_cast(static_cast(lhs) | static_cast(rhs))); +} + +template +typename std::enable_if_t::enable, Flags> +operator&(E lhs, E rhs) +{ + using type = std::underlying_type_t; + return Flags(static_cast(static_cast(lhs) & static_cast(rhs))); +} + +template +typename std::enable_if_t::enable, Flags> +operator^(E lhs, E rhs) +{ + using type = std::underlying_type_t; + return Flags(static_cast(static_cast(lhs) ^ static_cast(rhs))); +} + +template +typename std::enable_if_t::enable, Flags> +operator~(E rhs) +{ + using type = std::underlying_type_t; + return Flags(static_cast(~static_cast(rhs))); +} + +#define LIBCAMERA_FLAGS_ENABLE_OPERATORS(_enum) \ +template<> \ +struct flags_enable_operators<_enum> { \ + static const bool enable = true; \ +}; + +#else /* __DOXYGEN__ */ + +#define LIBCAMERA_FLAGS_ENABLE_OPERATORS(_enum) + +#endif /* __DOXYGEN__ */ + +} /* namespace libcamera */ + +#endif /* __LIBCAMERA_BASE_FLAGS_H__ */ diff --git a/include/libcamera/base/meson.build b/include/libcamera/base/meson.build index 7c499b558fb0..9feb4b9346d5 100644 --- a/include/libcamera/base/meson.build +++ b/include/libcamera/base/meson.build @@ -9,6 +9,7 @@ libcamera_base_headers = files([ 'event_dispatcher_poll.h', 'event_notifier.h', 'file.h', + 'flags.h', 'log.h', 'message.h', 'object.h', diff --git a/src/libcamera/base/flags.cpp b/src/libcamera/base/flags.cpp new file mode 100644 index 000000000000..3e4320ace7c8 --- /dev/null +++ b/src/libcamera/base/flags.cpp @@ -0,0 +1,192 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2020, Google Inc. + * + * flags.cpp - Type-safe enum-based bitfields + */ + +#include + +/** + * \file base/flags.h + * \brief Enum-based bit fields + */ + +namespace libcamera { + +/** + * \class Flags + * \brief Type-safe container for enum-based bitfields + * + * The Flags template class provides type-safe bitwise operators on enum values. + * It allows using enum types for bitfields, while preventing unsafe casts from + * integer types and mixing of flags from different enum types. + * + * To use the Flags class, declare an enum containing the desired bit flags, and + * use the Flags class to store bitfields based on the enum. If bitwise + * operators on the underlying enum are also desired, they can be enabled with + * the LIBCAMERA_FLAGS_ENABLE_OPERATORS(enum) macro. + */ + +/** + * \typedef Flags::Type + * \brief The underlying data type of the enum + */ + +/** + * \fn Flags::Flags() + * \brief Construct a Flags instance with a zero value + */ + +/** + * \fn Flags::Flags(E flag) + * \brief Construct a Flags instance storing the \a flag + * \param[in] flag The initial value + */ + +/** + * \fn Flags &Flags::operator&=(E flag) + * \brief Store the bitwise AND of this Flags and the \a flag in this Flags + * \param[in] flag The second operand + * \return A reference to this Flags + */ + +/** + * \fn Flags &Flags::operator&=(Flags other) + * \brief Store the bitwise AND of this Flags and the \a other Flags in this Flags + * \param[in] other The second operand + * \return A reference to this Flags + */ + +/** + * \fn Flags &Flags::operator|=(E flag) + * \brief Store the bitwise OR of this Flags and the \a flag in this Flags + * \param[in] flag The second operand + * \return A reference to this Flags + */ + +/** + * \fn Flags &Flags::operator|=(Flags other) + * \brief Store the bitwise OR of this Flags and the \a other Flags in this Flags + * \param[in] other The second operand + * \return A reference to this Flags + */ + +/** + * \fn Flags &Flags::operator^=(E flag) + * \brief Store the bitwise XOR of this Flags and the \a flag in this Flags + * \param[in] flag The second operand + * \return A reference to this Flags + */ + +/** + * \fn Flags &Flags::operator^=(Flags other) + * \brief Store the bitwise XOR of this Flags and the \a other Flags in this Flags + * \param[in] other The second operand + * \return A reference to this Flags + */ + +/** + * \fn bool Flags::operator==(E flag) + * \brief Compare flags for equality + * \param[in] flag The second operand + * \return True if the Flags and \a flag are equal, false otherwise + */ + +/** + * \fn bool Flags::operator==(Flags other) + * \brief Compare flags for equality + * \param[in] other The second operand + * \return True if the Flags and \a other are equal, false otherwise + */ + +/** + * \fn bool Flags::operator!=(E flag) + * \brief Compare flags for non-equality + * \param[in] flag The second operand + * \return True if the Flags and \a flag are not equal, false otherwise + */ + +/** + * \fn bool Flags::operator!=(Flags other) + * \brief Compare flags for non-equality + * \param[in] other The second operand + * \return True if the Flags and \a other are not equal, false otherwise + */ + +/** + * \fn Flags::operator Type() const + * \brief Convert the Flags to the underlying integer type + * \return The Flags value as an integer + */ + +/** + * \fn Flags::operator bool() const + * \brief Convert the Flags to a boolean + * \return True if at least one flag is set, false otherwise + */ + +/** + * \fn Flags Flags::operator&(E flag) const + * \brief Compute the bitwise AND of this Flags and the \a flag + * \param[in] flag The second operand + * \return A Flags containing the result of the AND operation + */ + +/** + * \fn Flags Flags::operator&(Flags other) const + * \brief Compute the bitwise AND of this Flags and the \a other Flags + * \param[in] other The second operand + * \return A Flags containing the result of the AND operation + */ + +/** + * \fn Flags Flags::operator|(E flag) const + * \brief Compute the bitwise OR of this Flags and the \a flag + * \param[in] flag The second operand + * \return A Flags containing the result of the OR operation + */ + +/** + * \fn Flags Flags::operator|(Flags other) const + * \brief Compute the bitwise OR of this Flags and the \a other Flags + * \param[in] other The second operand + * \return A Flags containing the result of the OR operation + */ + +/** + * \fn Flags Flags::operator^(E flag) const + * \brief Compute the bitwise XOR of this Flags and the \a flag + * \param[in] flag The second operand + * \return A Flags containing the result of the XOR operation + */ + +/** + * \fn Flags Flags::operator^(Flags other) const + * \brief Compute the bitwise XOR of this Flags and the \a other Flags + * \param[in] other The second operand + * \return A Flags containing the result of the XOR operation + */ + +/** + * \fn Flags Flags::operator~() const + * \brief Compute the bitwise NOT of this Flags + * \return A Flags containing the result of the NOT operation + */ + +/** + * \fn bool Flags::operator!() const + * \brief Check if flags are set + * \return True if no flags is set, false otherwise + */ + +/** + * \def LIBCAMERA_FLAGS_ENABLE_OPERATORS(enum) + * \brief Enable bitwise operations on the \a enum enumeration + * + * This macro enables the bitwise AND, OR, XOR and NOT operators on the given + * \a enum. This allows the enum values to be safely used in bitwise operations + * with the Flags<> class. + */ + +} /* namespace libcamera */ diff --git a/src/libcamera/base/meson.build b/src/libcamera/base/meson.build index 871721571e98..d799c66d8b3a 100644 --- a/src/libcamera/base/meson.build +++ b/src/libcamera/base/meson.build @@ -7,6 +7,7 @@ libcamera_base_sources = files([ 'event_dispatcher_poll.cpp', 'event_notifier.cpp', 'file.cpp', + 'flags.cpp', 'log.cpp', 'message.cpp', 'object.cpp', From patchwork Sun Jul 25 17:18:24 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Laurent Pinchart X-Patchwork-Id: 13113 Return-Path: X-Original-To: parsemail@patchwork.libcamera.org Delivered-To: parsemail@patchwork.libcamera.org Received: from lancelot.ideasonboard.com (lancelot.ideasonboard.com [92.243.16.209]) by patchwork.libcamera.org (Postfix) with ESMTPS id 86D6DC322C for ; Sun, 25 Jul 2021 17:18:42 +0000 (UTC) Received: from lancelot.ideasonboard.com (localhost [IPv6:::1]) by lancelot.ideasonboard.com (Postfix) with ESMTP id 8B42B687C2; Sun, 25 Jul 2021 19:18:39 +0200 (CEST) Authentication-Results: lancelot.ideasonboard.com; dkim=fail reason="signature verification failed" (1024-bit key; unprotected) header.d=ideasonboard.com header.i=@ideasonboard.com header.b="tsZb7Iak"; dkim-atps=neutral Received: from perceval.ideasonboard.com (perceval.ideasonboard.com [IPv6:2001:4b98:dc2:55:216:3eff:fef7:d647]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id 822EA687B1 for ; Sun, 25 Jul 2021 19:18:37 +0200 (CEST) Received: from pendragon.lan (62-78-145-57.bb.dnainternet.fi [62.78.145.57]) by perceval.ideasonboard.com (Postfix) with ESMTPSA id 234EC56B for ; Sun, 25 Jul 2021 19:18:37 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com; s=mail; t=1627233517; bh=U4LtyIKXI6hFMZhOzfihtra6iXZjZXDgFP4RhNkonoo=; h=From:To:Subject:Date:In-Reply-To:References:From; b=tsZb7Iak1Oyz5AIpzBFTtX1Xixkpg9VdNP7gBfZt0yfy9yn2vyDrmRYn1YEIpUM0S 8bqo749FMvczcVsqGwBCIquAGloByMqmC0z30aMft91HqTiC75CMjZI4lHTz6/XTb4 SGUWyNTUzEmwxdhfv5Zq/oKjK2ltxLEumxyCwr3M= From: Laurent Pinchart To: libcamera-devel@lists.libcamera.org Date: Sun, 25 Jul 2021 20:18:24 +0300 Message-Id: <20210725171827.23643-3-laurent.pinchart@ideasonboard.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210725171827.23643-1-laurent.pinchart@ideasonboard.com> References: <20210725171827.23643-1-laurent.pinchart@ideasonboard.com> MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH v2 2/5] test: Add tests for the Flags class X-BeenThere: libcamera-devel@lists.libcamera.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: libcamera-devel-bounces@lists.libcamera.org Sender: "libcamera-devel" Add tests that exercise the whole API of the Flags class. Signed-off-by: Laurent Pinchart Reviewed-by: Niklas Söderlund --- Changes since v1: - Fix enumerator Beta - Typo fix --- test/flags.cpp | 204 +++++++++++++++++++++++++++++++++++++++++++++++ test/meson.build | 1 + 2 files changed, 205 insertions(+) create mode 100644 test/flags.cpp diff --git a/test/flags.cpp b/test/flags.cpp new file mode 100644 index 000000000000..5a684e6ee11f --- /dev/null +++ b/test/flags.cpp @@ -0,0 +1,204 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Copyright (C) 2020, Google Inc. + * + * flags.cpp - Flags tests + */ + +#include + +#include + +#include "test.h" + +using namespace libcamera; +using namespace std; + +class FlagsTest : public Test +{ +protected: + enum class Option { + First = (1 << 0), + Second = (1 << 1), + Third = (1 << 2), + }; + + using Options = Flags