Mirror/libcamera
1
0
Fork 0
mirror of https://git.libcamera.org/libcamera/libcamera.git synced 2025-07-18 01:45:10 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions

ipa: raspberrypi: Reformat RPiController::Metadata class header

Browse source 
Rearrange header includes to be in alphabetical order.
Add whitespace to class definition to match libcamera coding guidelines.
Fix a typo in the comment showing an example of scoped locks.

There are no functional changes in this commit.

Signed-off-by: Naushir Patuck <naush@raspberrypi.com>
Reviewed-by: David Plowman <david.plowman@raspberrypi.com>
Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
This commit is contained in:
Naushir Patuck 2021-05-10 10:58:11 +01:00 • committed by Laurent Pinchart
parent 3099e91c7b
commit 340477f987
1 changed files with 16 additions and 7 deletions
Download patch file Download diff file Expand all files Collapse all files

23
src/ipa/raspberrypi/controller/metadata.hpp
View file

@ -1,6 +1,6 @@
/* SPDX-License-Identifier: BSD-2-Clause */ /* SPDX-License-Identifier: BSD-2-Clause */
/* /*
* Copyright (C) 2019, Raspberry Pi (Trading) Limited * Copyright (C) 2019-2021, Raspberry Pi (Trading) Limited
* *
* metadata.hpp - general metadata class * metadata.hpp - general metadata class
*/ */
@ -9,22 +9,25 @@
// A simple class for carrying arbitrary metadata, for example about an image. // A simple class for carrying arbitrary metadata, for example about an image.
#include <any> #include <any>
#include <string>
#include <mutex>
#include <map> #include <map>
#include <memory> #include <memory>
#include <mutex>
#include <string>
namespace RPiController { namespace RPiController {
class Metadata class Metadata
{ {
public: public:
template<typename T> void Set(std::string const &tag, T const &value) template<typename T>
void Set(std::string const &tag, T const &value)
{ {
std::lock_guard<std::mutex> lock(mutex_); std::lock_guard<std::mutex> lock(mutex_);
data_[tag] = value; data_[tag] = value;
} }
template<typename T> int Get(std::string const &tag, T &value) const
template<typename T>
int Get(std::string const &tag, T &value) const
{ {
std::lock_guard<std::mutex> lock(mutex_); std::lock_guard<std::mutex> lock(mutex_);
auto it = data_.find(tag); auto it = data_.find(tag);
@ -33,11 +36,13 @@ public:
value = std::any_cast<T>(it->second); value = std::any_cast<T>(it->second);
return 0; return 0;
} }
void Clear() void Clear()
{ {
std::lock_guard<std::mutex> lock(mutex_); std::lock_guard<std::mutex> lock(mutex_);
data_.clear(); data_.clear();
} }
Metadata &operator=(Metadata const &other) Metadata &operator=(Metadata const &other)
{ {
std::lock_guard<std::mutex> lock(mutex_); std::lock_guard<std::mutex> lock(mutex_);
@ -45,7 +50,9 @@ public:
data_ = other.data_; data_ = other.data_;
return *this; return *this;
} }
template<typename T> T *GetLocked(std::string const &tag)
template<typename T>
T *GetLocked(std::string const &tag)
{ {
// This allows in-place access to the Metadata contents, // This allows in-place access to the Metadata contents,
// for which you should be holding the lock. // for which you should be holding the lock.
@ -54,15 +61,17 @@ public:
return nullptr; return nullptr;
return std::any_cast<T>(&it->second); return std::any_cast<T>(&it->second);
} }
template<typename T> template<typename T>
void SetLocked(std::string const &tag, T const &value) void SetLocked(std::string const &tag, T const &value)
{ {
// Use this only if you're holding the lock yourself. // Use this only if you're holding the lock yourself.
data_[tag] = value; data_[tag] = value;
} }
// Note: use of (lowercase) lock and unlock means you can create scoped // Note: use of (lowercase) lock and unlock means you can create scoped
// locks with the standard lock classes. // locks with the standard lock classes.
// e.g. std::lock_guard<PisP::Metadata> lock(metadata) // e.g. std::lock_guard<RPiController::Metadata> lock(metadata)
void lock() { mutex_.lock(); } void lock() { mutex_.lock(); }
void unlock() { mutex_.unlock(); } void unlock() { mutex_.unlock(); }