Struct hyperscan::DatabaseRef

pub struct DatabaseRef<T>(_, _);

A borrowed reference to a Database.

Implementations

impl<T> DatabaseRef<T>where
    T: Mode + 'static,

pub fn id(&self) -> u32

Provides the id of compiled mode of the given database.

pub fn name(&self) -> &'static str

Provides the name of compiled mode of the given database.

impl<T> DatabaseRef<T>

pub fn size(&self) -> Result<usize>

Provides the size of the given database in bytes.

pub fn info(&self) -> Result<String>

Utility function providing information about a database.

impl<T> DatabaseRef<T>

pub fn serialize(&self) -> Result<Malloc<[u8]>>

Serialize a pattern database to a stream of bytes.

Examples

let pattern: Pattern = r"/foo(bar)+/i".parse().unwrap();
let db: BlockDatabase = pattern.left_most().build().unwrap();
let buf = db.serialize().unwrap();
assert!(buf.len() > 0);
assert!(buf.size().unwrap() > 0);
println!("database ({}) need {} bytes", buf.info().unwrap(), buf.size().unwrap());

let deserialized_db: BlockDatabase = buf.deserialize().unwrap();
let mut s = deserialized_db.alloc_scratch().unwrap();
let mut matches = Vec::new();

deserialized_db.scan("hello foobar!", &mut s, |id, from, to, _flags| {
    matches.push(from..to);
    Matching::Continue
}).unwrap();

assert_eq!(matches, vec![6..12]);

pub fn deserialize_at<B: AsRef<[u8]>>(&mut self, bytes: B) -> Result<()>

Reconstruct a pattern database from a stream of bytes previously generated by DatabaseRef::serialize() at a given memory location.

impl DatabaseRef<Block>

pub fn scan<T, F>(
    &self,
    data: T,
    scratch: &ScratchRef,
    on_match_event: F
) -> Result<()>where
    T: AsRef<[u8]>,
    F: MatchEventHandler,

The block (non-streaming) regular expression scanner.

This is the function call in which the actual pattern matching takes place for block-mode pattern databases.

Examples

let db: BlockDatabase = pattern! {"test"; CASELESS | SOM_LEFTMOST}.build().unwrap();
let s = db.alloc_scratch().unwrap();
let mut matches = vec![];

db.scan("foo test bar", &s, |_, from, to, _| {
    matches.push(from..to);
    Matching::Continue
}).unwrap();

assert_eq!(matches, vec![4..8]);

impl DatabaseRef<Vectored>

pub fn scan<I, T, F>(
    &self,
    data: I,
    scratch: &ScratchRef,
    on_match_event: F
) -> Result<()>where
    I: IntoIterator<Item = T>,
    T: AsRef<[u8]>,
    F: MatchEventHandler,

The vectored regular expression scanner.

This is the function call in which the actual pattern matching takes place for vectoring-mode pattern databases.

Examples

let db: VectoredDatabase = pattern!{"test"; CASELESS|SOM_LEFTMOST}.build().unwrap();
let s = db.alloc_scratch().unwrap();

let mut matches = vec![];

db.scan(vec!["foo", "test", "bar"], &s, |id, from, to, _| {
    matches.push(from..to);
    Matching::Continue
}).unwrap();

assert_eq!(matches, vec![3..7]);

impl DatabaseRef<Streaming>

pub fn scan<R, F>(
    &self,
    reader: &mut R,
    scratch: &ScratchRef,
    on_match_event: F
) -> Result<()>where
    R: Read,
    F: MatchEventHandler,

Pattern matching takes place for stream-mode pattern databases.

Examples

const SCAN_BUF_SIZE: usize = 4096;
let mut buf = String::from_utf8(vec![b'x'; SCAN_BUF_SIZE - 2]).unwrap();

buf.push_str("baaab");

let db: StreamingDatabase = pattern! { "a+"; SOM_LEFTMOST }.build().unwrap();
let s = db.alloc_scratch().unwrap();
let mut cur = Cursor::new(buf.as_bytes());
let mut matches = vec![];

db.scan(&mut cur, &s, |_, from, to, _| {
    matches.push((from, to));

    Matching::Continue
})
.unwrap();

assert_eq!(matches, vec![(4095, 4096), (4095, 4097), (4095, 4098)]);

impl<T> DatabaseRef<T>

pub fn alloc_scratch(&self) -> Result<Scratch>

Allocate a “scratch” space for use by Hyperscan.

pub fn realloc_scratch<'a>(
    &'a self,
    s: &'a mut Scratch
) -> Result<&'a mut Scratch>

Reallocate a “scratch” space for use by Hyperscan.

pub fn alloc(&self) -> Result<Scratch>

👎Deprecated:

use alloc_scratch instead

Allocate a “scratch” space for use by Hyperscan.

pub fn realloc(&self, s: &mut Scratch) -> Result<()>

👎Deprecated:

use realloc_scratch instead

Reallocate a “scratch” space for use by Hyperscan.

impl DatabaseRef<Streaming>

pub fn stream_size(&self) -> Result<usize>

Provides the size of the stream state allocated by a single stream opened against the given database.

pub fn open_stream(&self) -> Result<Stream>

Open and initialise a stream.

impl DatabaseRef<Streaming>

pub fn expand_stream(&self, buf: &[u8]) -> Result<Stream>

Decompresses a compressed representation created by StreamRef::compress() into a new stream.

Note: buf must correspond to a complete compressed representation created by StreamRef::compress() of a stream that was opened against db. It is not always possible to detect misuse of this API and behaviour is undefined if these properties are not satisfied.

Examples

let db: StreamingDatabase = pattern! {"test"; SOM_LEFTMOST}.build().unwrap();

let s = db.alloc_scratch().unwrap();
let st = db.open_stream().unwrap();

let mut matches = vec![];

let mut callback = |_, from, to, _| {
    matches.push((from, to));

    Matching::Continue
};

st.scan("foo t", &s, &mut callback).unwrap();
st.scan("es", &s, &mut callback).unwrap();

let mut buf = [0; 8192];
let len = st.compress(&mut buf).unwrap();
st.close(&s, Matching::Terminate).unwrap();

let st2 = db.expand_stream(&buf[..len]).unwrap();
st2.scan("t bar", &s, &mut callback).unwrap();
st2.close(&s, &mut callback).unwrap();

assert_eq!(matches, vec![(4, 8)]);

Trait Implementations

impl<T> AsMut<DatabaseRef<T>> for Database<T>

fn as_mut(&mut self) -> &mut DatabaseRef<T>

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T> AsRef<DatabaseRef<T>> for Database<T>

fn as_ref(&self) -> &DatabaseRef<T>

Converts this type into a shared reference of the (usually inferred) input type.

impl<T> Borrow<DatabaseRef<T>> for Database<T>

fn borrow(&self) -> &DatabaseRef<T>

Immutably borrows from an owned value.

impl<T> BorrowMut<DatabaseRef<T>> for Database<T>

fn borrow_mut(&mut self) -> &mut DatabaseRef<T>

Mutably borrows from an owned value.

impl<T> ForeignTypeRef for DatabaseRef<T>

type CType = hs_database

The raw C type.

unsafe fn from_ptr<'a>(ptr: *mut Self::CType) -> &'a Self

Constructs a shared instance of this type from its raw type.

unsafe fn from_ptr_mut<'a>(ptr: *mut Self::CType) -> &'a mut Self

Constructs a mutable reference of this type from its raw type.

fn as_ptr(&self) -> *mut Self::CType

Returns a raw pointer to the wrapped value.

impl<T> Send for DatabaseRef<T>

impl<T> Sync for DatabaseRef<T>