opencv-binding-generator 0.101.0

Binding generator for opencv crate
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
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

// todo support converting pointer + size to slice of Mat and other similar objects
// todo add support for arrays in dnn::DictValue
// todo allow ergonomically combining of enum variants with |
// todo almost everything from the manual module must be connected to the binding generator, not the main crate
// todo check that FN_FaceDetector works at all (receiving InputArray, passing as callback)
// todo public static properties like opencv2/core/base.hpp:384 Hamming::normType
// todo test returning reference to array like cv_MatStep_buf
// todo, allow extension of simple classes for e.g. Elliptic_KeyPoint
// fixme vector<Mat*> get's interpreted as Vector<Mat> which should be wrong (e.g. Layer::forward and Layer::apply_halide_scheduler)
// fixme MatConstIterator::m return Mat**, is it handled correctly?
// fixme VectorOfMat::get allows mutation
// fixme MatSize looks like just a pointer inside a Mat so it should take a lifetime

// copy-pasted form python generator (may be obsolete):
// fixme returning MatAllocator (trait) by reference is bad, check knearestneighbour

#![expect(clippy::nonminimal_bool)] // pattern `!type_ref.as_vector().is_some()` used for more clarity

use std::borrow::Cow;
use std::fs::File;
use std::io::{BufRead, Read, Seek, SeekFrom};
use std::ops::ControlFlow;

pub use abstract_ref_wrapper::AbstractRefWrapper;
use clang::Entity;
pub use class::Class;
pub use constant::Const;
pub use element::{is_opencv_path, opencv_module_from_path, DefaultElement, Element, EntityElement};
#[expect(unused)]
use entity::dbg_clang_entity;
pub use entity::EntityExt;
pub use enumeration::Enum;
use field::Field;
pub use func::{Func, FuncTypeHint, Pred, UsageTracker};
pub use generator::{GeneratedType, Generator, GeneratorVisitor, OpenCvWalker};
pub use generator_env::{ClassKindOverride, ExportConfig, GeneratorEnv};
pub use iterator_ext::IteratorExt;
pub use map_borrowed::CowMapBorrowedExt;
use memoize::{MemoizeMap, MemoizeMapExt};
use smart_ptr::SmartPtr;
pub use string_ext::{CompiledInterpolation, StrExt, StringExt};
pub use supported_module::SupportedModule;
use tuple::Tuple;
#[expect(unused)]
use type_ref::dbg_clang_type;
use type_ref::TypeRef;
pub use type_ref::{Constness, CppNameStyle, NameStyle};
pub use typedef::Typedef;
use vector::Vector;
pub use walker::{EntityWalkerExt, EntityWalkerVisitor};

use crate::debug::NameDebug;

mod abstract_ref_wrapper;
mod class;
pub mod comment;
mod constant;
mod debug;
mod element;
mod entity;
mod enumeration;
mod field;
mod func;
mod function;
mod generator;
mod generator_env;
mod iterator_ext;
mod map_borrowed;
mod memoize;
mod name_pool;
mod renderer;
pub mod settings;
mod smart_ptr;
mod string_ext;
mod supported_module;
#[cfg(test)]
mod test;
mod tuple;
mod type_ref;
mod typedef;
mod vector;
mod walker;
pub mod writer;

fn get_definition_text(entity: Entity) -> String {
	if let Some(range) = entity.get_range() {
		let loc = range.get_start().get_spelling_location();
		let start = loc.offset;
		let end = range.get_end().get_spelling_location().offset;
		let len = usize::try_from(end - start).expect("Definition span is too large");
		let mut def_bytes = vec![0; len];
		let mut source = File::open(loc.file.expect("Can't get file").get_path()).expect("Can't open source file");
		source.seek(SeekFrom::Start(u64::from(start))).expect("Cannot seek");
		source.read_exact(&mut def_bytes).expect("Can't read definition");
		String::from_utf8(def_bytes).expect("Can't parse definition")
	} else {
		unreachable!("Can't get entity range: {:#?}", entity)
	}
}

fn reserved_rename(val: Cow<str>) -> Cow<str> {
	settings::RESERVED_RENAME.get(val.as_ref()).map_or(val, |&v| v.into())
}

#[inline(always)]
pub fn line_reader(mut b: impl BufRead, mut cb: impl FnMut(&str) -> ControlFlow<()>) {
	let mut line = String::with_capacity(256);
	while let Ok(bytes_read) = b.read_line(&mut line) {
		if bytes_read == 0 {
			break;
		}
		if cb(&line).is_break() {
			break;
		}
		line.clear();
	}
}