potok/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2026-07-30 07:43:03 +04:00
Code Packages Releases Wiki Activity

Merge pull request #20039 from sivanov-work:gapi_empty_input

Browse Source 
G-API: Implement variant visit()

* Add variant visitor, use visitor for check compile args

* Fix GAPI UT: variant *compiler

* Aling apply_visior with std, fix indentations

* Fix compilation (included compiler_hints.hpp)

* Fix compilation (due gapi standalone)

* Fix compilation2 (Docs)

* Add Lambdas overload, Refactor visit()

* Add ReturnType auto deduction

* Fix comilation

* Fix compilation

* Fix warnings

* Try to fix MSVC14

* Fix docs

* Try fix Win compile

* Fix Docs again

* Revert GAPI empty input fix

* Apply comment for `tuple_element`

* Add std::decay for std::base_of to work arounf armv7 problem

* Apply review comments

* Apply review comments: added comment & removed unused args

* Fix docs compilation
This commit is contained in:
Sergey Ivanov
2021-07-07 15:33:40 +03:00
committed by GitHub
parent ed2a698392
commit c0f63eb21f
6 changed files with 512 additions and 20 deletions
Download Patch File Download Diff File Expand all files Collapse all files
modules/gapi/test/util/variant_tests.cpp
+250
View File
@@ -354,6 +354,20 @@ TEST(Variant, Get)
EXPECT_THROW(util::get<int>(cv2), util::bad_variant_access);
}
TEST(Variant, GetIndexed)
{
const TestVar cv(42);
// Test const& get()
EXPECT_EQ(42, util::get<0>(cv));
EXPECT_THROW(util::get<1>(cv), util::bad_variant_access);
// Test &get
TestVar cv2(std::string("42"));
EXPECT_EQ("42", util::get<1>(cv2));
EXPECT_THROW(util::get<0>(cv2), util::bad_variant_access);
}
TEST(Variant, GetWrite)
{
util::variant<int, std::string> v(42);
@@ -486,4 +500,240 @@ TEST(Variant, EXT_IndexOf)
static_assert(6u == V::index_of<MyClass>(), "Index is incorrect");
}
namespace test_validation
{
struct MyType
{
friend std::ostream& operator<<(std::ostream& out, const MyType& src)
{
return out << "MyType"; (void) src;
}
};
class MyClass
{
friend std::ostream& operator<<(std::ostream& out, const MyClass& src)
{
return out << "MyClass"; (void) src;
}
};
struct MyBoolParamIndexedVisitor : cv::util::static_indexed_visitor<bool, MyBoolParamIndexedVisitor>
{
MyBoolParamIndexedVisitor(std::ostream &output) : out(output) {}
template<class Type>
bool visit(std::size_t index, Type val, int check)
{
bool result = false;
out << index << ":" << val <<",";
if(std::is_same<Type, int>::value)
{
result = !memcmp(&val, &check, sizeof(int));
}
return result;
}
std::ostream &out;
};
struct MyBoolNoParamNonIndexedVisitor : cv::util::static_indexed_visitor<bool, MyBoolNoParamNonIndexedVisitor>
{
MyBoolNoParamNonIndexedVisitor(std::ostream &output) : out(output) {}
template<class Type>
bool visit(std::size_t index, Type val)
{
out << index << ":" << val <<",";
return true;
}
std::ostream &out;
};
struct MyVoidNoParamNonIndexedVisitor : cv::util::static_visitor<void, MyVoidNoParamNonIndexedVisitor>
{
MyVoidNoParamNonIndexedVisitor(std::ostream &output) : out(output) {}
template<class Type>
void visit(Type val)
{
out << val << ",";
}
std::ostream &out;
};
struct MyVoidNoParamIndexedVisitor : cv::util::static_indexed_visitor<void, MyVoidNoParamIndexedVisitor>
{
MyVoidNoParamIndexedVisitor(std::ostream &output) : out(output) {}
template<class Type>
void visit(std::size_t Index, Type val)
{
out << Index << ":" << val <<",";
}
std::ostream &out;
};
}
TEST(Variant, DynamicVisitor)
{
using V = cv::util::variant<int, double, char, float, test_validation::MyType, test_validation::MyClass>;
V var{42};
{
std::stringstream ss;
test_validation::MyBoolParamIndexedVisitor visitor(ss);
EXPECT_TRUE(cv::util::visit(visitor, var, int{42}));
EXPECT_EQ(ss.str(), std::string("0:42,"));
}
std::stringstream ss;
test_validation::MyBoolNoParamNonIndexedVisitor visitor(ss);
cv::util::visit(visitor, var);
EXPECT_EQ(ss.str(), std::string("0:42,"));
var = double{1.0};
EXPECT_TRUE(cv::util::visit(visitor, var));
EXPECT_EQ(ss.str(), std::string("0:42,1:1,"));
var = char{'a'};
EXPECT_TRUE(cv::util::visit(visitor, var));
EXPECT_EQ(ss.str(), std::string("0:42,1:1,2:a,"));
var = float{6.0};
EXPECT_TRUE(cv::util::visit(visitor, var));
EXPECT_EQ(ss.str(), std::string("0:42,1:1,2:a,3:6,"));
var = test_validation::MyType{};
EXPECT_TRUE(cv::util::visit(visitor, var));
EXPECT_EQ(ss.str(), std::string("0:42,1:1,2:a,3:6,4:MyType,"));
var = test_validation::MyClass{};
EXPECT_TRUE(cv::util::visit(visitor, var));
EXPECT_EQ(ss.str(), std::string("0:42,1:1,2:a,3:6,4:MyType,5:MyClass,"));
}
TEST(Variant, StaticVisitor)
{
using V = cv::util::variant<int, double, char, float, test_validation::MyType, test_validation::MyClass>;
V var{42};
std::stringstream ss;
test_validation::MyVoidNoParamNonIndexedVisitor visitor(ss);
cv::util::visit(visitor, var);
EXPECT_EQ(ss.str(), std::string("42,"));
var = double{1.0};
cv::util::visit(visitor, var);
EXPECT_EQ(ss.str(), std::string("42,1,"));
var = char{'a'};
cv::util::visit(visitor, var);
EXPECT_EQ(ss.str(), std::string("42,1,a,"));
var = float{6.0};
cv::util::visit(visitor, var);
EXPECT_EQ(ss.str(), std::string("42,1,a,6,"));
var = test_validation::MyType{};
cv::util::visit(visitor, var);
EXPECT_EQ(ss.str(), std::string("42,1,a,6,MyType,"));
var = test_validation::MyClass{};
cv::util::visit(visitor, var);
EXPECT_EQ(ss.str(), std::string("42,1,a,6,MyType,MyClass,"));
}
TEST(Variant, StaticIndexedVisitor)
{
using V = cv::util::variant<int, double, char, float, test_validation::MyType, test_validation::MyClass>;
V var{42};
std::stringstream ss;
cv::util::visit(test_validation::MyVoidNoParamIndexedVisitor {ss}, var);
EXPECT_EQ(ss.str(), std::string("0:42,"));
var = double{1.0};
cv::util::visit(test_validation::MyVoidNoParamIndexedVisitor (ss), var);
EXPECT_EQ(ss.str(), std::string("0:42,1:1,"));
var = char{'a'};
cv::util::visit(test_validation::MyVoidNoParamIndexedVisitor (ss), var);
EXPECT_EQ(ss.str(), std::string("0:42,1:1,2:a,"));
var = float{6.0};
cv::util::visit(test_validation::MyVoidNoParamIndexedVisitor (ss), var);
EXPECT_EQ(ss.str(), std::string("0:42,1:1,2:a,3:6,"));
var = test_validation::MyType{};
cv::util::visit(test_validation::MyVoidNoParamIndexedVisitor (ss), var);
EXPECT_EQ(ss.str(), std::string("0:42,1:1,2:a,3:6,4:MyType,"));
var = test_validation::MyClass{};
cv::util::visit(test_validation::MyVoidNoParamIndexedVisitor (ss), var);
EXPECT_EQ(ss.str(), std::string("0:42,1:1,2:a,3:6,4:MyType,5:MyClass,"));
}
TEST(Variant, LambdaVisitor)
{
using V = cv::util::variant<int, double, char, float, test_validation::MyType, test_validation::MyClass>;
V var{42};
{
cv::util::visit(cv::util::overload_lambdas(
[](int value) {
EXPECT_EQ(value, 42);
},
[](double) {
ADD_FAILURE() << "can't be called for `double`";
},
[](char) {
ADD_FAILURE() << "can't be called for `char`";
},
[](float) {
ADD_FAILURE() << "can't be called for `float`";
},
[](test_validation::MyType) {
ADD_FAILURE() << "can't be called for `MyType`";
},
[](test_validation::MyClass) {
ADD_FAILURE() << "can't be called for `MyClass`";
},
[](std::string) {
ADD_FAILURE() << "can't be called for `std::string`, invalid type";
}
), var);
}
var = 'c';
{
cv::util::visit(cv::util::overload_lambdas(
[](int) {
ADD_FAILURE() << "can't be called for `int`";
},
[](double) {
ADD_FAILURE() << "can't be called for `double`";
},
[](char value) {
EXPECT_EQ(value, 'c');
},
[](float) {
ADD_FAILURE() << "can't be called for `float`";
},
[](test_validation::MyType) {
ADD_FAILURE() << "can't be called for `MyType`";
},
[](test_validation::MyClass) {
ADD_FAILURE() << "can't be called for `MyClass`";
},
[](std::string) {
ADD_FAILURE() << "can't be called for `std::string`, invalid type";
}
), var);
}
}
} // namespace opencv_test