kreuzberg 4.0.0.rc2 → 4.0.0

data/vendor/kreuzberg-tesseract/src/choice_iterator.rs

@@ -0,0 +1,77 @@
+use crate::api::TessDeleteText;
+use crate::error::{Result, TesseractError};
+use std::ffi::CStr;
+use std::os::raw::{c_char, c_float, c_int, c_void};
+use std::sync::{Arc, Mutex};
+
+pub struct ChoiceIterator {
+    handle: Arc<Mutex<*mut c_void>>,
+}
+
+unsafe impl Send for ChoiceIterator {}
+unsafe impl Sync for ChoiceIterator {}
+
+impl ChoiceIterator {
+    /// Creates a new instance of the ChoiceIterator.
+    ///
+    /// # Arguments
+    ///
+    /// * `handle` - Pointer to the ChoiceIterator.
+    pub fn new(handle: *mut c_void) -> Self {
+        ChoiceIterator {
+            handle: Arc::new(Mutex::new(handle)),
+        }
+    }
+
+    /// Gets the next choice.
+    ///
+    /// # Returns
+    ///
+    /// Returns `true` if the next choice is successful, otherwise returns `false`.
+    pub fn next(&self) -> Result<bool> {
+        let handle = self.handle.lock().map_err(|_| TesseractError::MutexLockError)?;
+        Ok(unsafe { TessChoiceIteratorNext(*handle) != 0 })
+    }
+
+    /// Gets the UTF-8 text for the current choice.
+    ///
+    /// # Returns
+    ///
+    /// Returns the UTF-8 text as a `String` if successful, otherwise returns an error.
+    pub fn get_utf8_text(&self) -> Result<String> {
+        let handle = self.handle.lock().map_err(|_| TesseractError::MutexLockError)?;
+        let text_ptr = unsafe { TessChoiceIteratorGetUTF8Text(*handle) };
+        if text_ptr.is_null() {
+            return Err(TesseractError::NullPointerError);
+        }
+        let c_str = unsafe { CStr::from_ptr(text_ptr) };
+        let result = c_str.to_str()?.to_owned();
+        unsafe { TessDeleteText(text_ptr) };
+        Ok(result)
+    }
+
+    /// Gets the confidence of the current choice.
+    ///
+    /// # Returns
+    ///
+    /// Returns the confidence as a `f32`.
+    pub fn confidence(&self) -> Result<f32> {
+        let handle = self.handle.lock().map_err(|_| TesseractError::MutexLockError)?;
+        Ok(unsafe { TessChoiceIteratorConfidence(*handle) })
+    }
+}
+
+impl Drop for ChoiceIterator {
+    fn drop(&mut self) {
+        if let Ok(handle) = self.handle.lock() {
+            unsafe { TessChoiceIteratorDelete(*handle) };
+        }
+    }
+}
+
+unsafe extern "C" {
+    fn TessChoiceIteratorDelete(handle: *mut c_void);
+    fn TessChoiceIteratorNext(handle: *mut c_void) -> c_int;
+    fn TessChoiceIteratorGetUTF8Text(handle: *mut c_void) -> *mut c_char;
+    fn TessChoiceIteratorConfidence(handle: *mut c_void) -> c_float;
+}

data/vendor/kreuzberg-tesseract/src/enums.rs

@@ -0,0 +1,297 @@
+#[repr(C)]
+#[derive(Debug, Clone, Copy, PartialEq)]
+#[allow(non_camel_case_types)]
+pub enum TessPageSegMode {
+    PSM_OSD_ONLY = 0,
+    PSM_AUTO_OSD = 1,
+    PSM_AUTO_ONLY = 2,
+    PSM_AUTO = 3,
+    PSM_SINGLE_COLUMN = 4,
+    PSM_SINGLE_BLOCK_VERT_TEXT = 5,
+    PSM_SINGLE_BLOCK = 6,
+    PSM_SINGLE_LINE = 7,
+    PSM_SINGLE_WORD = 8,
+    PSM_CIRCLE_WORD = 9,
+    PSM_SINGLE_CHAR = 10,
+    PSM_SPARSE_TEXT = 11,
+    PSM_SPARSE_TEXT_OSD = 12,
+    PSM_RAW_LINE = 13,
+    PSM_COUNT = 14,
+}
+
+impl TessPageSegMode {
+    pub fn from_int(value: i32) -> Self {
+        match value {
+            0 => TessPageSegMode::PSM_OSD_ONLY,
+            1 => TessPageSegMode::PSM_AUTO_OSD,
+            2 => TessPageSegMode::PSM_AUTO_ONLY,
+            3 => TessPageSegMode::PSM_AUTO,
+            4 => TessPageSegMode::PSM_SINGLE_COLUMN,
+            5 => TessPageSegMode::PSM_SINGLE_BLOCK_VERT_TEXT,
+            6 => TessPageSegMode::PSM_SINGLE_BLOCK,
+            7 => TessPageSegMode::PSM_SINGLE_LINE,
+            8 => TessPageSegMode::PSM_SINGLE_WORD,
+            9 => TessPageSegMode::PSM_CIRCLE_WORD,
+            10 => TessPageSegMode::PSM_SINGLE_CHAR,
+            11 => TessPageSegMode::PSM_SPARSE_TEXT,
+            12 => TessPageSegMode::PSM_SPARSE_TEXT_OSD,
+            13 => TessPageSegMode::PSM_RAW_LINE,
+            14 => TessPageSegMode::PSM_COUNT,
+            _ => TessPageSegMode::PSM_AUTO,
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy, PartialEq)]
+#[allow(non_camel_case_types)]
+pub enum TessPageIteratorLevel {
+    RIL_BLOCK = 0,
+    RIL_PARA = 1,
+    RIL_TEXTLINE = 2,
+    RIL_WORD = 3,
+    RIL_SYMBOL = 4,
+}
+
+impl TessPageIteratorLevel {
+    pub fn from_int(value: i32) -> Self {
+        match value {
+            0 => TessPageIteratorLevel::RIL_BLOCK,
+            1 => TessPageIteratorLevel::RIL_PARA,
+            2 => TessPageIteratorLevel::RIL_TEXTLINE,
+            3 => TessPageIteratorLevel::RIL_WORD,
+            4 => TessPageIteratorLevel::RIL_SYMBOL,
+            _ => TessPageIteratorLevel::RIL_BLOCK,
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy, PartialEq)]
+#[allow(non_camel_case_types)]
+pub enum TessPolyBlockType {
+    PT_UNKNOWN = 0,
+    PT_FLOWING_TEXT = 1,
+    PT_HEADING_TEXT = 2,
+    PT_PULLOUT_TEXT = 3,
+    PT_EQUATION = 4,
+    PT_INLINE_EQUATION = 5,
+    PT_TABLE = 6,
+    PT_VERTICAL_TEXT = 7,
+    PT_CAPTION_TEXT = 8,
+    PT_FLOWING_IMAGE = 9,
+    PT_HEADING_IMAGE = 10,
+    PT_PULLOUT_IMAGE = 11,
+    PT_HORZ_LINE = 12,
+    PT_VERT_LINE = 13,
+    PT_NOISE = 14,
+    PT_COUNT = 15,
+}
+
+impl TessPolyBlockType {
+    pub fn from_int(value: i32) -> Self {
+        match value {
+            0 => TessPolyBlockType::PT_UNKNOWN,
+            1 => TessPolyBlockType::PT_FLOWING_TEXT,
+            2 => TessPolyBlockType::PT_HEADING_TEXT,
+            3 => TessPolyBlockType::PT_PULLOUT_TEXT,
+            4 => TessPolyBlockType::PT_EQUATION,
+            5 => TessPolyBlockType::PT_INLINE_EQUATION,
+            6 => TessPolyBlockType::PT_TABLE,
+            7 => TessPolyBlockType::PT_VERTICAL_TEXT,
+            8 => TessPolyBlockType::PT_CAPTION_TEXT,
+            9 => TessPolyBlockType::PT_FLOWING_IMAGE,
+            10 => TessPolyBlockType::PT_HEADING_IMAGE,
+            11 => TessPolyBlockType::PT_PULLOUT_IMAGE,
+            12 => TessPolyBlockType::PT_HORZ_LINE,
+            13 => TessPolyBlockType::PT_VERT_LINE,
+            14 => TessPolyBlockType::PT_NOISE,
+            15 => TessPolyBlockType::PT_COUNT,
+            _ => TessPolyBlockType::PT_UNKNOWN,
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy, PartialEq)]
+#[allow(non_camel_case_types)]
+pub enum TessOrientation {
+    ORIENTATION_PAGE_UP = 0,
+    ORIENTATION_PAGE_RIGHT = 1,
+    ORIENTATION_PAGE_DOWN = 2,
+    ORIENTATION_PAGE_LEFT = 3,
+}
+
+impl TessOrientation {
+    pub fn from_int(value: i32) -> Self {
+        match value {
+            0 => TessOrientation::ORIENTATION_PAGE_UP,
+            1 => TessOrientation::ORIENTATION_PAGE_RIGHT,
+            2 => TessOrientation::ORIENTATION_PAGE_DOWN,
+            3 => TessOrientation::ORIENTATION_PAGE_LEFT,
+            _ => TessOrientation::ORIENTATION_PAGE_UP,
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy, PartialEq)]
+#[allow(non_camel_case_types)]
+pub enum TessParagraphJustification {
+    JUSTIFICATION_UNKNOWN = 0,
+    JUSTIFICATION_LEFT = 1,
+    JUSTIFICATION_CENTER = 2,
+    JUSTIFICATION_RIGHT = 3,
+}
+
+impl TessParagraphJustification {
+    pub fn from_int(value: i32) -> Self {
+        match value {
+            0 => TessParagraphJustification::JUSTIFICATION_UNKNOWN,
+            1 => TessParagraphJustification::JUSTIFICATION_LEFT,
+            2 => TessParagraphJustification::JUSTIFICATION_CENTER,
+            3 => TessParagraphJustification::JUSTIFICATION_RIGHT,
+            _ => TessParagraphJustification::JUSTIFICATION_UNKNOWN,
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy, PartialEq)]
+#[allow(non_camel_case_types)]
+pub enum TessWritingDirection {
+    WRITING_DIRECTION_LEFT_TO_RIGHT = 0,
+    WRITING_DIRECTION_RIGHT_TO_LEFT = 1,
+    WRITING_DIRECTION_TOP_TO_BOTTOM = 2,
+}
+
+impl TessWritingDirection {
+    pub fn from_int(value: i32) -> Self {
+        match value {
+            0 => TessWritingDirection::WRITING_DIRECTION_LEFT_TO_RIGHT,
+            1 => TessWritingDirection::WRITING_DIRECTION_RIGHT_TO_LEFT,
+            2 => TessWritingDirection::WRITING_DIRECTION_TOP_TO_BOTTOM,
+            _ => TessWritingDirection::WRITING_DIRECTION_LEFT_TO_RIGHT,
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy, PartialEq)]
+#[allow(non_camel_case_types)]
+pub enum TessTextlineOrder {
+    TEXTLINE_ORDER_LEFT_TO_RIGHT = 0,
+    TEXTLINE_ORDER_RIGHT_TO_LEFT = 1,
+    TEXTLINE_ORDER_TOP_TO_BOTTOM = 2,
+}
+
+impl TessTextlineOrder {
+    pub fn from_int(value: i32) -> Self {
+        match value {
+            0 => TessTextlineOrder::TEXTLINE_ORDER_LEFT_TO_RIGHT,
+            1 => TessTextlineOrder::TEXTLINE_ORDER_RIGHT_TO_LEFT,
+            2 => TessTextlineOrder::TEXTLINE_ORDER_TOP_TO_BOTTOM,
+            _ => TessTextlineOrder::TEXTLINE_ORDER_LEFT_TO_RIGHT,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_page_seg_mode_from_int() {
+        assert_eq!(TessPageSegMode::from_int(0), TessPageSegMode::PSM_OSD_ONLY);
+        assert_eq!(TessPageSegMode::from_int(3), TessPageSegMode::PSM_AUTO);
+        assert_eq!(TessPageSegMode::from_int(10), TessPageSegMode::PSM_SINGLE_CHAR);
+        assert_eq!(TessPageSegMode::from_int(999), TessPageSegMode::PSM_AUTO);
+    }
+
+    #[test]
+    fn test_page_seg_mode_conversion() {
+        let mode = TessPageSegMode::PSM_SINGLE_LINE;
+        assert_eq!(mode as i32, 7);
+    }
+
+    #[test]
+    fn test_page_iterator_level_from_int() {
+        assert_eq!(TessPageIteratorLevel::from_int(0), TessPageIteratorLevel::RIL_BLOCK);
+        assert_eq!(TessPageIteratorLevel::from_int(3), TessPageIteratorLevel::RIL_WORD);
+        assert_eq!(TessPageIteratorLevel::from_int(-1), TessPageIteratorLevel::RIL_BLOCK);
+    }
+
+    #[test]
+    fn test_poly_block_type_from_int() {
+        assert_eq!(TessPolyBlockType::from_int(1), TessPolyBlockType::PT_FLOWING_TEXT);
+        assert_eq!(TessPolyBlockType::from_int(6), TessPolyBlockType::PT_TABLE);
+        assert_eq!(TessPolyBlockType::from_int(100), TessPolyBlockType::PT_UNKNOWN);
+    }
+
+    #[test]
+    fn test_orientation_from_int() {
+        assert_eq!(TessOrientation::from_int(0), TessOrientation::ORIENTATION_PAGE_UP);
+        assert_eq!(TessOrientation::from_int(2), TessOrientation::ORIENTATION_PAGE_DOWN);
+        assert_eq!(TessOrientation::from_int(5), TessOrientation::ORIENTATION_PAGE_UP);
+    }
+
+    #[test]
+    fn test_paragraph_justification_from_int() {
+        assert_eq!(
+            TessParagraphJustification::from_int(1),
+            TessParagraphJustification::JUSTIFICATION_LEFT
+        );
+        assert_eq!(
+            TessParagraphJustification::from_int(3),
+            TessParagraphJustification::JUSTIFICATION_RIGHT
+        );
+        assert_eq!(
+            TessParagraphJustification::from_int(-1),
+            TessParagraphJustification::JUSTIFICATION_UNKNOWN
+        );
+    }
+
+    #[test]
+    fn test_writing_direction_from_int() {
+        assert_eq!(
+            TessWritingDirection::from_int(0),
+            TessWritingDirection::WRITING_DIRECTION_LEFT_TO_RIGHT
+        );
+        assert_eq!(
+            TessWritingDirection::from_int(1),
+            TessWritingDirection::WRITING_DIRECTION_RIGHT_TO_LEFT
+        );
+        assert_eq!(
+            TessWritingDirection::from_int(10),
+            TessWritingDirection::WRITING_DIRECTION_LEFT_TO_RIGHT
+        );
+    }
+
+    #[test]
+    fn test_textline_order_from_int() {
+        assert_eq!(
+            TessTextlineOrder::from_int(0),
+            TessTextlineOrder::TEXTLINE_ORDER_LEFT_TO_RIGHT
+        );
+        assert_eq!(
+            TessTextlineOrder::from_int(2),
+            TessTextlineOrder::TEXTLINE_ORDER_TOP_TO_BOTTOM
+        );
+        assert_eq!(
+            TessTextlineOrder::from_int(99),
+            TessTextlineOrder::TEXTLINE_ORDER_LEFT_TO_RIGHT
+        );
+    }
+
+    #[test]
+    fn test_enums_are_copy() {
+        fn assert_copy<T: Copy>() {}
+        assert_copy::<TessPageSegMode>();
+        assert_copy::<TessPageIteratorLevel>();
+        assert_copy::<TessPolyBlockType>();
+        assert_copy::<TessOrientation>();
+        assert_copy::<TessParagraphJustification>();
+        assert_copy::<TessWritingDirection>();
+        assert_copy::<TessTextlineOrder>();
+    }
+}

data/vendor/kreuzberg-tesseract/src/error.rs

@@ -0,0 +1,81 @@
+use std::str::Utf8Error;
+use thiserror::Error;
+
+/// Errors that can occur when using the Tesseract API.
+#[derive(Error, Debug)]
+pub enum TesseractError {
+    #[error("Failed to initialize Tesseract")]
+    InitError,
+    #[error("Failed to set image")]
+    SetImageError,
+    #[error("OCR operation failed")]
+    OcrError,
+    #[error("Invalid UTF-8 in Tesseract output")]
+    Utf8Error(#[from] Utf8Error),
+    #[error("Failed to lock mutex")]
+    MutexLockError,
+    #[error("Failed to set variable")]
+    SetVariableError,
+    #[error("Failed to get variable")]
+    GetVariableError,
+    #[error("Null pointer error")]
+    NullPointerError,
+    #[error("Invalid parameter")]
+    InvalidParameterError,
+    #[error("Layout analysis failed")]
+    AnalyseLayoutError,
+    #[error("Page processing failed")]
+    ProcessPagesError,
+    #[error("I/O error")]
+    IoError,
+    #[error("Mutex error")]
+    MutexError,
+    #[error("Invalid dimensions")]
+    InvalidDimensions,
+    #[error("Invalid bytes per pixel")]
+    InvalidBytesPerPixel,
+    #[error("Invalid bytes per line")]
+    InvalidBytesPerLine,
+    #[error("Invalid image data")]
+    InvalidImageData,
+    #[error("Uninitialized error")]
+    UninitializedError,
+}
+
+/// Result type for Tesseract operations.
+pub type Result<T> = std::result::Result<T, TesseractError>;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_error_display() {
+        let error = TesseractError::InitError;
+        assert_eq!(error.to_string(), "Failed to initialize Tesseract");
+
+        let error = TesseractError::SetImageError;
+        assert_eq!(error.to_string(), "Failed to set image");
+
+        let error = TesseractError::OcrError;
+        assert_eq!(error.to_string(), "OCR operation failed");
+    }
+
+    #[test]
+    fn test_utf8_error_conversion() {
+        let invalid_utf8 = vec![0xFF, 0xFE];
+        let utf8_error = std::str::from_utf8(&invalid_utf8).unwrap_err();
+        let tess_error: TesseractError = utf8_error.into();
+
+        match tess_error {
+            TesseractError::Utf8Error(_) => {}
+            _ => panic!("Expected Utf8Error variant"),
+        }
+    }
+
+    #[test]
+    fn test_error_is_send_sync() {
+        fn assert_send_sync<T: Send + Sync>() {}
+        assert_send_sync::<TesseractError>();
+    }
+}

data/vendor/kreuzberg-tesseract/src/lib.rs

@@ -0,0 +1,145 @@
+#![cfg_attr(not(feature = "build-tesseract"), allow(unused_variables, dead_code))]
+#![allow(clippy::arc_with_non_send_sync)]
+#![allow(clippy::missing_transmute_annotations)]
+#![allow(clippy::type_complexity)]
+#![allow(clippy::new_without_default)]
+#![allow(clippy::not_unsafe_ptr_arg_deref)]
+#![allow(clippy::cmp_null)]
+
+//! # tesseract-rs
+//!
+//! `tesseract-rs` provides safe Rust bindings for Tesseract OCR with built-in compilation
+//! of Tesseract and Leptonica libraries. This crate aims to make OCR functionality
+//! easily accessible in Rust projects while handling the complexity of interfacing
+//! with the underlying C++ libraries.
+//!
+//! ## Usage
+//!
+//! Here's a basic example of how to use `tesseract-rs`:
+//!
+//! ```rust
+//! use std::path::PathBuf;
+//! use std::error::Error;
+//! use kreuzberg_tesseract::TesseractAPI;
+//!
+//! fn get_default_tessdata_dir() -> PathBuf {
+//!     if cfg!(target_os = "macos") {
+//!         let home_dir = std::env::var("HOME").expect("HOME environment variable not set");
+//!         PathBuf::from(home_dir)
+//!             .join("Library")
+//!             .join("Application Support")
+//!             .join("tesseract-rs")
+//!             .join("tessdata")
+//!     } else if cfg!(target_os = "linux") {
+//!         let home_dir = std::env::var("HOME").expect("HOME environment variable not set");
+//!         PathBuf::from(home_dir)
+//!             .join(".tesseract-rs")
+//!             .join("tessdata")
+//!     } else if cfg!(target_os = "windows") {
+//!         PathBuf::from(std::env::var("APPDATA").expect("APPDATA environment variable not set"))
+//!             .join("tesseract-rs")
+//!             .join("tessdata")
+//!     } else {
+//!         panic!("Unsupported operating system");
+//!     }
+//! }
+//!
+//! fn get_tessdata_dir() -> PathBuf {
+//!     match std::env::var("TESSDATA_PREFIX") {
+//!         Ok(dir) => {
+//!             let path = PathBuf::from(dir);
+//!             println!("Using TESSDATA_PREFIX directory: {:?}", path);
+//!             path
+//!         }
+//!         Err(_) => {
+//!             let default_dir = get_default_tessdata_dir();
+//!             println!(
+//!                 "TESSDATA_PREFIX not set, using default directory: {:?}",
+//!                 default_dir
+//!             );
+//!             default_dir
+//!         }
+//!     }
+//! }
+//!
+//! fn main() -> Result<(), Box<dyn Error>> {
+//!     let api = TesseractAPI::new();
+//!
+//!     // Get tessdata directory (uses default location or TESSDATA_PREFIX if set)
+//!     let tessdata_dir = get_tessdata_dir();
+//!     api.init(tessdata_dir.to_str().unwrap(), "eng")?;
+//!
+//!     let width = 24;
+//!     let height = 24;
+//!     let bytes_per_pixel = 1;
+//!     let bytes_per_line = width * bytes_per_pixel;
+//!
+//!     // Initialize image data with all white pixels
+//!     let mut image_data = vec![255u8; width * height];
+//!
+//!     // Draw number 9 with clearer distinction
+//!     for y in 4..19 {
+//!         for x in 7..17 {
+//!             // Top bar
+//!             if y == 4 && x >= 8 && x <= 15 {
+//!                 image_data[y * width + x] = 0;
+//!             }
+//!             // Top curve left side
+//!             if y >= 4 && y <= 10 && x == 7 {
+//!                 image_data[y * width + x] = 0;
+//!             }
+//!             // Top curve right side
+//!             if y >= 4 && y <= 11 && x == 16 {
+//!                 image_data[y * width + x] = 0;
+//!             }
+//!             // Middle bar
+//!             if y == 11 && x >= 8 && x <= 15 {
+//!                 image_data[y * width + x] = 0;
+//!             }
+//!             // Bottom right vertical line
+//!             if y >= 11 && y <= 18 && x == 16 {
+//!                 image_data[y * width + x] = 0;
+//!             }
+//!             // Bottom bar
+//!             if y == 18 && x >= 8 && x <= 15 {
+//!                 image_data[y * width + x] = 0;
+//!             }
+//!         }
+//!     }
+//!
+//!     // Set the image data
+//!     api.set_image(&image_data, width.try_into().unwrap(), height.try_into().unwrap(), bytes_per_pixel.try_into().unwrap(), bytes_per_line.try_into().unwrap())?;
+//!
+//!     // Set whitelist for digits only
+//!     api.set_variable("tessedit_char_whitelist", "0123456789")?;
+//!
+//!     // Set PSM mode to single character
+//!     api.set_variable("tessedit_pageseg_mode", "10")?;
+//!
+//!     // Get the recognized text
+//!     let text = api.get_utf8_text()?;
+//!     println!("Recognized text: {}", text.trim());
+//!
+//!     Ok(())
+//! }
+//! ```
+pub use error::{Result, TesseractError};
+mod error;
+mod page_iterator;
+pub use page_iterator::PageIterator;
+mod result_iterator;
+pub use result_iterator::ResultIterator;
+mod choice_iterator;
+pub use choice_iterator::ChoiceIterator;
+mod monitor;
+pub use monitor::TessMonitor;
+mod result_renderer;
+pub use result_renderer::TessResultRenderer;
+mod mutable_iterator;
+pub use mutable_iterator::MutableIterator;
+mod enums;
+pub use enums::{
+    TessOrientation, TessPageIteratorLevel, TessPageSegMode, TessPolyBlockType, TessTextlineOrder, TessWritingDirection,
+};
+mod api;
+pub use api::TesseractAPI;

data/vendor/kreuzberg-tesseract/src/monitor.rs

@@ -0,0 +1,57 @@
+use std::os::raw::{c_int, c_void};
+use std::sync::{Arc, Mutex};
+
+pub struct TessMonitor {
+    handle: Arc<Mutex<*mut c_void>>,
+}
+
+unsafe impl Send for TessMonitor {}
+unsafe impl Sync for TessMonitor {}
+
+impl TessMonitor {
+    /// Creates a new instance of the TessMonitor.
+    ///
+    /// # Returns
+    ///
+    /// Returns the new instance of the TessMonitor.
+    pub fn new() -> Self {
+        let handle = unsafe { TessMonitorCreate() };
+        TessMonitor {
+            handle: Arc::new(Mutex::new(handle)),
+        }
+    }
+
+    /// Sets the deadline for the monitor.
+    ///
+    /// # Arguments
+    ///
+    /// * `deadline` - Deadline in milliseconds.
+    pub fn set_deadline(&self, deadline: i32) {
+        let handle = self.handle.lock().unwrap();
+        unsafe { TessMonitorSetDeadlineMSecs(*handle, deadline) };
+    }
+
+    /// Gets the progress of the monitor.
+    ///
+    /// # Returns
+    ///
+    /// Returns the progress as an `i32`.
+    pub fn get_progress(&self) -> i32 {
+        let handle = self.handle.lock().unwrap();
+        unsafe { TessMonitorGetProgress(*handle) }
+    }
+}
+
+impl Drop for TessMonitor {
+    fn drop(&mut self) {
+        let handle = self.handle.lock().unwrap();
+        unsafe { TessMonitorDelete(*handle) };
+    }
+}
+
+unsafe extern "C" {
+    pub fn TessMonitorCreate() -> *mut c_void;
+    pub fn TessMonitorDelete(monitor: *mut c_void);
+    pub fn TessMonitorSetDeadlineMSecs(monitor: *mut c_void, deadline: c_int);
+    pub fn TessMonitorGetProgress(monitor: *mut c_void) -> c_int;
+}