NekoCWD/libcamera
NekoCWD/libcamera
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages 7 Wiki Activity Actions

libcamera: base: utils: Drop defopt

Browse source 
utils::defopt causes compilation issues on gcc 8.0.0 to gcc 8.3.0,
likely due to bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=86521
that was fixed in gcc 8.4.0. gcc 8.3.0 may be considered old (libcamera
requires gcc-8 or newer), but it is shipped by Debian 10 that has LTS
support until mid-2024.

As no workaround has been found to fix compilation on gcc 8.3.0 while
still retaining the functionality of utils::defopt, remove it from the
libcamera base library. This change could be reverted once support for
gcc-8 will be dropped.

Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Reviewed-by: Jacopo Mondi <jacopo@jmondi.org>
Reviewed-by: Kieran Bingham <kieran.bingham@ideasonboard.com>
This commit is contained in:
Laurent Pinchart 2022-10-09 07:34:09 +03:00
parent 603a4d60f6
commit e0e54965df
3 changed files with 0 additions and 88 deletions
Download patch file Download diff file Expand all files Collapse all files

14
include/libcamera/base/utils.h
View file

@ -367,20 +367,6 @@ decltype(auto) abs_diff(const T &a, const T &b)
return a - b; return a - b;
} }
namespace details {
struct defopt_t {
template<typename T>
operator T() const
{
return T{};
}
};
} /* namespace details */
constexpr details::defopt_t defopt;
} /* namespace utils */ } /* namespace utils */
#ifndef __DOXYGEN__ #ifndef __DOXYGEN__

21
src/libcamera/base/utils.cpp
View file

@ -463,27 +463,6 @@ std::string toAscii(const std::string &str)
* \a b * \a b
*/ */
/**
* \var defopt
* \brief Constant used with std::optional::value_or() to create a
* default-constructed object
*
* The std::optional<T>::value_or(U &&default_value) function returns the
* contained value if available, or \a default_value if the std::optional has no
* value. If the desired default value is a default-constructed T, the obvious
* option is to call std::optional<T>::value_or(T{}). This approach has two
* drawbacks:
*
* * The \a default_value T{} is constructed even if the std::optional instance
* has a value, which impacts efficiency.
* * The T{} default constructor needs to be spelled out explicitly in the
* value_or() call, leading to long lines if the type is complex.
*
* The defopt variable solves these issues by providing a value that can be
* passed to std::optional<T>::value_or() and get implicitly converted to a
* default-constructed T.
*/
} /* namespace utils */ } /* namespace utils */
#ifndef __DOXYGEN__ #ifndef __DOXYGEN__

53
test/utils.cpp
View file

@ -170,55 +170,6 @@ protected:
return TestPass; return TestPass;
} }
int testDefopt()
{
static bool defaultConstructed = false;
struct ValueType {
ValueType()
: value_(-1)
{
defaultConstructed = true;
}
ValueType(int value)
: value_(value)
{
}
int value_;
};
/*
* Test that utils::defopt doesn't cause default-construction
* of a ValueType instance when value_or(utils::defopt) is
* called on a std::optional that has a value.
*/
std::optional<ValueType> opt = ValueType(0);
ValueType value = opt.value_or(utils::defopt);
if (defaultConstructed || value.value_ != 0) {
std::cerr << "utils::defopt didn't prevent default construction"
<< std::endl;
return TestFail;
}
/*
* Then test that the ValueType is correctly default-constructed
* when the std::optional has no value.
*/
opt = std::nullopt;
value = opt.value_or(utils::defopt);
if (!defaultConstructed || value.value_ != -1) {
std::cerr << "utils::defopt didn't cause default construction"
<< std::endl;
return TestFail;
}
return TestPass;
}
int run() int run()
{ {
/* utils::hex() test. */ /* utils::hex() test. */
@ -339,10 +290,6 @@ protected:
if (testDuration() != TestPass) if (testDuration() != TestPass)
return TestFail; return TestFail;
/* utils::defopt test. */
if (testDefopt() != TestPass)
return TestFail;
return TestPass; return TestPass;
} }
}; };