ZipCrc Rust Reference Documentation
ZipCrc
Current Version: 11.6.1
Chilkat.ZipCrc
Use
Use
Use
Use
Call
Use Calculate ZIP-compatible CRC32 values for files, bytes, strings, and streamed data.
Chilkat.ZipCrc calculates the 32-bit CRC value used in ZIP file
headers. It can compute CRC32 values for in-memory byte arrays,
BinData, StringBuilder content, strings using a
specified character encoding, and entire files. It also supports streaming
CRC calculation, allowing applications to process large or incremental data
in chunks without holding the full input in memory.
CRC32 for byte data
CalculateCrc to calculate a ZIP-style CRC32 value for
an in-memory byte array.
BinData support
CrcBd when the input bytes are already stored in a
Chilkat.BinData object.
String CRCs
CrcString or CrcSb to calculate CRC32 for
text using a specific charset such as utf-8,
utf-16, or windows-1252.
File CRCs
FileCrc to calculate the CRC32 of a file while streaming
the file contents to keep memory usage small and constant.
Streaming calculation
BeginStream, add chunks with MoreData, and
finish with EndStream when data arrives incrementally.
Hex formatting
ToHex to convert a 32-bit CRC integer into a readable
hexadecimal string.
FileCrc for files, CalculateCrc or
CrcBd for binary data already in memory, and
CrcString or CrcSb for text where the byte
representation depends on a charset. For large or chunked input, initialize
the CRC with BeginStream, feed each block with
MoreData, and call EndStream to obtain the final
CRC32 value.
Object Creation
// Cargo.toml:
// [dependencies]
// chilkat = "11.6"
use chilkat::ZipCrc;
// Once per process, before any other Chilkat call:
chilkat::unlock_bundle("Anything for 30-day trial")?; // shorthand for Global::new().unlock_bundle(..)
let zip_crc = ZipCrc::new();
// ... the native object is freed when `zip_crc` goes out of scope.Creates the underlying native Chilkat object (ZipCrc also implements Default). Every method takes &self, so the object never needs to be declared mut. A ZipCrc is Send but not Sync: it may be moved to another thread, but a reference to it cannot be shared between threads at the same time.
The native object is freed when the ZipCrc is dropped — when it goes out of scope, or explicitly with drop(zip_crc). There is no Dispose method to call.
Errors
Methods that can fail return chilkat::Result<T>, which is Result<T, chilkat::Error>: a method whose only outcome is success or failure returns Result<()>, a method producing a string or an object returns Result<String> or Result<ZipCrc>. The error carries the object's LastErrorText at the time of the failure (Error::last_error_text), the class and method names, and implements std::error::Error, so ? works in any function returning chilkat::Result or a Box<dyn Error>. Properties never fail, and methods that answer a question (has_..., is_..., ...) return a plain bool.
match zip_crc.some_method(...) {
Ok(value) => println!("{value:?}"),
Err(e) => eprintln!("{}", e.last_error_text()),
}Properties
DebugLogFilePath
pub fn debug_log_file_path(&self) -> String
pub fn set_debug_log_file_path(&self, value: &str)
If set to a file path, this property logs the LastErrorText of each Chilkat method or property call to the specified file. This logging helps identify the context and history of Chilkat calls leading up to any crash or hang, aiding in debugging.
Enabling the VerboseLogging property provides more detailed information. This property is mainly used for debugging rare instances where a Chilkat method call causes a hang or crash, which should generally not happen.
Possible causes of hangs include:
- A timeout property set to 0, indicating an infinite timeout.
- A hang occurring within an event callback in the application code.
- An internal bug in the Chilkat code causing the hang.
LastErrorHtml
Provides HTML-formatted information about the last called method or property. If a method call fails or behaves unexpectedly, check this property for details. Note that information is available regardless of the method call's success.
topLastErrorText
Provides plain text information about the last called method or property. If a method call fails or behaves unexpectedly, check this property for details. Note that information is available regardless of the method call's success.
LastErrorXml
Provides XML-formatted information about the last called method or property. If a method call fails or behaves unexpectedly, check this property for details. Note that information is available regardless of the method call's success.
topLastMethodSuccess
pub fn last_method_success(&self) -> bool
pub fn set_last_method_success(&self, value: bool)
Indicates the success or failure of the most recent method call: true means success, false means failure. This property remains unchanged by property setters or getters. This method is present to address challenges in checking for null or Nothing returns in certain programming languages. Note: This property does not apply to methods that return integer values or to boolean-returning methods where the boolean does not indicate success or failure.
VerboseLogging
pub fn verbose_logging(&self) -> bool
pub fn set_verbose_logging(&self, value: bool)
If set to true, then the contents of LastErrorText (or LastErrorXml, or LastErrorHtml) may contain more verbose information. The default value is false. Verbose logging should only be used for debugging. The potentially large quantity of logged information may adversely affect peformance.
Version
Methods
BeginStream
Provides a way to calculate a CRC by streaming the data a chunk at a time. An application would start by calling BeginStream. Then it would add data by calling MoreData for each additional chunk. After the last chunk has been processed, the EndStream method is called to return the CRC.
topCrcBd
Calculates a CRC32 for the bytes contained in bd.
CrcSb
Calculates a CRC32 for the string contained in sb. The charset is the byte representation to be used for the sb when calculating the CRC32. It can be utf-8, utf-16, windows-1252, iso-8859-1, or any of the character encodings (charsets) listed at the link below.
CrcString
Calculates a CRC32 for a string. The charset is the byte representation to be used for the str when calculating the CRC32. It can be utf-8, utf-16, windows-1252, iso-8859-1, or any of the character encodings (charsets) listed at the link below.
EndStream
Finalizes and returns the Zip CRC value calculated by calling BeginStream followed by multiple calls to MoreData.
topFileCrc
Calculates the CRC32 of a file. The data contained in the file is streamed for the calculation to keep the memory footprint small and constant. Returns the CRC32 of the file.
ToHex
Events
All Chilkat methods are synchronous: the call returns when the work is done. During a call, ZipCrc raises three events so your application can show progress and offer a way out. Implement the chilkat::EventHandler trait (every method has a do-nothing default, so implement only the events you need) and install it with set_event_handler:
use chilkat::{ZipCrc, EventHandler};
struct Progress;
impl EventHandler for Progress {
fn percent_done(&mut self, pct: i32) -> bool {
println!("{pct}%");
false // return true to abort the method in progress
}
fn progress_info(&mut self, name: &str, value: &str) {
println!("{name}: {value}");
}
}
let zip_crc = ZipCrc::new();
zip_crc.set_event_handler(Progress);
zip_crc.set_heartbeat_ms(250); // raise abort_check 4 times per second during Chilkat callsFor a one-off handler the closure methods avoid writing a type; they may be combined, and each replaces the previously set closure for that one event (installing a closure removes a trait handler set earlier, and vice versa):
zip_crc.on_percent_done(|pct| { println!("{pct}%"); false });
zip_crc.on_progress_info(|name, value| println!("{name}: {value}"));Installs handler as the receiver of this object's events, replacing any handler or closures set earlier. The object owns the handler, which must be Send + 'static.
Removes the handler and any closures; events are no longer delivered.
AbortCheck fires at regular intervals controlled by the HeartbeatMs property (0, the default, disables it); PercentDone fires when an operation's completion percentage is known; ProgressInfo delivers named progress values. Returning true from abort_check or percent_done aborts the running method, which then returns Err.
Events fire on the thread that called the method, before that method returns. A panic inside a handler aborts the running method and is re-raised to the caller once the native library has returned, so it never unwinds through C frames. To abort a long operation from another thread, share an Arc<AtomicBool> with an abort_check handler, or set the object's AbortCurrent property to true.
AbortCheck
fn abort_check(&mut self) -> bool
Enables a method call to be aborted by triggering the AbortCheck event at intervals defined by the HeartbeatMs property. If HeartbeatMs is set to its default value of 0, no events will occur. For instance, set HeartbeatMs to 200 to trigger 5 AbortCheck events per second.
Example (closure form; the EventHandler trait method is equivalent):
zip_crc.set_heartbeat_ms(250); // call abort_check 4 times per second
let stop = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
let flag = stop.clone();
zip_crc.on_abort_check(move || flag.load(std::sync::atomic::Ordering::Relaxed));
// ... another thread may now abort the method in progress with stop.store(true, Ordering::Relaxed)PercentDone
fn percent_done(&mut self, pct: i32) -> bool
This provides the percentage completion for any method involving network communications or time-consuming processing, assuming the progress can be measured as a percentage. This event is triggered only when it's possible and logical to express the operation's progress as a percentage. The pct_done argument will range from 1 to 100. For methods that finish quickly, the number of PercentDone callbacks may vary, but the final callback will have pct_done equal to 100. For longer operations, callbacks will not exceed one per percentage point (e.g., 1, 2, 3, ..., 98, 99, 100).
The PercentDone callback also acts as an AbortCheck event. For fast methods where PercentDone fires, an AbortCheck event may not trigger since the PercentDone callback already provides an opportunity to abort. For longer operations, where time between PercentDone callbacks is extended, AbortCheck callbacks enable more responsive operation termination.
To abort the operation, set the abort output argument to true. This will cause the method to terminate and return a failure status or corresponding failure value.
Example (closure form; the EventHandler trait method is equivalent):
zip_crc.on_percent_done(|pct| {
// pct ranges from 1 to 100.
println!("Percent done: {pct}");
false // return true to abort the method in progress
});ProgressInfo
fn progress_info(&mut self, name: &str, value: &str)
This event callback provides tag name/value pairs that detail what occurs during a method call. To discover existing tag names, create code to handle the event, emit the pairs, and review them. Most tag names are self-explanatory.
Note: Some Chilkat methods don't fire any ProgressInfo events.
Example (closure form; the EventHandler trait method is equivalent):
zip_crc.on_progress_info(|name, value| println!("{name}: {value}"));