fast-tlsh 0.1.1

Library to generate / parse / compare TLSH locality sensitive hashes
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

// SPDX-License-Identifier: Apache-2.0 OR MIT
// SPDX-FileCopyrightText: Copyright (C) 2024 Tsukasa OI <floss_ssdeep@irq.a4lg.com>.

// Separate from README.md to use rustdoc-specific features in docs/readme.md.
#![doc = include_str!("_docs/readme.md")]
// no_std
#![cfg_attr(not(any(test, doc, feature = "std")), no_std)]
// Allow using internal features when use of Nightly Rust features are allowed.
#![cfg_attr(feature = "unstable", allow(internal_features))]
// Regular nightly features
#![cfg_attr(feature = "unstable", feature(doc_cfg))]
#![cfg_attr(feature = "unstable", feature(doc_auto_cfg))]
#![cfg_attr(feature = "unstable", feature(core_intrinsics))]
#![cfg_attr(feature = "unstable", feature(coverage_attribute))]
#![cfg_attr(feature = "unstable", feature(error_in_core))]
#![cfg_attr(feature = "unstable", feature(portable_simd))]
#![cfg_attr(
    all(feature = "unstable", target_arch = "arm"),
    feature(arm_target_feature)
)]
#![cfg_attr(
    all(feature = "unstable", target_arch = "arm"),
    feature(stdarch_arm_feature_detection)
)]
#![cfg_attr(
    all(feature = "unstable", target_arch = "arm"),
    feature(stdarch_arm_neon_intrinsics)
)]
// In the code maintenance mode, disallow all warnings.
#![cfg_attr(feature = "maint-code", deny(warnings))]
// Unsafe code is *only* allowed on enabling either arch-specific SIMD
// ("simd-per-arch") or "unsafe" features ("simd-per-arch" and "simd-portable"
// features only indicate those "implemented using SIMD inside this crate").
// If only arch-specific SIMD features are enabled,
// such code requires explicit allow.
#![cfg_attr(
    not(any(feature = "simd-per-arch", feature = "unsafe")),
    forbid(unsafe_code)
)]
#![cfg_attr(
    all(feature = "simd-per-arch", not(feature = "unsafe")),
    deny(unsafe_code)
)]
// Non-test code requires documents (including private items)
#![cfg_attr(not(test), warn(missing_docs))]
#![cfg_attr(not(test), warn(clippy::missing_docs_in_private_items))]
// Unless in the maintenance mode, allow unknown lints.
#![cfg_attr(not(feature = "maint-lints"), allow(unknown_lints))]
// Unless in the maintenance mode, allow old lint names.
#![cfg_attr(not(feature = "maint-lints"), allow(renamed_and_removed_lints))]
// Tests: allow unused unsafe blocks (invariant! does will not need unsafe
// on tests but others may need this macro).
#![cfg_attr(test, allow(unused_unsafe))]
// Tests: non-simplified boolean expressions should be allowed.
#![cfg_attr(test, allow(clippy::nonminimal_bool))]
// Tests: assertion on constants should be allowed.
#![cfg_attr(test, allow(clippy::assertions_on_constants))]

// alloc is required when the "alloc" feature is enabled or testing (including doctests).
#[cfg(any(feature = "alloc", test, doc))]
extern crate alloc;

pub mod _docs;
pub mod buckets;
pub mod compare;
mod compare_easy;
pub mod errors;
pub mod generate;
mod generate_easy;
mod generate_easy_std;
pub mod hash;
pub mod hashes;
mod intrinsics;
pub mod length;
mod macros;
mod params;
mod parse;
#[cfg(not(any(doc, feature = "experiment-pearson")))]
mod pearson;
#[cfg(any(doc, feature = "experiment-pearson"))]
#[cfg_attr(feature = "unstable", doc(cfg(feature = "experiment-pearson")))]
pub mod pearson;

// Easy function re-exports
#[cfg(feature = "easy-functions")]
pub use compare_easy::{compare, compare_with};
#[cfg(feature = "easy-functions")]
pub use generate_easy::{hash_buf, hash_buf_for};
#[cfg(all(feature = "easy-functions", feature = "std"))]
pub use generate_easy_std::{hash_file, hash_file_for, hash_stream, hash_stream_for};

// Trait re-exports
pub use generate::public::GeneratorType;
pub use hash::public::FuzzyHashType;

/// The default fuzzy hash type.
pub type Tlsh = hashes::Normal;

/// The fuzzy hash generator with the default parameter.
pub type TlshGenerator = generate::Generator<Tlsh>;

/// The fuzzy hash generator with specified parameter
/// (or output fuzzy hash type).
///
/// The type parameter `T` must be either:
///
/// *   [`Tlsh`], the default (in this case, you'd better to use
///     [`TlshGenerator`]),
/// *   One of the types in [`hashes`] (each represents a fuzzy hash type
///     and its parameter at the same time) or
/// *   [`hash::FuzzyHash`] with valid parameters.
///
/// unless you have something pointing to these types above somewhere else.
///
/// # Example
///
/// ```
/// use tlsh::prelude::*;
///
/// // Initialize a generator for long fuzzy hash (with 256 buckets)
/// // with long (3-byte) checksum.
/// let mut generator = TlshGeneratorFor::<tlsh::hashes::LongWithLongChecksum>::new();
/// ```
pub type TlshGeneratorFor<T> = generate::Generator<T>;

/// The recommended set (prelude) to import.
///
/// It contains all crate-root types, traits and type aliases
/// suitable for using this crate.  Because some methods require importing
/// certain traits, just importing this can be convenient (not to confuse
/// beginners, those traits are imported as `_`).
///
/// It (intentionally) excludes crate-root easy functions because
/// it's not a big cost to type `tlsh::`.
///
/// It also excludes [`tlsh::hashes`](crate::hashes) to avoid confusion.
pub mod prelude {
    pub use super::FuzzyHashType as _;
    pub use super::GeneratorType as _;

    pub use super::Tlsh;
    pub use super::{TlshGenerator, TlshGeneratorFor};
}

mod tests;