kreuzberg 4.0.0.pre.rc.29 → 4.0.0.rc1

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

@@ -1,77 +0,0 @@
-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

@@ -1,297 +0,0 @@
-#[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

@@ -1,81 +0,0 @@
-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

@@ -1,145 +0,0 @@
-#![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

@@ -1,57 +0,0 @@
-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;
-}