hyperscan (JavaCPP Presets for Hyperscan 5.4.2-1.5.10 API)

java.lang.Object
- org.bytedeco.hyperscan.presets.hyperscan
- - org.bytedeco.hyperscan.global.hyperscan

All Implemented Interfaces:: InfoMapper

public class hyperscan
extends hyperscan

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`HS_ARCH_ERROR` Unsupported CPU architecture.
`static int`	`HS_BAD_ALIGN` A parameter passed to this function was not correctly aligned.
`static int`	`HS_BAD_ALLOC` The memory allocator (either malloc() or the allocator set with \ref hs_set_allocator()) did not correctly return memory suitably aligned for the largest representable data type on this platform.
`static int`	`HS_COMPILER_ERROR` The pattern compiler failed, and the \ref hs_compile_error_t should be inspected for more detail.
`static long`	`HS_CPU_FEATURES_AVX2` CPU features flag - Intel(R) Advanced Vector Extensions 2 (Intel(R) AVX2) Setting this flag indicates that the target platform supports AVX2 instructions.
`static long`	`HS_CPU_FEATURES_AVX512` CPU features flag - Intel(R) Advanced Vector Extensions 512 (Intel(R) AVX512) Setting this flag indicates that the target platform supports AVX512 instructions, specifically AVX-512BW.
`static long`	`HS_CPU_FEATURES_AVX512VBMI` CPU features flag - Intel(R) Advanced Vector Extensions 512 Vector Byte Manipulation Instructions (Intel(R) AVX512VBMI) Setting this flag indicates that the target platform supports AVX512VBMI instructions.
`static int`	`HS_DB_MODE_ERROR` The given database was built for a different mode of operation.
`static int`	`HS_DB_PLATFORM_ERROR` The given database was built for a different platform (i.e., CPU type).
`static int`	`HS_DB_VERSION_ERROR` The given database was built for a different version of Hyperscan.
`static long`	`HS_EXT_FLAG_EDIT_DISTANCE` Flag indicating that the hs_expr_ext::edit_distance field is used.
`static long`	`HS_EXT_FLAG_HAMMING_DISTANCE` Flag indicating that the hs_expr_ext::hamming_distance field is used.
`static long`	`HS_EXT_FLAG_MAX_OFFSET` Flag indicating that the hs_expr_ext::max_offset field is used.
`static long`	`HS_EXT_FLAG_MIN_LENGTH` Flag indicating that the hs_expr_ext::min_length field is used.
`static long`	`HS_EXT_FLAG_MIN_OFFSET` Flag indicating that the hs_expr_ext::min_offset field is used.
`static int`	`HS_FLAG_ALLOWEMPTY` Compile flag: Allow expressions that can match against empty buffers.
`static int`	`HS_FLAG_CASELESS` Compile flag: Set case-insensitive matching.
`static int`	`HS_FLAG_COMBINATION` Compile flag: Logical combination.
`static int`	`HS_FLAG_DOTALL` Compile flag: Matching a `.` will not exclude newlines.
`static int`	`HS_FLAG_MULTILINE` Compile flag: Set multi-line anchoring.
`static int`	`HS_FLAG_PREFILTER` Compile flag: Enable prefiltering mode for this expression.
`static int`	`HS_FLAG_QUIET` Compile flag: Don't do any match reporting.
`static int`	`HS_FLAG_SINGLEMATCH` Compile flag: Set single-match only mode.
`static int`	`HS_FLAG_SOM_LEFTMOST` Compile flag: Enable leftmost start of match reporting.
`static int`	`HS_FLAG_UCP` Compile flag: Enable Unicode property support for this expression.
`static int`	`HS_FLAG_UTF8` Compile flag: Enable UTF-8 mode for this expression.
`static int`	`HS_INSUFFICIENT_SPACE` Provided buffer was too small.
`static int`	`HS_INVALID` A parameter passed to this function was invalid.
`static int`	`HS_MAJOR` \file \brief The complete Hyperscan API definition.
`static int`	`HS_MINOR`
`static int`	`HS_MODE_BLOCK` Compiler mode flag: Block scan (non-streaming) database.
`static int`	`HS_MODE_NOSTREAM` Compiler mode flag: Alias for \ref HS_MODE_BLOCK.
`static int`	`HS_MODE_SOM_HORIZON_LARGE` Compiler mode flag: use full precision to track start of match offsets in stream state.
`static int`	`HS_MODE_SOM_HORIZON_MEDIUM` Compiler mode flag: use medium precision to track start of match offsets in stream state.
`static int`	`HS_MODE_SOM_HORIZON_SMALL` Compiler mode flag: use limited precision to track start of match offsets in stream state.
`static int`	`HS_MODE_STREAM` Compiler mode flag: Streaming database.
`static int`	`HS_MODE_VECTORED` Compiler mode flag: Vectored scanning database.
`static int`	`HS_NOMEM` A memory allocation failed.
`static long`	`HS_OFFSET_PAST_HORIZON` Callback 'from' return value, indicating that the start of this match was too early to be tracked with the requested SOM_HORIZON precision.
`static int`	`HS_PATCH`
`static int`	`HS_SCAN_TERMINATED` The engine was terminated by callback.
`static int`	`HS_SCRATCH_IN_USE` The scratch region was already in use.
`static int`	`HS_SUCCESS` The engine completed normally.
`static int`	`HS_TUNE_FAMILY_BDW` Tuning Parameter - Intel(R) microarchitecture code name Broadwell This indicates that the compiled database should be tuned for the Broadwell microarchitecture.
`static int`	`HS_TUNE_FAMILY_GENERIC` Tuning Parameter - Generic This indicates that the compiled database should not be tuned for any particular target platform.
`static int`	`HS_TUNE_FAMILY_GLM` Tuning Parameter - Intel(R) microarchitecture code name Goldmont This indicates that the compiled database should be tuned for the Goldmont microarchitecture.
`static int`	`HS_TUNE_FAMILY_HSW` Tuning Parameter - Intel(R) microarchitecture code name Haswell This indicates that the compiled database should be tuned for the Haswell microarchitecture.
`static int`	`HS_TUNE_FAMILY_ICL` Tuning Parameter - Intel(R) microarchitecture code name Icelake This indicates that the compiled database should be tuned for the Icelake microarchitecture.
`static int`	`HS_TUNE_FAMILY_ICX` Tuning Parameter - Intel(R) microarchitecture code name Icelake Server This indicates that the compiled database should be tuned for the Icelake Server microarchitecture.
`static int`	`HS_TUNE_FAMILY_IVB` Tuning Parameter - Intel(R) microarchitecture code name Ivy Bridge This indicates that the compiled database should be tuned for the Ivy Bridge microarchitecture.
`static int`	`HS_TUNE_FAMILY_SKL` Tuning Parameter - Intel(R) microarchitecture code name Skylake This indicates that the compiled database should be tuned for the Skylake microarchitecture.
`static int`	`HS_TUNE_FAMILY_SKX` Tuning Parameter - Intel(R) microarchitecture code name Skylake Server This indicates that the compiled database should be tuned for the Skylake Server microarchitecture.
`static int`	`HS_TUNE_FAMILY_SLM` Tuning Parameter - Intel(R) microarchitecture code name Silvermont This indicates that the compiled database should be tuned for the Silvermont microarchitecture.
`static int`	`HS_TUNE_FAMILY_SNB` Tuning Parameter - Intel(R) microarchitecture code name Sandy Bridge This indicates that the compiled database should be tuned for the Sandy Bridge microarchitecture.
`static int`	`HS_UNKNOWN_ERROR` Unexpected internal error.

Constructor Summary

Constructors
Constructor and Description

hyperscan()

Constructors
Constructor and Description
`hyperscan()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static int`	`hs_alloc_scratch(hs_database_t db, hs_scratch_t scratch)`
`static int`	`hs_alloc_scratch(hs_database_t db, PointerPointer scratch)` Allocate a "scratch" space for use by Hyperscan.
`static int`	`hs_clone_scratch(hs_scratch_t src, hs_scratch_t dest)`
`static int`	`hs_clone_scratch(hs_scratch_t src, PointerPointer dest)` Allocate a scratch space that is a clone of an existing scratch space.
`static int`	`hs_close_stream(hs_stream_t id, hs_scratch_t scratch, match_event_handler onEvent, Pointer ctxt)` Close a stream.
`static int`	`hs_compile_ext_multi(byte[] expressions, int[] flags, int[] ids, hs_expr_ext_t ext, int elements, int mode, hs_platform_info_t platform, hs_database_t db, hs_compile_error_t error)`
`static int`	`hs_compile_ext_multi(ByteBuffer expressions, IntBuffer flags, IntBuffer ids, hs_expr_ext_t ext, int elements, int mode, hs_platform_info_t platform, hs_database_t db, hs_compile_error_t error)`
`static int`	`hs_compile_ext_multi(BytePointer expressions, IntPointer flags, IntPointer ids, hs_expr_ext_t ext, int elements, int mode, hs_platform_info_t platform, hs_database_t db, hs_compile_error_t error)`
`static int`	`hs_compile_ext_multi(PointerPointer expressions, IntPointer flags, IntPointer ids, PointerPointer ext, int elements, int mode, hs_platform_info_t platform, PointerPointer db, PointerPointer error)` The multiple regular expression compiler with extended parameter support.
`static int`	`hs_compile_lit_multi(byte[] expressions, int[] flags, int[] ids, SizeTPointer lens, int elements, int mode, hs_platform_info_t platform, hs_database_t db, hs_compile_error_t error)`
`static int`	`hs_compile_lit_multi(ByteBuffer expressions, IntBuffer flags, IntBuffer ids, SizeTPointer lens, int elements, int mode, hs_platform_info_t platform, hs_database_t db, hs_compile_error_t error)`
`static int`	`hs_compile_lit_multi(BytePointer expressions, IntPointer flags, IntPointer ids, SizeTPointer lens, int elements, int mode, hs_platform_info_t platform, hs_database_t db, hs_compile_error_t error)`
`static int`	`hs_compile_lit_multi(PointerPointer expressions, IntPointer flags, IntPointer ids, SizeTPointer lens, int elements, int mode, hs_platform_info_t platform, PointerPointer db, PointerPointer error)` The multiple pure literal expression compiler.
`static int`	`hs_compile_lit(BytePointer expression, int flags, long len, int mode, hs_platform_info_t platform, hs_database_t db, hs_compile_error_t error)`
`static int`	`hs_compile_lit(BytePointer expression, int flags, long len, int mode, hs_platform_info_t platform, PointerPointer db, PointerPointer error)` The basic pure literal expression compiler.
`static int`	`hs_compile_lit(String expression, int flags, long len, int mode, hs_platform_info_t platform, hs_database_t db, hs_compile_error_t error)`
`static int`	`hs_compile_multi(byte[] expressions, int[] flags, int[] ids, int elements, int mode, hs_platform_info_t platform, hs_database_t db, hs_compile_error_t error)`
`static int`	`hs_compile_multi(ByteBuffer expressions, IntBuffer flags, IntBuffer ids, int elements, int mode, hs_platform_info_t platform, hs_database_t db, hs_compile_error_t error)`
`static int`	`hs_compile_multi(BytePointer expressions, IntPointer flags, IntPointer ids, int elements, int mode, hs_platform_info_t platform, hs_database_t db, hs_compile_error_t error)`
`static int`	`hs_compile_multi(PointerPointer expressions, IntPointer flags, IntPointer ids, int elements, int mode, hs_platform_info_t platform, PointerPointer db, PointerPointer error)` The multiple regular expression compiler.
`static int`	`hs_compile(BytePointer expression, int flags, int mode, hs_platform_info_t platform, hs_database_t db, hs_compile_error_t error)`
`static int`	`hs_compile(BytePointer expression, int flags, int mode, hs_platform_info_t platform, PointerPointer db, PointerPointer error)` The basic regular expression compiler.
`static int`	`hs_compile(String expression, int flags, int mode, hs_platform_info_t platform, hs_database_t db, hs_compile_error_t error)`
`static int`	`hs_compress_stream(hs_stream_t stream, byte[] buf, long buf_space, SizeTPointer used_space)`
`static int`	`hs_compress_stream(hs_stream_t stream, ByteBuffer buf, long buf_space, SizeTPointer used_space)`
`static int`	`hs_compress_stream(hs_stream_t stream, BytePointer buf, long buf_space, SizeTPointer used_space)` Creates a compressed representation of the provided stream in the buffer provided.
`static int`	`hs_copy_stream(hs_stream_t to_id, hs_stream_t from_id)`
`static int`	`hs_copy_stream(PointerPointer to_id, hs_stream_t from_id)` Duplicate the given stream.
`static int`	`hs_database_info(hs_database_t database, byte[] info)`
`static int`	`hs_database_info(hs_database_t database, ByteBuffer info)`
`static int`	`hs_database_info(hs_database_t database, BytePointer info)`
`static int`	`hs_database_info(hs_database_t database, PointerPointer info)` Utility function providing information about a database.
`static int`	`hs_database_size(hs_database_t database, SizeTPointer database_size)` Provides the size of the given database in bytes.
`static int`	`hs_deserialize_database_at(BytePointer bytes, long length, hs_database_t db)` Reconstruct a pattern database from a stream of bytes previously generated by \ref hs_serialize_database() at a given memory location.
`static int`	`hs_deserialize_database_at(String bytes, long length, hs_database_t db)`
`static int`	`hs_deserialize_database(BytePointer bytes, long length, hs_database_t db)`
`static int`	`hs_deserialize_database(BytePointer bytes, long length, PointerPointer db)` Reconstruct a pattern database from a stream of bytes previously generated by \ref hs_serialize_database().
`static int`	`hs_deserialize_database(String bytes, long length, hs_database_t db)`
`static int`	`hs_expand_stream(hs_database_t db, hs_stream_t stream, BytePointer buf, long buf_size)`
`static int`	`hs_expand_stream(hs_database_t db, hs_stream_t stream, String buf, long buf_size)`
`static int`	`hs_expand_stream(hs_database_t db, PointerPointer stream, BytePointer buf, long buf_size)` Decompresses a compressed representation created by \ref hs_compress_stream() into a new stream.
`static int`	`hs_expression_ext_info(BytePointer expression, int flags, hs_expr_ext_t ext, hs_expr_info_t info, hs_compile_error_t error)`
`static int`	`hs_expression_ext_info(BytePointer expression, int flags, hs_expr_ext_t ext, PointerPointer info, PointerPointer error)` Utility function providing information about a regular expression, with extended parameter support.
`static int`	`hs_expression_ext_info(String expression, int flags, hs_expr_ext_t ext, hs_expr_info_t info, hs_compile_error_t error)`
`static int`	`hs_expression_info(BytePointer expression, int flags, hs_expr_info_t info, hs_compile_error_t error)`
`static int`	`hs_expression_info(BytePointer expression, int flags, PointerPointer info, PointerPointer error)` Utility function providing information about a regular expression.
`static int`	`hs_expression_info(String expression, int flags, hs_expr_info_t info, hs_compile_error_t error)`
`static int`	`hs_free_compile_error(hs_compile_error_t error)` Free an error structure generated by \ref hs_compile(), \ref hs_compile_multi() or \ref hs_compile_ext_multi().
`static int`	`hs_free_database(hs_database_t db)` Free a compiled pattern database.
`static int`	`hs_free_scratch(hs_scratch_t scratch)` Free a scratch block previously allocated by \ref hs_alloc_scratch() or \ref hs_clone_scratch().
`static int`	`hs_open_stream(hs_database_t db, int flags, hs_stream_t stream)`
`static int`	`hs_open_stream(hs_database_t db, int flags, PointerPointer stream)` Open and initialise a stream.
`static int`	`hs_populate_platform(hs_platform_info_t platform)` Populates the platform information based on the current host.
`static int`	`hs_reset_and_copy_stream(hs_stream_t to_id, hs_stream_t from_id, hs_scratch_t scratch, match_event_handler onEvent, Pointer context)` Duplicate the given 'from' stream state onto the 'to' stream.
`static int`	`hs_reset_and_expand_stream(hs_stream_t to_stream, BytePointer buf, long buf_size, hs_scratch_t scratch, match_event_handler onEvent, Pointer context)` Decompresses a compressed representation created by \ref hs_compress_stream() on top of the 'to' stream.
`static int`	`hs_reset_and_expand_stream(hs_stream_t to_stream, String buf, long buf_size, hs_scratch_t scratch, match_event_handler onEvent, Pointer context)`
`static int`	`hs_reset_stream(hs_stream_t id, int flags, hs_scratch_t scratch, match_event_handler onEvent, Pointer context)` Reset a stream to an initial state.
`static int`	`hs_scan_stream(hs_stream_t id, BytePointer data, int length, int flags, hs_scratch_t scratch, match_event_handler onEvent, Pointer ctxt)` Write data to be scanned to the opened stream.
`static int`	`hs_scan_stream(hs_stream_t id, String data, int length, int flags, hs_scratch_t scratch, match_event_handler onEvent, Pointer ctxt)`
`static int`	`hs_scan_vector(hs_database_t db, byte[] data, int[] length, int count, int flags, hs_scratch_t scratch, match_event_handler onEvent, Pointer context)`
`static int`	`hs_scan_vector(hs_database_t db, ByteBuffer data, IntBuffer length, int count, int flags, hs_scratch_t scratch, match_event_handler onEvent, Pointer context)`
`static int`	`hs_scan_vector(hs_database_t db, BytePointer data, IntPointer length, int count, int flags, hs_scratch_t scratch, match_event_handler onEvent, Pointer context)`
`static int`	`hs_scan_vector(hs_database_t db, PointerPointer data, IntPointer length, int count, int flags, hs_scratch_t scratch, match_event_handler onEvent, Pointer context)` The vectored regular expression scanner.
`static int`	`hs_scan(hs_database_t db, BytePointer data, int length, int flags, hs_scratch_t scratch, match_event_handler onEvent, Pointer context)` The block (non-streaming) regular expression scanner.
`static int`	`hs_scan(hs_database_t db, String data, int length, int flags, hs_scratch_t scratch, match_event_handler onEvent, Pointer context)`
`static int`	`hs_scratch_size(hs_scratch_t scratch, SizeTPointer scratch_size)` Provides the size of the given scratch space.
`static int`	`hs_serialize_database(hs_database_t db, byte[] bytes, SizeTPointer length)`
`static int`	`hs_serialize_database(hs_database_t db, ByteBuffer bytes, SizeTPointer length)`
`static int`	`hs_serialize_database(hs_database_t db, BytePointer bytes, SizeTPointer length)`
`static int`	`hs_serialize_database(hs_database_t db, PointerPointer bytes, SizeTPointer length)` Serialize a pattern database to a stream of bytes.
`static int`	`hs_serialized_database_info(BytePointer bytes, long length, byte[] info)`
`static int`	`hs_serialized_database_info(BytePointer bytes, long length, ByteBuffer info)`
`static int`	`hs_serialized_database_info(BytePointer bytes, long length, BytePointer info)`
`static int`	`hs_serialized_database_info(BytePointer bytes, long length, PointerPointer info)` Utility function providing information about a serialized database.
`static int`	`hs_serialized_database_info(String bytes, long length, byte[] info)`
`static int`	`hs_serialized_database_info(String bytes, long length, ByteBuffer info)`
`static int`	`hs_serialized_database_info(String bytes, long length, BytePointer info)`
`static int`	`hs_serialized_database_size(BytePointer bytes, long length, SizeTPointer deserialized_size)` Utility function for reporting the size that would be required by a database if it were deserialized.
`static int`	`hs_serialized_database_size(String bytes, long length, SizeTPointer deserialized_size)`
`static int`	`hs_set_allocator(hs_alloc_t alloc_func, hs_free_t free_func)` Set the allocate and free functions used by Hyperscan for allocating memory at runtime for stream state, scratch space, database bytecode, and various other data structure returned by the Hyperscan API.
`static int`	`hs_set_database_allocator(hs_alloc_t alloc_func, hs_free_t free_func)` Set the allocate and free functions used by Hyperscan for allocating memory for database bytecode produced by the compile calls (\ref hs_compile(), \ref hs_compile_multi(), \ref hs_compile_ext_multi()) and by database deserialization (\ref hs_deserialize_database()).
`static int`	`hs_set_misc_allocator(hs_alloc_t alloc_func, hs_free_t free_func)` Set the allocate and free functions used by Hyperscan for allocating memory for items returned by the Hyperscan API such as \ref hs_compile_error_t, \ref hs_expr_info_t and serialized databases.
`static int`	`hs_set_scratch_allocator(hs_alloc_t alloc_func, hs_free_t free_func)` Set the allocate and free functions used by Hyperscan for allocating memory for scratch space by \ref hs_alloc_scratch() and \ref hs_clone_scratch().
`static int`	`hs_set_stream_allocator(hs_alloc_t alloc_func, hs_free_t free_func)` Set the allocate and free functions used by Hyperscan for allocating memory for stream state by \ref hs_open_stream().
`static int`	`hs_stream_size(hs_database_t database, SizeTPointer stream_size)` Provides the size of the stream state allocated by a single stream opened against the given database.
`static int`	`hs_valid_platform()` Utility function to test the current system architecture.
`static BytePointer`	`hs_version()` Utility function for identifying this release version.

Methods inherited from class org.bytedeco.hyperscan.presets.hyperscan
map

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- HS_SUCCESS
```
public static final int HS_SUCCESS
```
  The engine completed normally.
  
  See Also:
  
  Constant Field Values
- HS_INVALID
```
public static final int HS_INVALID
```
  A parameter passed to this function was invalid. This error is only returned in cases where the function can detect an invalid parameter -- it cannot be relied upon to detect (for example) pointers to freed memory or other invalid data.
  
  See Also:
  
  Constant Field Values
- HS_NOMEM
```
public static final int HS_NOMEM
```
  A memory allocation failed.
  
  See Also:
  
  Constant Field Values
- HS_SCAN_TERMINATED
```
public static final int HS_SCAN_TERMINATED
```
  The engine was terminated by callback. This return value indicates that the target buffer was partially scanned, but that the callback function requested that scanning cease after a match was located.
  
  See Also:
  
  Constant Field Values
- HS_COMPILER_ERROR
```
public static final int HS_COMPILER_ERROR
```
  The pattern compiler failed, and the \ref hs_compile_error_t should be inspected for more detail.
  
  See Also:
  
  Constant Field Values
- HS_DB_VERSION_ERROR
```
public static final int HS_DB_VERSION_ERROR
```
  The given database was built for a different version of Hyperscan.
  
  See Also:
  
  Constant Field Values
- HS_DB_PLATFORM_ERROR
```
public static final int HS_DB_PLATFORM_ERROR
```
  The given database was built for a different platform (i.e., CPU type).
  
  See Also:
  
  Constant Field Values
- HS_DB_MODE_ERROR
```
public static final int HS_DB_MODE_ERROR
```
  The given database was built for a different mode of operation. This error is returned when streaming calls are used with a block or vectored database and vice versa.
  
  See Also:
  
  Constant Field Values
- HS_BAD_ALIGN
```
public static final int HS_BAD_ALIGN
```
  A parameter passed to this function was not correctly aligned.
  
  See Also:
  
  Constant Field Values
- HS_BAD_ALLOC
```
public static final int HS_BAD_ALLOC
```
  The memory allocator (either malloc() or the allocator set with \ref hs_set_allocator()) did not correctly return memory suitably aligned for the largest representable data type on this platform.
  
  See Also:
  
  Constant Field Values
- HS_SCRATCH_IN_USE
```
public static final int HS_SCRATCH_IN_USE
```
  The scratch region was already in use. This error is returned when Hyperscan is able to detect that the scratch region given is already in use by another Hyperscan API call. A separate scratch region, allocated with \ref hs_alloc_scratch() or \ref hs_clone_scratch(), is required for every concurrent caller of the Hyperscan API. For example, this error might be returned when \ref hs_scan() has been called inside a callback delivered by a currently-executing \ref hs_scan() call using the same scratch region. Note: Not all concurrent uses of scratch regions may be detected. This error is intended as a best-effort debugging tool, not a guarantee.
  
  See Also:
  
  Constant Field Values
- HS_ARCH_ERROR
```
public static final int HS_ARCH_ERROR
```
  Unsupported CPU architecture. This error is returned when Hyperscan is able to detect that the current system does not support the required instruction set. At a minimum, Hyperscan requires Supplemental Streaming SIMD Extensions 3 (SSSE3).
  
  See Also:
  
  Constant Field Values
- HS_INSUFFICIENT_SPACE
```
public static final int HS_INSUFFICIENT_SPACE
```
  Provided buffer was too small. This error indicates that there was insufficient space in the buffer. The call should be repeated with a larger provided buffer. Note: in this situation, it is normal for the amount of space required to be returned in the same manner as the used space would have been returned if the call was successful.
  
  See Also:
  
  Constant Field Values
- HS_UNKNOWN_ERROR
```
public static final int HS_UNKNOWN_ERROR
```
  Unexpected internal error. This error indicates that there was unexpected matching behaviors. This could be related to invalid usage of stream and scratch space or invalid memory operations by users.
  
  See Also:
  
  Constant Field Values
- HS_EXT_FLAG_MIN_OFFSET
```
public static final long HS_EXT_FLAG_MIN_OFFSET
```
  Flag indicating that the hs_expr_ext::min_offset field is used.
  
  See Also:
  
  Constant Field Values
- HS_EXT_FLAG_MAX_OFFSET
```
public static final long HS_EXT_FLAG_MAX_OFFSET
```
  Flag indicating that the hs_expr_ext::max_offset field is used.
  
  See Also:
  
  Constant Field Values
- HS_EXT_FLAG_MIN_LENGTH
```
public static final long HS_EXT_FLAG_MIN_LENGTH
```
  Flag indicating that the hs_expr_ext::min_length field is used.
  
  See Also:
  
  Constant Field Values
- HS_EXT_FLAG_EDIT_DISTANCE
```
public static final long HS_EXT_FLAG_EDIT_DISTANCE
```
  Flag indicating that the hs_expr_ext::edit_distance field is used.
  
  See Also:
  
  Constant Field Values
- HS_EXT_FLAG_HAMMING_DISTANCE
```
public static final long HS_EXT_FLAG_HAMMING_DISTANCE
```
  Flag indicating that the hs_expr_ext::hamming_distance field is used.
  
  See Also:
  
  Constant Field Values
- HS_FLAG_CASELESS
```
public static final int HS_FLAG_CASELESS
```
  Compile flag: Set case-insensitive matching. This flag sets the expression to be matched case-insensitively by default. The expression may still use PCRE tokens (notably (?i) and (?-i)) to switch case-insensitive matching on and off.
  
  See Also:
  
  Constant Field Values
- HS_FLAG_DOTALL
```
public static final int HS_FLAG_DOTALL
```
  Compile flag: Matching a . will not exclude newlines. This flag sets any instances of the . token to match newline characters as well as all other characters. The PCRE specification states that the . token does not match newline characters by default, so without this flag the . token will not cross line boundaries.
  
  See Also:
  
  Constant Field Values
- HS_FLAG_MULTILINE
```
public static final int HS_FLAG_MULTILINE
```
  Compile flag: Set multi-line anchoring. This flag instructs the expression to make the ^ and $ tokens match newline characters as well as the start and end of the stream. If this flag is not specified, the ^ token will only ever match at the start of a stream, and the $ token will only ever match at the end of a stream within the guidelines of the PCRE specification.
  
  See Also:
  
  Constant Field Values
- HS_FLAG_SINGLEMATCH
```
public static final int HS_FLAG_SINGLEMATCH
```
  Compile flag: Set single-match only mode. This flag sets the expression's match ID to match at most once. In streaming mode, this means that the expression will return only a single match over the lifetime of the stream, rather than reporting every match as per standard Hyperscan semantics. In block mode or vectored mode, only the first match for each invocation of \ref hs_scan() or \ref hs_scan_vector() will be returned. If multiple expressions in the database share the same match ID, then they either must all specify \ref HS_FLAG_SINGLEMATCH or none of them specify \ref HS_FLAG_SINGLEMATCH. If a group of expressions sharing a match ID specify the flag, then at most one match with the match ID will be generated per stream. Note: The use of this flag in combination with \ref HS_FLAG_SOM_LEFTMOST is not currently supported.
  
  See Also:
  
  Constant Field Values
- HS_FLAG_ALLOWEMPTY
```
public static final int HS_FLAG_ALLOWEMPTY
```
  Compile flag: Allow expressions that can match against empty buffers. This flag instructs the compiler to allow expressions that can match against empty buffers, such as .?, .*, (a|). Since Hyperscan can return every possible match for an expression, such expressions generally execute very slowly; the default behaviour is to return an error when an attempt to compile one is made. Using this flag will force the compiler to allow such an expression.
  
  See Also:
  
  Constant Field Values
- HS_FLAG_UTF8
```
public static final int HS_FLAG_UTF8
```
  Compile flag: Enable UTF-8 mode for this expression. This flag instructs Hyperscan to treat the pattern as a sequence of UTF-8 characters. The results of scanning invalid UTF-8 sequences with a Hyperscan library that has been compiled with one or more patterns using this flag are undefined.
  
  See Also:
  
  Constant Field Values
- HS_FLAG_UCP
```
public static final int HS_FLAG_UCP
```
  Compile flag: Enable Unicode property support for this expression. This flag instructs Hyperscan to use Unicode properties, rather than the default ASCII interpretations, for character mnemonics like \w and \s as well as the POSIX character classes. It is only meaningful in conjunction with \ref HS_FLAG_UTF8.
  
  See Also:
  
  Constant Field Values
- HS_FLAG_PREFILTER
```
public static final int HS_FLAG_PREFILTER
```
  Compile flag: Enable prefiltering mode for this expression. This flag instructs Hyperscan to compile an "approximate" version of this pattern for use in a prefiltering application, even if Hyperscan does not support the pattern in normal operation. The set of matches returned when this flag is used is guaranteed to be a superset of the matches specified by the non-prefiltering expression. If the pattern contains pattern constructs not supported by Hyperscan (such as zero-width assertions, back-references or conditional references) these constructs will be replaced internally with broader constructs that may match more often. Furthermore, in prefiltering mode Hyperscan may simplify a pattern that would otherwise return a "Pattern too large" error at compile time, or for performance reasons (subject to the matching guarantee above). It is generally expected that the application will subsequently confirm prefilter matches with another regular expression matcher that can provide exact matches for the pattern. Note: The use of this flag in combination with \ref HS_FLAG_SOM_LEFTMOST is not currently supported.
  
  See Also:
  
  Constant Field Values
- HS_FLAG_SOM_LEFTMOST
```
public static final int HS_FLAG_SOM_LEFTMOST
```
  Compile flag: Enable leftmost start of match reporting. This flag instructs Hyperscan to report the leftmost possible start of match offset when a match is reported for this expression. (By default, no start of match is returned.) For all the 3 modes, enabling this behaviour may reduce performance. And particularly, it may increase stream state requirements in streaming mode.
  
  See Also:
  
  Constant Field Values
- HS_FLAG_COMBINATION
```
public static final int HS_FLAG_COMBINATION
```
  Compile flag: Logical combination. This flag instructs Hyperscan to parse this expression as logical combination syntax. Logical constraints consist of operands, operators and parentheses. The operands are expression indices, and operators can be '!'(NOT), '&'(AND) or '|'(OR). For example: (101&102&103)|(104&!105) ((301|302)&303)&(304|305)
  
  See Also:
  
  Constant Field Values
- HS_FLAG_QUIET
```
public static final int HS_FLAG_QUIET
```
  Compile flag: Don't do any match reporting. This flag instructs Hyperscan to ignore match reporting for this expression. It is designed to be used on the sub-expressions in logical combinations.
  
  See Also:
  
  Constant Field Values
- HS_CPU_FEATURES_AVX2
```
public static final long HS_CPU_FEATURES_AVX2
```
  CPU features flag - Intel(R) Advanced Vector Extensions 2 (Intel(R) AVX2) Setting this flag indicates that the target platform supports AVX2 instructions.
  
  See Also:
  
  Constant Field Values
- HS_CPU_FEATURES_AVX512
```
public static final long HS_CPU_FEATURES_AVX512
```
  CPU features flag - Intel(R) Advanced Vector Extensions 512 (Intel(R) AVX512) Setting this flag indicates that the target platform supports AVX512 instructions, specifically AVX-512BW. Using AVX512 implies the use of AVX2.
  
  See Also:
  
  Constant Field Values
- HS_CPU_FEATURES_AVX512VBMI
```
public static final long HS_CPU_FEATURES_AVX512VBMI
```
  CPU features flag - Intel(R) Advanced Vector Extensions 512 Vector Byte Manipulation Instructions (Intel(R) AVX512VBMI) Setting this flag indicates that the target platform supports AVX512VBMI instructions. Using AVX512VBMI implies the use of AVX512.
  
  See Also:
  
  Constant Field Values
- HS_TUNE_FAMILY_GENERIC
```
public static final int HS_TUNE_FAMILY_GENERIC
```
  Tuning Parameter - Generic This indicates that the compiled database should not be tuned for any particular target platform.
  
  See Also:
  
  Constant Field Values
- HS_TUNE_FAMILY_SNB
```
public static final int HS_TUNE_FAMILY_SNB
```
  Tuning Parameter - Intel(R) microarchitecture code name Sandy Bridge This indicates that the compiled database should be tuned for the Sandy Bridge microarchitecture.
  
  See Also:
  
  Constant Field Values
- HS_TUNE_FAMILY_IVB
```
public static final int HS_TUNE_FAMILY_IVB
```
  Tuning Parameter - Intel(R) microarchitecture code name Ivy Bridge This indicates that the compiled database should be tuned for the Ivy Bridge microarchitecture.
  
  See Also:
  
  Constant Field Values
- HS_TUNE_FAMILY_HSW
```
public static final int HS_TUNE_FAMILY_HSW
```
  Tuning Parameter - Intel(R) microarchitecture code name Haswell This indicates that the compiled database should be tuned for the Haswell microarchitecture.
  
  See Also:
  
  Constant Field Values
- HS_TUNE_FAMILY_SLM
```
public static final int HS_TUNE_FAMILY_SLM
```
  Tuning Parameter - Intel(R) microarchitecture code name Silvermont This indicates that the compiled database should be tuned for the Silvermont microarchitecture.
  
  See Also:
  
  Constant Field Values
- HS_TUNE_FAMILY_BDW
```
public static final int HS_TUNE_FAMILY_BDW
```
  Tuning Parameter - Intel(R) microarchitecture code name Broadwell This indicates that the compiled database should be tuned for the Broadwell microarchitecture.
  
  See Also:
  
  Constant Field Values
- HS_TUNE_FAMILY_SKL
```
public static final int HS_TUNE_FAMILY_SKL
```
  Tuning Parameter - Intel(R) microarchitecture code name Skylake This indicates that the compiled database should be tuned for the Skylake microarchitecture.
  
  See Also:
  
  Constant Field Values
- HS_TUNE_FAMILY_SKX
```
public static final int HS_TUNE_FAMILY_SKX
```
  Tuning Parameter - Intel(R) microarchitecture code name Skylake Server This indicates that the compiled database should be tuned for the Skylake Server microarchitecture.
  
  See Also:
  
  Constant Field Values
- HS_TUNE_FAMILY_GLM
```
public static final int HS_TUNE_FAMILY_GLM
```
  Tuning Parameter - Intel(R) microarchitecture code name Goldmont This indicates that the compiled database should be tuned for the Goldmont microarchitecture.
  
  See Also:
  
  Constant Field Values
- HS_TUNE_FAMILY_ICL
```
public static final int HS_TUNE_FAMILY_ICL
```
  Tuning Parameter - Intel(R) microarchitecture code name Icelake This indicates that the compiled database should be tuned for the Icelake microarchitecture.
  
  See Also:
  
  Constant Field Values
- HS_TUNE_FAMILY_ICX
```
public static final int HS_TUNE_FAMILY_ICX
```
  Tuning Parameter - Intel(R) microarchitecture code name Icelake Server This indicates that the compiled database should be tuned for the Icelake Server microarchitecture.
  
  See Also:
  
  Constant Field Values
- HS_MODE_BLOCK
```
public static final int HS_MODE_BLOCK
```
  Compiler mode flag: Block scan (non-streaming) database.
  
  See Also:
  
  Constant Field Values
- HS_MODE_NOSTREAM
```
public static final int HS_MODE_NOSTREAM
```
  Compiler mode flag: Alias for \ref HS_MODE_BLOCK.
  
  See Also:
  
  Constant Field Values
- HS_MODE_STREAM
```
public static final int HS_MODE_STREAM
```
  Compiler mode flag: Streaming database.
  
  See Also:
  
  Constant Field Values
- HS_MODE_VECTORED
```
public static final int HS_MODE_VECTORED
```
  Compiler mode flag: Vectored scanning database.
  
  See Also:
  
  Constant Field Values
- HS_MODE_SOM_HORIZON_LARGE
```
public static final int HS_MODE_SOM_HORIZON_LARGE
```
  Compiler mode flag: use full precision to track start of match offsets in stream state. This mode will use the most stream state per pattern, but will always return an accurate start of match offset regardless of how far back in the past it was found. One of the SOM_HORIZON modes must be selected to use the \ref HS_FLAG_SOM_LEFTMOST expression flag.
  
  See Also:
  
  Constant Field Values
- HS_MODE_SOM_HORIZON_MEDIUM
```
public static final int HS_MODE_SOM_HORIZON_MEDIUM
```
  Compiler mode flag: use medium precision to track start of match offsets in stream state. This mode will use less stream state than \ref HS_MODE_SOM_HORIZON_LARGE and will limit start of match accuracy to offsets within 2^32 bytes of the end of match offset reported. One of the SOM_HORIZON modes must be selected to use the \ref HS_FLAG_SOM_LEFTMOST expression flag.
  
  See Also:
  
  Constant Field Values
- HS_MODE_SOM_HORIZON_SMALL
```
public static final int HS_MODE_SOM_HORIZON_SMALL
```
  Compiler mode flag: use limited precision to track start of match offsets in stream state. This mode will use less stream state than \ref HS_MODE_SOM_HORIZON_LARGE and will limit start of match accuracy to offsets within 2^16 bytes of the end of match offset reported. One of the SOM_HORIZON modes must be selected to use the \ref HS_FLAG_SOM_LEFTMOST expression flag.
  
  See Also:
  
  Constant Field Values
- HS_OFFSET_PAST_HORIZON
```
public static final long HS_OFFSET_PAST_HORIZON
```
  Callback 'from' return value, indicating that the start of this match was too early to be tracked with the requested SOM_HORIZON precision.
  
  See Also:
  
  Constant Field Values
- HS_MAJOR
```
public static final int HS_MAJOR
```
  \file \brief The complete Hyperscan API definition. Hyperscan is a high speed regular expression engine. This header includes both the Hyperscan compiler and runtime components. See the individual component headers for documentation.
  
  See Also:
  
  Constant Field Values
- HS_MINOR
```
public static final int HS_MINOR
```
  See Also:
  
  Constant Field Values
- HS_PATCH
```
public static final int HS_PATCH
```
  See Also:
  
  Constant Field Values

Constructor Detail
- hyperscan
```
public hyperscan()
```

Method Detail

hs_free_database
```
@Cast(value="hs_error_t")
public static int hs_free_database(hs_database_t db)
```
Free a compiled pattern database. The free callback set by \ref hs_set_database_allocator() (or \ref hs_set_allocator()) will be used by this function.

Parameters:

db - A compiled pattern database. NULL may also be safely provided, in which case the function does nothing.

Returns:

\ref HS_SUCCESS on success, other values on failure.

hs_serialize_database

@Cast(value="hs_error_t")
public static int hs_serialize_database(@Const
                                                                  hs_database_t db,
                                                                  @Cast(value="char**")
                                                                  PointerPointer bytes,
                                                                  @Cast(value="size_t*")
                                                                  SizeTPointer length)

Serialize a pattern database to a stream of bytes. The allocator callback set by \ref hs_set_misc_allocator() (or \ref hs_set_allocator()) will be used by this function.

Parameters:: db - A compiled pattern database.; bytes - On success, a pointer to an array of bytes will be returned here. These bytes can be subsequently relocated or written to disk. The caller is responsible for freeing this block.; length - On success, the number of bytes in the generated byte array will be returned here.
Returns:: \ref HS_SUCCESS on success, \ref HS_NOMEM if the byte array cannot be allocated, other values may be returned if errors are detected.

hs_serialize_database

@Cast(value="hs_error_t")
public static int hs_serialize_database(@Const
                                                                  hs_database_t db,
                                                                  @Cast(value="char**") @ByPtrPtr
                                                                  BytePointer bytes,
                                                                  @Cast(value="size_t*")
                                                                  SizeTPointer length)

hs_serialize_database

@Cast(value="hs_error_t")
public static int hs_serialize_database(@Const
                                                                  hs_database_t db,
                                                                  @Cast(value="char**") @ByPtrPtr
                                                                  ByteBuffer bytes,
                                                                  @Cast(value="size_t*")
                                                                  SizeTPointer length)

hs_serialize_database

@Cast(value="hs_error_t")
public static int hs_serialize_database(@Const
                                                                  hs_database_t db,
                                                                  @Cast(value="char**") @ByPtrPtr
                                                                  byte[] bytes,
                                                                  @Cast(value="size_t*")
                                                                  SizeTPointer length)

hs_deserialize_database
```
@Cast(value="hs_error_t")
public static int hs_deserialize_database(@Cast(value="const char*")
                                                                    BytePointer bytes,
                                                                    @Cast(value="const size_t")
                                                                    long length,
                                                                    @Cast(value="hs_database_t**")
                                                                    PointerPointer db)
```
Reconstruct a pattern database from a stream of bytes previously generated by \ref hs_serialize_database(). This function will allocate sufficient space for the database using the allocator set with \ref hs_set_database_allocator() (or \ref hs_set_allocator()); to use a pre-allocated region of memory, use the \ref hs_deserialize_database_at() function.

Parameters:

bytes - A byte array generated by \ref hs_serialize_database() representing a compiled pattern database.

length - The length of the byte array generated by \ref hs_serialize_database(). This should be the same value as that returned by \ref hs_serialize_database().

db - On success, a pointer to a newly allocated \ref hs_database_t will be returned here. This database can then be used for scanning, and eventually freed by the caller using \ref hs_free_database().

Returns:

\ref HS_SUCCESS on success, other values on failure.

hs_deserialize_database

@Cast(value="hs_error_t")
public static int hs_deserialize_database(@Cast(value="const char*")
                                                                    BytePointer bytes,
                                                                    @Cast(value="const size_t")
                                                                    long length,
                                                                    @ByPtrPtr
                                                                    hs_database_t db)

hs_deserialize_database

@Cast(value="hs_error_t")
public static int hs_deserialize_database(String bytes,
                                                                    @Cast(value="const size_t")
                                                                    long length,
                                                                    @ByPtrPtr
                                                                    hs_database_t db)

hs_deserialize_database_at
```
@Cast(value="hs_error_t")
public static int hs_deserialize_database_at(@Cast(value="const char*")
                                                                       BytePointer bytes,
                                                                       @Cast(value="const size_t")
                                                                       long length,
                                                                       hs_database_t db)
```
Reconstruct a pattern database from a stream of bytes previously generated by \ref hs_serialize_database() at a given memory location. This function (unlike \ref hs_deserialize_database()) will write the reconstructed database to the memory location given in the \p db parameter. The amount of space required at this location can be determined with the \ref hs_serialized_database_size() function.

Parameters:

bytes - A byte array generated by \ref hs_serialize_database() representing a compiled pattern database.

length - The length of the byte array generated by \ref hs_serialize_database(). This should be the same value as that returned by \ref hs_serialize_database().

db - Pointer to an 8-byte aligned block of memory of sufficient size to hold the deserialized database. On success, the reconstructed database will be written to this location. This database can then be used for pattern matching. The user is responsible for freeing this memory; the \ref hs_free_database() call should not be used.

Returns:

\ref HS_SUCCESS on success, other values on failure.

hs_deserialize_database_at

@Cast(value="hs_error_t")
public static int hs_deserialize_database_at(String bytes,
                                                                       @Cast(value="const size_t")
                                                                       long length,
                                                                       hs_database_t db)

hs_stream_size

@Cast(value="hs_error_t")
public static int hs_stream_size(@Const
                                                           hs_database_t database,
                                                           @Cast(value="size_t*")
                                                           SizeTPointer stream_size)

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

Parameters:: database - Pointer to a compiled (streaming mode) pattern database.; stream_size - On success, the size in bytes of an individual stream opened against the given database is placed in this parameter.
Returns:: \ref HS_SUCCESS on success, other values on failure.

hs_database_size

@Cast(value="hs_error_t")
public static int hs_database_size(@Const
                                                             hs_database_t database,
                                                             @Cast(value="size_t*")
                                                             SizeTPointer database_size)

Provides the size of the given database in bytes.

Parameters:: database - Pointer to compiled pattern database.; database_size - On success, the size of the compiled database in bytes is placed in this parameter.
Returns:: \ref HS_SUCCESS on success, other values on failure.

hs_serialized_database_size

@Cast(value="hs_error_t")
public static int hs_serialized_database_size(@Cast(value="const char*")
                                                                        BytePointer bytes,
                                                                        @Cast(value="const size_t")
                                                                        long length,
                                                                        @Cast(value="size_t*")
                                                                        SizeTPointer deserialized_size)

Utility function for reporting the size that would be required by a database if it were deserialized. This can be used to allocate a shared memory region or other "special" allocation prior to deserializing with the \ref hs_deserialize_database_at() function.

Parameters:: bytes - Pointer to a byte array generated by \ref hs_serialize_database() representing a compiled pattern database.; length - The length of the byte array generated by \ref hs_serialize_database(). This should be the same value as that returned by \ref hs_serialize_database().; deserialized_size - On success, the size of the compiled database that would be generated by \ref hs_deserialize_database_at() is returned here.
Returns:: \ref HS_SUCCESS on success, other values on failure.

hs_serialized_database_size

@Cast(value="hs_error_t")
public static int hs_serialized_database_size(String bytes,
                                                                        @Cast(value="const size_t")
                                                                        long length,
                                                                        @Cast(value="size_t*")
                                                                        SizeTPointer deserialized_size)

hs_database_info

@Cast(value="hs_error_t")
public static int hs_database_info(@Const
                                                             hs_database_t database,
                                                             @Cast(value="char**")
                                                             PointerPointer info)

Utility function providing information about a database.

Parameters:: database - Pointer to a compiled database.; info - On success, a string containing the version and platform information for the supplied database is placed in the parameter. The string is allocated using the allocator supplied in \ref hs_set_misc_allocator() (or malloc() if no allocator was set) and should be freed by the caller.
Returns:: \ref HS_SUCCESS on success, other values on failure.

hs_database_info

@Cast(value="hs_error_t")
public static int hs_database_info(@Const
                                                             hs_database_t database,
                                                             @Cast(value="char**") @ByPtrPtr
                                                             BytePointer info)

hs_database_info

@Cast(value="hs_error_t")
public static int hs_database_info(@Const
                                                             hs_database_t database,
                                                             @Cast(value="char**") @ByPtrPtr
                                                             ByteBuffer info)

hs_database_info

@Cast(value="hs_error_t")
public static int hs_database_info(@Const
                                                             hs_database_t database,
                                                             @Cast(value="char**") @ByPtrPtr
                                                             byte[] info)

hs_serialized_database_info

@Cast(value="hs_error_t")
public static int hs_serialized_database_info(@Cast(value="const char*")
                                                                        BytePointer bytes,
                                                                        @Cast(value="size_t")
                                                                        long length,
                                                                        @Cast(value="char**")
                                                                        PointerPointer info)

Utility function providing information about a serialized database.

Parameters:: bytes - Pointer to a serialized database.; length - Length in bytes of the serialized database.; info - On success, a string containing the version and platform information for the supplied serialized database is placed in the parameter. The string is allocated using the allocator supplied in \ref hs_set_misc_allocator() (or malloc() if no allocator was set) and should be freed by the caller.
Returns:: \ref HS_SUCCESS on success, other values on failure.

hs_serialized_database_info

@Cast(value="hs_error_t")
public static int hs_serialized_database_info(@Cast(value="const char*")
                                                                        BytePointer bytes,
                                                                        @Cast(value="size_t")
                                                                        long length,
                                                                        @Cast(value="char**") @ByPtrPtr
                                                                        BytePointer info)

hs_serialized_database_info

@Cast(value="hs_error_t")
public static int hs_serialized_database_info(String bytes,
                                                                        @Cast(value="size_t")
                                                                        long length,
                                                                        @Cast(value="char**") @ByPtrPtr
                                                                        ByteBuffer info)

hs_serialized_database_info

@Cast(value="hs_error_t")
public static int hs_serialized_database_info(@Cast(value="const char*")
                                                                        BytePointer bytes,
                                                                        @Cast(value="size_t")
                                                                        long length,
                                                                        @Cast(value="char**") @ByPtrPtr
                                                                        byte[] info)

hs_serialized_database_info

@Cast(value="hs_error_t")
public static int hs_serialized_database_info(String bytes,
                                                                        @Cast(value="size_t")
                                                                        long length,
                                                                        @Cast(value="char**") @ByPtrPtr
                                                                        BytePointer info)

hs_serialized_database_info

@Cast(value="hs_error_t")
public static int hs_serialized_database_info(@Cast(value="const char*")
                                                                        BytePointer bytes,
                                                                        @Cast(value="size_t")
                                                                        long length,
                                                                        @Cast(value="char**") @ByPtrPtr
                                                                        ByteBuffer info)

hs_serialized_database_info

@Cast(value="hs_error_t")
public static int hs_serialized_database_info(String bytes,
                                                                        @Cast(value="size_t")
                                                                        long length,
                                                                        @Cast(value="char**") @ByPtrPtr
                                                                        byte[] info)

hs_set_allocator
```
@Cast(value="hs_error_t")
public static int hs_set_allocator(hs_alloc_t alloc_func,
                                                             hs_free_t free_func)
```
Set the allocate and free functions used by Hyperscan for allocating memory at runtime for stream state, scratch space, database bytecode, and various other data structure returned by the Hyperscan API. The function is equivalent to calling \ref hs_set_stream_allocator(), \ref hs_set_scratch_allocator(), \ref hs_set_database_allocator() and \ref hs_set_misc_allocator() with the provided parameters. This call will override any previous allocators that have been set. Note: there is no way to change the allocator used for temporary objects created during the various compile calls (\ref hs_compile(), \ref hs_compile_multi(), \ref hs_compile_ext_multi()).

Parameters:

alloc_func - A callback function pointer that allocates memory. This function must return memory suitably aligned for the largest representable data type on this platform.

free_func - A callback function pointer that frees allocated memory.

Returns:

\ref HS_SUCCESS on success, other values on failure.

hs_set_database_allocator
```
@Cast(value="hs_error_t")
public static int hs_set_database_allocator(hs_alloc_t alloc_func,
                                                                      hs_free_t free_func)
```
Set the allocate and free functions used by Hyperscan for allocating memory for database bytecode produced by the compile calls (\ref hs_compile(), \ref hs_compile_multi(), \ref hs_compile_ext_multi()) and by database deserialization (\ref hs_deserialize_database()). If no database allocation functions are set, or if NULL is used in place of both parameters, then memory allocation will default to standard methods (such as the system malloc() and free() calls). This call will override any previous database allocators that have been set. Note: the database allocator may also be set by calling \ref hs_set_allocator(). Note: there is no way to change how temporary objects created during the various compile calls (\ref hs_compile(), \ref hs_compile_multi(), \ref hs_compile_ext_multi()) are allocated.

Parameters:

alloc_func - A callback function pointer that allocates memory. This function must return memory suitably aligned for the largest representable data type on this platform.

free_func - A callback function pointer that frees allocated memory.

Returns:

\ref HS_SUCCESS on success, other values on failure.

hs_set_misc_allocator
```
@Cast(value="hs_error_t")
public static int hs_set_misc_allocator(hs_alloc_t alloc_func,
                                                                  hs_free_t free_func)
```
Set the allocate and free functions used by Hyperscan for allocating memory for items returned by the Hyperscan API such as \ref hs_compile_error_t, \ref hs_expr_info_t and serialized databases. If no misc allocation functions are set, or if NULL is used in place of both parameters, then memory allocation will default to standard methods (such as the system malloc() and free() calls). This call will override any previous misc allocators that have been set. Note: the misc allocator may also be set by calling \ref hs_set_allocator().

Parameters:

alloc_func - A callback function pointer that allocates memory. This function must return memory suitably aligned for the largest representable data type on this platform.

free_func - A callback function pointer that frees allocated memory.

Returns:

\ref HS_SUCCESS on success, other values on failure.

hs_set_scratch_allocator
```
@Cast(value="hs_error_t")
public static int hs_set_scratch_allocator(hs_alloc_t alloc_func,
                                                                     hs_free_t free_func)
```
Set the allocate and free functions used by Hyperscan for allocating memory for scratch space by \ref hs_alloc_scratch() and \ref hs_clone_scratch(). If no scratch allocation functions are set, or if NULL is used in place of both parameters, then memory allocation will default to standard methods (such as the system malloc() and free() calls). This call will override any previous scratch allocators that have been set. Note: the scratch allocator may also be set by calling \ref hs_set_allocator().

Parameters:

alloc_func - A callback function pointer that allocates memory. This function must return memory suitably aligned for the largest representable data type on this platform.

free_func - A callback function pointer that frees allocated memory.

Returns:

\ref HS_SUCCESS on success, other values on failure.

hs_set_stream_allocator
```
@Cast(value="hs_error_t")
public static int hs_set_stream_allocator(hs_alloc_t alloc_func,
                                                                    hs_free_t free_func)
```
Set the allocate and free functions used by Hyperscan for allocating memory for stream state by \ref hs_open_stream(). If no stream allocation functions are set, or if NULL is used in place of both parameters, then memory allocation will default to standard methods (such as the system malloc() and free() calls). This call will override any previous stream allocators that have been set. Note: the stream allocator may also be set by calling \ref hs_set_allocator().

Parameters:

alloc_func - A callback function pointer that allocates memory. This function must return memory suitably aligned for the largest representable data type on this platform.

free_func - A callback function pointer that frees allocated memory.

Returns:

\ref HS_SUCCESS on success, other values on failure.

hs_version
```
@Cast(value="const char*")
public static BytePointer hs_version()
```
Utility function for identifying this release version.

Returns:

A string containing the version number of this release build and the date of the build. It is allocated statically, so it does not need to be freed by the caller.

hs_valid_platform
```
@Cast(value="hs_error_t")
public static int hs_valid_platform()
```
Utility function to test the current system architecture. Hyperscan requires the Supplemental Streaming SIMD Extensions 3 instruction set. This function can be called on any x86 platform to determine if the system provides the required instruction set. This function does not test for more advanced features if Hyperscan has been built for a more specific architecture, for example the AVX2 instruction set.

Returns:

\ref HS_SUCCESS on success, \ref HS_ARCH_ERROR if system does not support Hyperscan.

hs_compile
```
@Cast(value="hs_error_t")
public static int hs_compile(@Cast(value="const char*")
                                                       BytePointer expression,
                                                       @Cast(value="unsigned int")
                                                       int flags,
                                                       @Cast(value="unsigned int")
                                                       int mode,
                                                       @Const
                                                       hs_platform_info_t platform,
                                                       @Cast(value="hs_database_t**")
                                                       PointerPointer db,
                                                       @Cast(value="hs_compile_error_t**")
                                                       PointerPointer error)
```
The basic regular expression compiler. This is the function call with which an expression is compiled into a Hyperscan database which can be passed to the runtime functions (such as \ref hs_scan(), \ref hs_open_stream(), etc.)

Parameters:

expression - The NULL-terminated expression to parse. Note that this string must represent ONLY the pattern to be matched, with no delimiters or flags; any global flags should be specified with the \p flags argument. For example, the expression /abc?def/i should be compiled by providing abc?def as the \p expression, and \ref HS_FLAG_CASELESS as the \a flags.

flags - Flags which modify the behaviour of the expression. Multiple flags may be used by ORing them together. Valid values are: - HS_FLAG_CASELESS - Matching will be performed case-insensitively. - HS_FLAG_DOTALL - Matching a . will not exclude newlines. - HS_FLAG_MULTILINE - ^ and $ anchors match any newlines in data. - HS_FLAG_SINGLEMATCH - Only one match will be generated for the expression per stream. - HS_FLAG_ALLOWEMPTY - Allow expressions which can match against an empty string, such as .*. - HS_FLAG_UTF8 - Treat this pattern as a sequence of UTF-8 characters. - HS_FLAG_UCP - Use Unicode properties for character classes. - HS_FLAG_PREFILTER - Compile pattern in prefiltering mode. - HS_FLAG_SOM_LEFTMOST - Report the leftmost start of match offset when a match is found. - HS_FLAG_COMBINATION - Parse the expression in logical combination syntax. - HS_FLAG_QUIET - Ignore match reporting for this expression. Used for the sub-expressions in logical combinations.

mode - Compiler mode flags that affect the database as a whole. One of \ref HS_MODE_STREAM or \ref HS_MODE_BLOCK or \ref HS_MODE_VECTORED must be supplied, to select between the generation of a streaming, block or vectored database. In addition, other flags (beginning with HS_MODE_) may be supplied to enable specific features. See \ref HS_MODE_FLAG for more details.

platform - If not NULL, the platform structure is used to determine the target platform for the database. If NULL, a database suitable for running on the current host platform is produced.

db - On success, a pointer to the generated database will be returned in this parameter, or NULL on failure. The caller is responsible for deallocating the buffer using the \ref hs_free_database() function.

error - If the compile fails, a pointer to a \ref hs_compile_error_t will be returned, providing details of the error condition. The caller is responsible for deallocating the buffer using the \ref hs_free_compile_error() function.

Returns:

\ref HS_SUCCESS is returned on successful compilation; \ref HS_COMPILER_ERROR on failure, with details provided in the error parameter.

hs_compile

@Cast(value="hs_error_t")
public static int hs_compile(@Cast(value="const char*")
                                                       BytePointer expression,
                                                       @Cast(value="unsigned int")
                                                       int flags,
                                                       @Cast(value="unsigned int")
                                                       int mode,
                                                       @Const
                                                       hs_platform_info_t platform,
                                                       @ByPtrPtr
                                                       hs_database_t db,
                                                       @ByPtrPtr
                                                       hs_compile_error_t error)

hs_compile

@Cast(value="hs_error_t")
public static int hs_compile(String expression,
                                                       @Cast(value="unsigned int")
                                                       int flags,
                                                       @Cast(value="unsigned int")
                                                       int mode,
                                                       @Const
                                                       hs_platform_info_t platform,
                                                       @ByPtrPtr
                                                       hs_database_t db,
                                                       @ByPtrPtr
                                                       hs_compile_error_t error)

hs_compile_multi
```
@Cast(value="hs_error_t")
public static int hs_compile_multi(@Cast(value="const char*const*")
                                                             PointerPointer expressions,
                                                             @Cast(value="const unsigned int*")
                                                             IntPointer flags,
                                                             @Cast(value="const unsigned int*")
                                                             IntPointer ids,
                                                             @Cast(value="unsigned int")
                                                             int elements,
                                                             @Cast(value="unsigned int")
                                                             int mode,
                                                             @Const
                                                             hs_platform_info_t platform,
                                                             @Cast(value="hs_database_t**")
                                                             PointerPointer db,
                                                             @Cast(value="hs_compile_error_t**")
                                                             PointerPointer error)
```
The multiple regular expression compiler. This is the function call with which a set of expressions is compiled into a database which can be passed to the runtime functions (such as \ref hs_scan(), \ref hs_open_stream(), etc.) Each expression can be labelled with a unique integer which is passed into the match callback to identify the pattern that has matched.

Parameters:

expressions - Array of NULL-terminated expressions to compile. Note that (as for \ref hs_compile()) these strings must contain only the pattern to be matched, with no delimiters or flags. For example, the expression /abc?def/i should be compiled by providing abc?def as the first string in the \p expressions array, and \ref HS_FLAG_CASELESS as the first value in the \p flags array.

flags - Array of flags which modify the behaviour of each expression. Multiple flags may be used by ORing them together. Specifying the NULL pointer in place of an array will set the flags value for all patterns to zero. Valid values are: - HS_FLAG_CASELESS - Matching will be performed case-insensitively. - HS_FLAG_DOTALL - Matching a . will not exclude newlines. - HS_FLAG_MULTILINE - ^ and $ anchors match any newlines in data. - HS_FLAG_SINGLEMATCH - Only one match will be generated by patterns with this match id per stream. - HS_FLAG_ALLOWEMPTY - Allow expressions which can match against an empty string, such as .*. - HS_FLAG_UTF8 - Treat this pattern as a sequence of UTF-8 characters. - HS_FLAG_UCP - Use Unicode properties for character classes. - HS_FLAG_PREFILTER - Compile pattern in prefiltering mode. - HS_FLAG_SOM_LEFTMOST - Report the leftmost start of match offset when a match is found. - HS_FLAG_COMBINATION - Parse the expression in logical combination syntax. - HS_FLAG_QUIET - Ignore match reporting for this expression. Used for the sub-expressions in logical combinations.

ids - An array of integers specifying the ID number to be associated with the corresponding pattern in the expressions array. Specifying the NULL pointer in place of an array will set the ID value for all patterns to zero.

elements - The number of elements in the input arrays.

mode - Compiler mode flags that affect the database as a whole. One of \ref HS_MODE_STREAM or \ref HS_MODE_BLOCK or \ref HS_MODE_VECTORED must be supplied, to select between the generation of a streaming, block or vectored database. In addition, other flags (beginning with HS_MODE_) may be supplied to enable specific features. See \ref HS_MODE_FLAG for more details.

platform - If not NULL, the platform structure is used to determine the target platform for the database. If NULL, a database suitable for running on the current host platform is produced.

db - On success, a pointer to the generated database will be returned in this parameter, or NULL on failure. The caller is responsible for deallocating the buffer using the \ref hs_free_database() function.

error - If the compile fails, a pointer to a \ref hs_compile_error_t will be returned, providing details of the error condition. The caller is responsible for deallocating the buffer using the \ref hs_free_compile_error() function.

Returns:

\ref HS_SUCCESS is returned on successful compilation; \ref HS_COMPILER_ERROR on failure, with details provided in the \p error parameter.

hs_compile_multi

@Cast(value="hs_error_t")
public static int hs_compile_multi(@Cast(value="const char*const*") @ByPtrPtr
                                                             BytePointer expressions,
                                                             @Cast(value="const unsigned int*")
                                                             IntPointer flags,
                                                             @Cast(value="const unsigned int*")
                                                             IntPointer ids,
                                                             @Cast(value="unsigned int")
                                                             int elements,
                                                             @Cast(value="unsigned int")
                                                             int mode,
                                                             @Const
                                                             hs_platform_info_t platform,
                                                             @ByPtrPtr
                                                             hs_database_t db,
                                                             @ByPtrPtr
                                                             hs_compile_error_t error)

hs_compile_multi

@Cast(value="hs_error_t")
public static int hs_compile_multi(@Cast(value="const char*const*") @ByPtrPtr
                                                             ByteBuffer expressions,
                                                             @Cast(value="const unsigned int*")
                                                             IntBuffer flags,
                                                             @Cast(value="const unsigned int*")
                                                             IntBuffer ids,
                                                             @Cast(value="unsigned int")
                                                             int elements,
                                                             @Cast(value="unsigned int")
                                                             int mode,
                                                             @Const
                                                             hs_platform_info_t platform,
                                                             @ByPtrPtr
                                                             hs_database_t db,
                                                             @ByPtrPtr
                                                             hs_compile_error_t error)

hs_compile_multi

@Cast(value="hs_error_t")
public static int hs_compile_multi(@Cast(value="const char*const*") @ByPtrPtr
                                                             byte[] expressions,
                                                             @Cast(value="const unsigned int*")
                                                             int[] flags,
                                                             @Cast(value="const unsigned int*")
                                                             int[] ids,
                                                             @Cast(value="unsigned int")
                                                             int elements,
                                                             @Cast(value="unsigned int")
                                                             int mode,
                                                             @Const
                                                             hs_platform_info_t platform,
                                                             @ByPtrPtr
                                                             hs_database_t db,
                                                             @ByPtrPtr
                                                             hs_compile_error_t error)

hs_compile_ext_multi
```
@Cast(value="hs_error_t")
public static int hs_compile_ext_multi(@Cast(value="const char*const*")
                                                                 PointerPointer expressions,
                                                                 @Cast(value="const unsigned int*")
                                                                 IntPointer flags,
                                                                 @Cast(value="const unsigned int*")
                                                                 IntPointer ids,
                                                                 @Cast(value="const hs_expr_ext_t*const*")
                                                                 PointerPointer ext,
                                                                 @Cast(value="unsigned int")
                                                                 int elements,
                                                                 @Cast(value="unsigned int")
                                                                 int mode,
                                                                 @Const
                                                                 hs_platform_info_t platform,
                                                                 @Cast(value="hs_database_t**")
                                                                 PointerPointer db,
                                                                 @Cast(value="hs_compile_error_t**")
                                                                 PointerPointer error)
```
The multiple regular expression compiler with extended parameter support. This function call compiles a group of expressions into a database in the same way as \ref hs_compile_multi(), but allows additional parameters to be specified via an \ref hs_expr_ext_t structure per expression.

Parameters:

expressions - Array of NULL-terminated expressions to compile. Note that (as for \ref hs_compile()) these strings must contain only the pattern to be matched, with no delimiters or flags. For example, the expression /abc?def/i should be compiled by providing abc?def as the first string in the \p expressions array, and \ref HS_FLAG_CASELESS as the first value in the \p flags array.

flags - Array of flags which modify the behaviour of each expression. Multiple flags may be used by ORing them together. Specifying the NULL pointer in place of an array will set the flags value for all patterns to zero. Valid values are: - HS_FLAG_CASELESS - Matching will be performed case-insensitively. - HS_FLAG_DOTALL - Matching a . will not exclude newlines. - HS_FLAG_MULTILINE - ^ and $ anchors match any newlines in data. - HS_FLAG_SINGLEMATCH - Only one match will be generated by patterns with this match id per stream. - HS_FLAG_ALLOWEMPTY - Allow expressions which can match against an empty string, such as .*. - HS_FLAG_UTF8 - Treat this pattern as a sequence of UTF-8 characters. - HS_FLAG_UCP - Use Unicode properties for character classes. - HS_FLAG_PREFILTER - Compile pattern in prefiltering mode. - HS_FLAG_SOM_LEFTMOST - Report the leftmost start of match offset when a match is found. - HS_FLAG_COMBINATION - Parse the expression in logical combination syntax. - HS_FLAG_QUIET - Ignore match reporting for this expression. Used for the sub-expressions in logical combinations.

ids - An array of integers specifying the ID number to be associated with the corresponding pattern in the expressions array. Specifying the NULL pointer in place of an array will set the ID value for all patterns to zero.

ext - An array of pointers to filled \ref hs_expr_ext_t structures that define extended behaviour for each pattern. NULL may be specified if no extended behaviour is needed for an individual pattern, or in place of the whole array if it is not needed for any expressions. Memory used by these structures must be both allocated and freed by the caller.

elements - The number of elements in the input arrays.

mode - Compiler mode flags that affect the database as a whole. One of \ref HS_MODE_STREAM, \ref HS_MODE_BLOCK or \ref HS_MODE_VECTORED must be supplied, to select between the generation of a streaming, block or vectored database. In addition, other flags (beginning with HS_MODE_) may be supplied to enable specific features. See \ref HS_MODE_FLAG for more details.

platform - If not NULL, the platform structure is used to determine the target platform for the database. If NULL, a database suitable for running on the current host platform is produced.

db - On success, a pointer to the generated database will be returned in this parameter, or NULL on failure. The caller is responsible for deallocating the buffer using the \ref hs_free_database() function.

error - If the compile fails, a pointer to a \ref hs_compile_error_t will be returned, providing details of the error condition. The caller is responsible for deallocating the buffer using the \ref hs_free_compile_error() function.

Returns:

\ref HS_SUCCESS is returned on successful compilation; \ref HS_COMPILER_ERROR on failure, with details provided in the \p error parameter.

hs_compile_ext_multi

@Cast(value="hs_error_t")
public static int hs_compile_ext_multi(@Cast(value="const char*const*") @ByPtrPtr
                                                                 BytePointer expressions,
                                                                 @Cast(value="const unsigned int*")
                                                                 IntPointer flags,
                                                                 @Cast(value="const unsigned int*")
                                                                 IntPointer ids,
                                                                 @Const @ByPtrPtr
                                                                 hs_expr_ext_t ext,
                                                                 @Cast(value="unsigned int")
                                                                 int elements,
                                                                 @Cast(value="unsigned int")
                                                                 int mode,
                                                                 @Const
                                                                 hs_platform_info_t platform,
                                                                 @ByPtrPtr
                                                                 hs_database_t db,
                                                                 @ByPtrPtr
                                                                 hs_compile_error_t error)

hs_compile_ext_multi

@Cast(value="hs_error_t")
public static int hs_compile_ext_multi(@Cast(value="const char*const*") @ByPtrPtr
                                                                 ByteBuffer expressions,
                                                                 @Cast(value="const unsigned int*")
                                                                 IntBuffer flags,
                                                                 @Cast(value="const unsigned int*")
                                                                 IntBuffer ids,
                                                                 @Const @ByPtrPtr
                                                                 hs_expr_ext_t ext,
                                                                 @Cast(value="unsigned int")
                                                                 int elements,
                                                                 @Cast(value="unsigned int")
                                                                 int mode,
                                                                 @Const
                                                                 hs_platform_info_t platform,
                                                                 @ByPtrPtr
                                                                 hs_database_t db,
                                                                 @ByPtrPtr
                                                                 hs_compile_error_t error)

hs_compile_ext_multi

@Cast(value="hs_error_t")
public static int hs_compile_ext_multi(@Cast(value="const char*const*") @ByPtrPtr
                                                                 byte[] expressions,
                                                                 @Cast(value="const unsigned int*")
                                                                 int[] flags,
                                                                 @Cast(value="const unsigned int*")
                                                                 int[] ids,
                                                                 @Const @ByPtrPtr
                                                                 hs_expr_ext_t ext,
                                                                 @Cast(value="unsigned int")
                                                                 int elements,
                                                                 @Cast(value="unsigned int")
                                                                 int mode,
                                                                 @Const
                                                                 hs_platform_info_t platform,
                                                                 @ByPtrPtr
                                                                 hs_database_t db,
                                                                 @ByPtrPtr
                                                                 hs_compile_error_t error)

hs_compile_lit
```
@Cast(value="hs_error_t")
public static int hs_compile_lit(@Cast(value="const char*")
                                                           BytePointer expression,
                                                           @Cast(value="unsigned")
                                                           int flags,
                                                           @Cast(value="const size_t")
                                                           long len,
                                                           @Cast(value="unsigned")
                                                           int mode,
                                                           @Const
                                                           hs_platform_info_t platform,
                                                           @Cast(value="hs_database_t**")
                                                           PointerPointer db,
                                                           @Cast(value="hs_compile_error_t**")
                                                           PointerPointer error)
```
The basic pure literal expression compiler. This is the function call with which a pure literal expression (not a common regular expression) is compiled into a Hyperscan database which can be passed to the runtime functions (such as \ref hs_scan(), \ref hs_open_stream(), etc.)

Parameters:

expression - The NULL-terminated expression to parse. Note that this string must represent ONLY the pattern to be matched, with no delimiters or flags; any global flags should be specified with the \p flags argument. For example, the expression /abc?def/i should be compiled by providing abc?def as the \p expression, and \ref HS_FLAG_CASELESS as the \a flags. Meanwhile, the string content shall be fully parsed in a literal sense without any regular grammars. For example, the \p expression abc? simply means a char sequence of a, b, c, and ?. The ? here doesn't mean 0 or 1 quantifier under regular semantics.

flags - Flags which modify the behaviour of the expression. Multiple flags may be used by ORing them together. Compared to \ref hs_compile(), fewer valid values are provided: - HS_FLAG_CASELESS - Matching will be performed case-insensitively. - HS_FLAG_SINGLEMATCH - Only one match will be generated for the expression per stream. - HS_FLAG_SOM_LEFTMOST - Report the leftmost start of match offset when a match is found.

len - The length of the text content of the pure literal expression. As the text content indicated by \p expression is treated as single character one by one, the special terminating character \0 should be allowed to appear in expression, and not treated as a terminator for a string. Thus, the end of a pure literal expression cannot be indicated by identifying \0, but by counting to the expression length.

mode - Compiler mode flags that affect the database as a whole. One of \ref HS_MODE_STREAM or \ref HS_MODE_BLOCK or \ref HS_MODE_VECTORED must be supplied, to select between the generation of a streaming, block or vectored database. In addition, other flags (beginning with HS_MODE_) may be supplied to enable specific features. See \ref HS_MODE_FLAG for more details.

platform - If not NULL, the platform structure is used to determine the target platform for the database. If NULL, a database suitable for running on the current host platform is produced.

db - On success, a pointer to the generated database will be returned in this parameter, or NULL on failure. The caller is responsible for deallocating the buffer using the \ref hs_free_database() function.

error - If the compile fails, a pointer to a \ref hs_compile_error_t will be returned, providing details of the error condition. The caller is responsible for deallocating the buffer using the \ref hs_free_compile_error() function.

Returns:

\ref HS_SUCCESS is returned on successful compilation; \ref HS_COMPILER_ERROR on failure, with details provided in the error parameter.

hs_compile_lit

@Cast(value="hs_error_t")
public static int hs_compile_lit(@Cast(value="const char*")
                                                           BytePointer expression,
                                                           @Cast(value="unsigned")
                                                           int flags,
                                                           @Cast(value="const size_t")
                                                           long len,
                                                           @Cast(value="unsigned")
                                                           int mode,
                                                           @Const
                                                           hs_platform_info_t platform,
                                                           @ByPtrPtr
                                                           hs_database_t db,
                                                           @ByPtrPtr
                                                           hs_compile_error_t error)

hs_compile_lit

@Cast(value="hs_error_t")
public static int hs_compile_lit(String expression,
                                                           @Cast(value="unsigned")
                                                           int flags,
                                                           @Cast(value="const size_t")
                                                           long len,
                                                           @Cast(value="unsigned")
                                                           int mode,
                                                           @Const
                                                           hs_platform_info_t platform,
                                                           @ByPtrPtr
                                                           hs_database_t db,
                                                           @ByPtrPtr
                                                           hs_compile_error_t error)

hs_compile_lit_multi
```
@Cast(value="hs_error_t")
public static int hs_compile_lit_multi(@Cast(value="const char*const*")
                                                                 PointerPointer expressions,
                                                                 @Cast(value="const unsigned*")
                                                                 IntPointer flags,
                                                                 @Cast(value="const unsigned*")
                                                                 IntPointer ids,
                                                                 @Cast(value="const size_t*")
                                                                 SizeTPointer lens,
                                                                 @Cast(value="unsigned")
                                                                 int elements,
                                                                 @Cast(value="unsigned")
                                                                 int mode,
                                                                 @Const
                                                                 hs_platform_info_t platform,
                                                                 @Cast(value="hs_database_t**")
                                                                 PointerPointer db,
                                                                 @Cast(value="hs_compile_error_t**")
                                                                 PointerPointer error)
```
The multiple pure literal expression compiler. This is the function call with which a set of pure literal expressions is compiled into a database which can be passed to the runtime functions (such as \ref hs_scan(), \ref hs_open_stream(), etc.) Each expression can be labelled with a unique integer which is passed into the match callback to identify the pattern that has matched.

Parameters:

expressions - The NULL-terminated expression to parse. Note that this string must represent ONLY the pattern to be matched, with no delimiters or flags; any global flags should be specified with the \p flags argument. For example, the expression /abc?def/i should be compiled by providing abc?def as the \p expression, and \ref HS_FLAG_CASELESS as the \a flags. Meanwhile, the string content shall be fully parsed in a literal sense without any regular grammars. For example, the \p expression abc? simply means a char sequence of a, b, c, and ?. The ? here doesn't mean 0 or 1 quantifier under regular semantics.

flags - Array of flags which modify the behaviour of each expression. Multiple flags may be used by ORing them together. Specifying the NULL pointer in place of an array will set the flags value for all patterns to zero. Compared to \ref hs_compile_multi(), fewer valid values are provided: - HS_FLAG_CASELESS - Matching will be performed case-insensitively. - HS_FLAG_SINGLEMATCH - Only one match will be generated for the expression per stream. - HS_FLAG_SOM_LEFTMOST - Report the leftmost start of match offset when a match is found.

ids - An array of integers specifying the ID number to be associated with the corresponding pattern in the expressions array. Specifying the NULL pointer in place of an array will set the ID value for all patterns to zero.

lens - Array of lengths of the text content of each pure literal expression. As the text content indicated by \p expression is treated as single character one by one, the special terminating character \0 should be allowed to appear in expression, and not treated as a terminator for a string. Thus, the end of a pure literal expression cannot be indicated by identifying \0, but by counting to the expression length.

elements - The number of elements in the input arrays.

mode - Compiler mode flags that affect the database as a whole. One of \ref HS_MODE_STREAM or \ref HS_MODE_BLOCK or \ref HS_MODE_VECTORED must be supplied, to select between the generation of a streaming, block or vectored database. In addition, other flags (beginning with HS_MODE_) may be supplied to enable specific features. See \ref HS_MODE_FLAG for more details.

platform - If not NULL, the platform structure is used to determine the target platform for the database. If NULL, a database suitable for running on the current host platform is produced.

db - On success, a pointer to the generated database will be returned in this parameter, or NULL on failure. The caller is responsible for deallocating the buffer using the \ref hs_free_database() function.

error - If the compile fails, a pointer to a \ref hs_compile_error_t will be returned, providing details of the error condition. The caller is responsible for deallocating the buffer using the \ref hs_free_compile_error() function.

Returns:

\ref HS_SUCCESS is returned on successful compilation; \ref HS_COMPILER_ERROR on failure, with details provided in the error parameter.

hs_compile_lit_multi

@Cast(value="hs_error_t")
public static int hs_compile_lit_multi(@Cast(value="const char*const*") @ByPtrPtr
                                                                 BytePointer expressions,
                                                                 @Cast(value="const unsigned*")
                                                                 IntPointer flags,
                                                                 @Cast(value="const unsigned*")
                                                                 IntPointer ids,
                                                                 @Cast(value="const size_t*")
                                                                 SizeTPointer lens,
                                                                 @Cast(value="unsigned")
                                                                 int elements,
                                                                 @Cast(value="unsigned")
                                                                 int mode,
                                                                 @Const
                                                                 hs_platform_info_t platform,
                                                                 @ByPtrPtr
                                                                 hs_database_t db,
                                                                 @ByPtrPtr
                                                                 hs_compile_error_t error)

hs_compile_lit_multi

@Cast(value="hs_error_t")
public static int hs_compile_lit_multi(@Cast(value="const char*const*") @ByPtrPtr
                                                                 ByteBuffer expressions,
                                                                 @Cast(value="const unsigned*")
                                                                 IntBuffer flags,
                                                                 @Cast(value="const unsigned*")
                                                                 IntBuffer ids,
                                                                 @Cast(value="const size_t*")
                                                                 SizeTPointer lens,
                                                                 @Cast(value="unsigned")
                                                                 int elements,
                                                                 @Cast(value="unsigned")
                                                                 int mode,
                                                                 @Const
                                                                 hs_platform_info_t platform,
                                                                 @ByPtrPtr
                                                                 hs_database_t db,
                                                                 @ByPtrPtr
                                                                 hs_compile_error_t error)

hs_compile_lit_multi

@Cast(value="hs_error_t")
public static int hs_compile_lit_multi(@Cast(value="const char*const*") @ByPtrPtr
                                                                 byte[] expressions,
                                                                 @Cast(value="const unsigned*")
                                                                 int[] flags,
                                                                 @Cast(value="const unsigned*")
                                                                 int[] ids,
                                                                 @Cast(value="const size_t*")
                                                                 SizeTPointer lens,
                                                                 @Cast(value="unsigned")
                                                                 int elements,
                                                                 @Cast(value="unsigned")
                                                                 int mode,
                                                                 @Const
                                                                 hs_platform_info_t platform,
                                                                 @ByPtrPtr
                                                                 hs_database_t db,
                                                                 @ByPtrPtr
                                                                 hs_compile_error_t error)

hs_free_compile_error
```
@Cast(value="hs_error_t")
public static int hs_free_compile_error(hs_compile_error_t error)
```
Free an error structure generated by \ref hs_compile(), \ref hs_compile_multi() or \ref hs_compile_ext_multi().

Parameters:

error - The \ref hs_compile_error_t to be freed. NULL may also be safely provided.

Returns:

\ref HS_SUCCESS on success, other values on failure.

hs_expression_info
```
@Cast(value="hs_error_t")
public static int hs_expression_info(@Cast(value="const char*")
                                                               BytePointer expression,
                                                               @Cast(value="unsigned int")
                                                               int flags,
                                                               @Cast(value="hs_expr_info_t**")
                                                               PointerPointer info,
                                                               @Cast(value="hs_compile_error_t**")
                                                               PointerPointer error)
```
Utility function providing information about a regular expression. The information provided in \ref hs_expr_info_t includes the minimum and maximum width of a pattern match. Note: successful analysis of an expression with this function does not imply that compilation of the same expression (via \ref hs_compile(), \ref hs_compile_multi() or \ref hs_compile_ext_multi()) would succeed. This function may return \ref HS_SUCCESS for regular expressions that Hyperscan cannot compile. Note: some per-pattern flags (such as \ref HS_FLAG_ALLOWEMPTY, \ref HS_FLAG_SOM_LEFTMOST) are accepted by this call, but as they do not affect the properties returned in the \ref hs_expr_info_t structure, they will not affect the outcome of this function.

Parameters:

expression - The NULL-terminated expression to parse. Note that this string must represent ONLY the pattern to be matched, with no delimiters or flags; any global flags should be specified with the \p flags argument. For example, the expression /abc?def/i should be compiled by providing abc?def as the \p expression, and \ref HS_FLAG_CASELESS as the \a flags.

flags - Flags which modify the behaviour of the expression. Multiple flags may be used by ORing them together. Valid values are: - HS_FLAG_CASELESS - Matching will be performed case-insensitively. - HS_FLAG_DOTALL - Matching a . will not exclude newlines. - HS_FLAG_MULTILINE - ^ and $ anchors match any newlines in data. - HS_FLAG_SINGLEMATCH - Only one match will be generated by the expression per stream. - HS_FLAG_ALLOWEMPTY - Allow expressions which can match against an empty string, such as .*. - HS_FLAG_UTF8 - Treat this pattern as a sequence of UTF-8 characters. - HS_FLAG_UCP - Use Unicode properties for character classes. - HS_FLAG_PREFILTER - Compile pattern in prefiltering mode. - HS_FLAG_SOM_LEFTMOST - Report the leftmost start of match offset when a match is found. - HS_FLAG_QUIET - This flag will be ignored.

info - On success, a pointer to the pattern information will be returned in this parameter, or NULL on failure. This structure is allocated using the allocator supplied in \ref hs_set_allocator() (or malloc() if no allocator was set) and should be freed by the caller.

error - If the call fails, a pointer to a \ref hs_compile_error_t will be returned, providing details of the error condition. The caller is responsible for deallocating the buffer using the \ref hs_free_compile_error() function.

Returns:

\ref HS_SUCCESS is returned on successful compilation; \ref HS_COMPILER_ERROR on failure, with details provided in the error parameter.

hs_expression_info

@Cast(value="hs_error_t")
public static int hs_expression_info(@Cast(value="const char*")
                                                               BytePointer expression,
                                                               @Cast(value="unsigned int")
                                                               int flags,
                                                               @ByPtrPtr
                                                               hs_expr_info_t info,
                                                               @ByPtrPtr
                                                               hs_compile_error_t error)

hs_expression_info

@Cast(value="hs_error_t")
public static int hs_expression_info(String expression,
                                                               @Cast(value="unsigned int")
                                                               int flags,
                                                               @ByPtrPtr
                                                               hs_expr_info_t info,
                                                               @ByPtrPtr
                                                               hs_compile_error_t error)

hs_expression_ext_info
```
@Cast(value="hs_error_t")
public static int hs_expression_ext_info(@Cast(value="const char*")
                                                                   BytePointer expression,
                                                                   @Cast(value="unsigned int")
                                                                   int flags,
                                                                   @Const
                                                                   hs_expr_ext_t ext,
                                                                   @Cast(value="hs_expr_info_t**")
                                                                   PointerPointer info,
                                                                   @Cast(value="hs_compile_error_t**")
                                                                   PointerPointer error)
```
Utility function providing information about a regular expression, with extended parameter support. The information provided in \ref hs_expr_info_t includes the minimum and maximum width of a pattern match. Note: successful analysis of an expression with this function does not imply that compilation of the same expression (via \ref hs_compile(), \ref hs_compile_multi() or \ref hs_compile_ext_multi()) would succeed. This function may return \ref HS_SUCCESS for regular expressions that Hyperscan cannot compile. Note: some per-pattern flags (such as \ref HS_FLAG_ALLOWEMPTY, \ref HS_FLAG_SOM_LEFTMOST) are accepted by this call, but as they do not affect the properties returned in the \ref hs_expr_info_t structure, they will not affect the outcome of this function.

Parameters:

expression - The NULL-terminated expression to parse. Note that this string must represent ONLY the pattern to be matched, with no delimiters or flags; any global flags should be specified with the \p flags argument. For example, the expression /abc?def/i should be compiled by providing abc?def as the \p expression, and \ref HS_FLAG_CASELESS as the \a flags.

flags - Flags which modify the behaviour of the expression. Multiple flags may be used by ORing them together. Valid values are: - HS_FLAG_CASELESS - Matching will be performed case-insensitively. - HS_FLAG_DOTALL - Matching a . will not exclude newlines. - HS_FLAG_MULTILINE - ^ and $ anchors match any newlines in data. - HS_FLAG_SINGLEMATCH - Only one match will be generated by the expression per stream. - HS_FLAG_ALLOWEMPTY - Allow expressions which can match against an empty string, such as .*. - HS_FLAG_UTF8 - Treat this pattern as a sequence of UTF-8 characters. - HS_FLAG_UCP - Use Unicode properties for character classes. - HS_FLAG_PREFILTER - Compile pattern in prefiltering mode. - HS_FLAG_SOM_LEFTMOST - Report the leftmost start of match offset when a match is found. - HS_FLAG_QUIET - This flag will be ignored.

ext - A pointer to a filled \ref hs_expr_ext_t structure that defines extended behaviour for this pattern. NULL may be specified if no extended parameters are needed.

info - On success, a pointer to the pattern information will be returned in this parameter, or NULL on failure. This structure is allocated using the allocator supplied in \ref hs_set_allocator() (or malloc() if no allocator was set) and should be freed by the caller.

error - If the call fails, a pointer to a \ref hs_compile_error_t will be returned, providing details of the error condition. The caller is responsible for deallocating the buffer using the \ref hs_free_compile_error() function.

Returns:

\ref HS_SUCCESS is returned on successful compilation; \ref HS_COMPILER_ERROR on failure, with details provided in the error parameter.

hs_expression_ext_info

@Cast(value="hs_error_t")
public static int hs_expression_ext_info(@Cast(value="const char*")
                                                                   BytePointer expression,
                                                                   @Cast(value="unsigned int")
                                                                   int flags,
                                                                   @Const
                                                                   hs_expr_ext_t ext,
                                                                   @ByPtrPtr
                                                                   hs_expr_info_t info,
                                                                   @ByPtrPtr
                                                                   hs_compile_error_t error)

hs_expression_ext_info

@Cast(value="hs_error_t")
public static int hs_expression_ext_info(String expression,
                                                                   @Cast(value="unsigned int")
                                                                   int flags,
                                                                   @Const
                                                                   hs_expr_ext_t ext,
                                                                   @ByPtrPtr
                                                                   hs_expr_info_t info,
                                                                   @ByPtrPtr
                                                                   hs_compile_error_t error)

hs_populate_platform
```
@Cast(value="hs_error_t")
public static int hs_populate_platform(hs_platform_info_t platform)
```
Populates the platform information based on the current host.

Parameters:

platform - On success, the pointed to structure is populated based on the current host.

Returns:

\ref HS_SUCCESS on success, other values on failure.

hs_open_stream

@Cast(value="hs_error_t")
public static int hs_open_stream(@Const
                                                           hs_database_t db,
                                                           @Cast(value="unsigned int")
                                                           int flags,
                                                           @Cast(value="hs_stream_t**")
                                                           PointerPointer stream)

Open and initialise a stream.

Parameters:: db - A compiled pattern database.; flags - Flags modifying the behaviour of the stream. This parameter is provided for future use and is unused at present.; stream - On success, a pointer to the generated \ref hs_stream_t will be returned; NULL on failure.
Returns:: \ref HS_SUCCESS on success, other values on failure.

hs_open_stream

@Cast(value="hs_error_t")
public static int hs_open_stream(@Const
                                                           hs_database_t db,
                                                           @Cast(value="unsigned int")
                                                           int flags,
                                                           @ByPtrPtr
                                                           hs_stream_t stream)

hs_scan_stream

@Cast(value="hs_error_t")
public static int hs_scan_stream(hs_stream_t id,
                                                           @Cast(value="const char*")
                                                           BytePointer data,
                                                           @Cast(value="unsigned int")
                                                           int length,
                                                           @Cast(value="unsigned int")
                                                           int flags,
                                                           hs_scratch_t scratch,
                                                           match_event_handler onEvent,
                                                           Pointer ctxt)

Write data to be scanned to the opened stream. This is the function call in which the actual pattern matching takes place as data is written to the stream. Matches will be returned via the \ref match_event_handler callback supplied.

Parameters:: id - The stream ID (returned by \ref hs_open_stream()) to which the data will be written.; data - Pointer to the data to be scanned.; length - The number of bytes to scan.; flags - Flags modifying the behaviour of the stream. This parameter is provided for future use and is unused at present.; scratch - A per-thread scratch space allocated by \ref hs_alloc_scratch().; onEvent - Pointer to a match event callback function. If a NULL pointer is given, no matches will be returned.; ctxt - The user defined pointer which will be passed to the callback function when a match occurs.
Returns:: Returns \ref HS_SUCCESS on success; \ref HS_SCAN_TERMINATED if the match callback indicated that scanning should stop; other values on error.

hs_scan_stream

@Cast(value="hs_error_t")
public static int hs_scan_stream(hs_stream_t id,
                                                           String data,
                                                           @Cast(value="unsigned int")
                                                           int length,
                                                           @Cast(value="unsigned int")
                                                           int flags,
                                                           hs_scratch_t scratch,
                                                           match_event_handler onEvent,
                                                           Pointer ctxt)

hs_close_stream
```
@Cast(value="hs_error_t")
public static int hs_close_stream(hs_stream_t id,
                                                            hs_scratch_t scratch,
                                                            match_event_handler onEvent,
                                                            Pointer ctxt)
```
Close a stream. This function completes matching on the given stream and frees the memory associated with the stream state. After this call, the stream pointed to by \p id is invalid and can no longer be used. To reuse the stream state after completion, rather than closing it, the \ref hs_reset_stream function can be used. This function must be called for any stream created with \ref hs_open_stream(), even if scanning has been terminated by a non-zero return from the match callback function. Note: This operation may result in matches being returned (via calls to the match event callback) for expressions anchored to the end of the data stream (for example, via the use of the $ meta-character). If these matches are not desired, NULL may be provided as the \ref match_event_handler callback. If NULL is provided as the \ref match_event_handler callback, it is permissible to provide a NULL scratch.

Parameters:

id - The stream ID returned by \ref hs_open_stream().

scratch - A per-thread scratch space allocated by \ref hs_alloc_scratch(). This is allowed to be NULL only if the \p onEvent callback is also NULL.

onEvent - Pointer to a match event callback function. If a NULL pointer is given, no matches will be returned.

ctxt - The user defined pointer which will be passed to the callback function when a match occurs.

Returns:

Returns \ref HS_SUCCESS on success, other values on failure.

hs_reset_stream
```
@Cast(value="hs_error_t")
public static int hs_reset_stream(hs_stream_t id,
                                                            @Cast(value="unsigned int")
                                                            int flags,
                                                            hs_scratch_t scratch,
                                                            match_event_handler onEvent,
                                                            Pointer context)
```
Reset a stream to an initial state. Conceptually, this is equivalent to performing \ref hs_close_stream() on the given stream, followed by a \ref hs_open_stream(). This new stream replaces the original stream in memory, avoiding the overhead of freeing the old stream and allocating the new one. Note: This operation may result in matches being returned (via calls to the match event callback) for expressions anchored to the end of the original data stream (for example, via the use of the $ meta-character). If these matches are not desired, NULL may be provided as the \ref match_event_handler callback. Note: the stream will also be tied to the same database.

Parameters:

id - The stream (as created by \ref hs_open_stream()) to be replaced.

flags - Flags modifying the behaviour of the stream. This parameter is provided for future use and is unused at present.

scratch - A per-thread scratch space allocated by \ref hs_alloc_scratch(). This is allowed to be NULL only if the \p onEvent callback is also NULL.

onEvent - Pointer to a match event callback function. If a NULL pointer is given, no matches will be returned.

context - The user defined pointer which will be passed to the callback function when a match occurs.

Returns:

\ref HS_SUCCESS on success, other values on failure.

hs_copy_stream

@Cast(value="hs_error_t")
public static int hs_copy_stream(@Cast(value="hs_stream_t**")
                                                           PointerPointer to_id,
                                                           @Const
                                                           hs_stream_t from_id)

Duplicate the given stream. The new stream will have the same state as the original including the current stream offset.

Parameters:: to_id - On success, a pointer to the new, copied \ref hs_stream_t will be returned; NULL on failure.; from_id - The stream (as created by \ref hs_open_stream()) to be copied.
Returns:: \ref HS_SUCCESS on success, other values on failure.

hs_copy_stream

@Cast(value="hs_error_t")
public static int hs_copy_stream(@ByPtrPtr
                                                           hs_stream_t to_id,
                                                           @Const
                                                           hs_stream_t from_id)

hs_reset_and_copy_stream
```
@Cast(value="hs_error_t")
public static int hs_reset_and_copy_stream(hs_stream_t to_id,
                                                                     @Const
                                                                     hs_stream_t from_id,
                                                                     hs_scratch_t scratch,
                                                                     match_event_handler onEvent,
                                                                     Pointer context)
```
Duplicate the given 'from' stream state onto the 'to' stream. The 'to' stream will first be reset (reporting any EOD matches if a non-NULL \p onEvent callback handler is provided). Note: the 'to' stream and the 'from' stream must be open against the same database.

Parameters:

to_id - On success, a pointer to the new, copied \ref hs_stream_t will be returned; NULL on failure.

from_id - The stream (as created by \ref hs_open_stream()) to be copied.

scratch - A per-thread scratch space allocated by \ref hs_alloc_scratch(). This is allowed to be NULL only if the \p onEvent callback is also NULL.

onEvent - Pointer to a match event callback function. If a NULL pointer is given, no matches will be returned.

context - The user defined pointer which will be passed to the callback function when a match occurs.

Returns:

\ref HS_SUCCESS on success, other values on failure.

hs_compress_stream
```
@Cast(value="hs_error_t")
public static int hs_compress_stream(@Const
                                                               hs_stream_t stream,
                                                               @Cast(value="char*")
                                                               BytePointer buf,
                                                               @Cast(value="size_t")
                                                               long buf_space,
                                                               @Cast(value="size_t*")
                                                               SizeTPointer used_space)
```
Creates a compressed representation of the provided stream in the buffer provided. This compressed representation can be converted back into a stream state by using \ref hs_expand_stream() or \ref hs_reset_and_expand_stream(). The size of the compressed representation will be placed into \p used_space. If there is not sufficient space in the buffer to hold the compressed representation, \ref HS_INSUFFICIENT_SPACE will be returned and \p used_space will be populated with the amount of space required. Note: this function does not close the provided stream, you may continue to use the stream or to free it with \ref hs_close_stream().

Parameters:

stream - The stream (as created by \ref hs_open_stream()) to be compressed.

buf - Buffer to write the compressed representation into. Note: if the call is just being used to determine the amount of space required, it is allowed to pass NULL here and \p buf_space as 0.

buf_space - The number of bytes in \p buf. If buf_space is too small, the call will fail with \ref HS_INSUFFICIENT_SPACE.

used_space - Pointer to where the amount of used space will be written to. The used buffer space is always less than or equal to \p buf_space. If the call fails with \ref HS_INSUFFICIENT_SPACE, this pointer will be used to write out the amount of buffer space required.

Returns:

\ref HS_SUCCESS on success, \ref HS_INSUFFICIENT_SPACE if the provided buffer is too small.

hs_compress_stream

@Cast(value="hs_error_t")
public static int hs_compress_stream(@Const
                                                               hs_stream_t stream,
                                                               @Cast(value="char*")
                                                               ByteBuffer buf,
                                                               @Cast(value="size_t")
                                                               long buf_space,
                                                               @Cast(value="size_t*")
                                                               SizeTPointer used_space)

hs_compress_stream

@Cast(value="hs_error_t")
public static int hs_compress_stream(@Const
                                                               hs_stream_t stream,
                                                               @Cast(value="char*")
                                                               byte[] buf,
                                                               @Cast(value="size_t")
                                                               long buf_space,
                                                               @Cast(value="size_t*")
                                                               SizeTPointer used_space)

hs_expand_stream

@Cast(value="hs_error_t")
public static int hs_expand_stream(@Const
                                                             hs_database_t db,
                                                             @Cast(value="hs_stream_t**")
                                                             PointerPointer stream,
                                                             @Cast(value="const char*")
                                                             BytePointer buf,
                                                             @Cast(value="size_t")
                                                             long buf_size)

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

Parameters:: db - The compiled pattern database that the compressed stream was opened against.; stream - On success, a pointer to the expanded \ref hs_stream_t will be returned; NULL on failure.; buf - A compressed representation of a stream. These compressed forms are created by \ref hs_compress_stream().; buf_size - The size in bytes of the compressed representation.
Returns:: \ref HS_SUCCESS on success, other values on failure.

hs_expand_stream

@Cast(value="hs_error_t")
public static int hs_expand_stream(@Const
                                                             hs_database_t db,
                                                             @ByPtrPtr
                                                             hs_stream_t stream,
                                                             @Cast(value="const char*")
                                                             BytePointer buf,
                                                             @Cast(value="size_t")
                                                             long buf_size)

hs_expand_stream

@Cast(value="hs_error_t")
public static int hs_expand_stream(@Const
                                                             hs_database_t db,
                                                             @ByPtrPtr
                                                             hs_stream_t stream,
                                                             String buf,
                                                             @Cast(value="size_t")
                                                             long buf_size)

hs_reset_and_expand_stream
```
@Cast(value="hs_error_t")
public static int hs_reset_and_expand_stream(hs_stream_t to_stream,
                                                                       @Cast(value="const char*")
                                                                       BytePointer buf,
                                                                       @Cast(value="size_t")
                                                                       long buf_size,
                                                                       hs_scratch_t scratch,
                                                                       match_event_handler onEvent,
                                                                       Pointer context)
```
Decompresses a compressed representation created by \ref hs_compress_stream() on top of the 'to' stream. The 'to' stream will first be reset (reporting any EOD matches if a non-NULL \p onEvent callback handler is provided). Note: the 'to' stream must be opened against the same database as the compressed stream. Note: \p buf must correspond to a complete compressed representation created by \ref hs_compress_stream() of a stream that was opened against \p db. It is not always possible to detect misuse of this API and behaviour is undefined if these properties are not satisfied.

Parameters:

to_stream - A pointer to a valid stream state. A pointer to the expanded \ref hs_stream_t will be returned; NULL on failure.

buf - A compressed representation of a stream. These compressed forms are created by \ref hs_compress_stream().

buf_size - The size in bytes of the compressed representation.

scratch - A per-thread scratch space allocated by \ref hs_alloc_scratch(). This is allowed to be NULL only if the \p onEvent callback is also NULL.

onEvent - Pointer to a match event callback function. If a NULL pointer is given, no matches will be returned.

context - The user defined pointer which will be passed to the callback function when a match occurs.

Returns:

\ref HS_SUCCESS on success, other values on failure.

hs_reset_and_expand_stream

@Cast(value="hs_error_t")
public static int hs_reset_and_expand_stream(hs_stream_t to_stream,
                                                                       String buf,
                                                                       @Cast(value="size_t")
                                                                       long buf_size,
                                                                       hs_scratch_t scratch,
                                                                       match_event_handler onEvent,
                                                                       Pointer context)

hs_scan

@Cast(value="hs_error_t")
public static int hs_scan(@Const
                                                    hs_database_t db,
                                                    @Cast(value="const char*")
                                                    BytePointer data,
                                                    @Cast(value="unsigned int")
                                                    int length,
                                                    @Cast(value="unsigned int")
                                                    int flags,
                                                    hs_scratch_t scratch,
                                                    match_event_handler onEvent,
                                                    Pointer context)

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.

Parameters:: db - A compiled pattern database.; data - Pointer to the data to be scanned.; length - The number of bytes to scan.; flags - Flags modifying the behaviour of this function. This parameter is provided for future use and is unused at present.; scratch - A per-thread scratch space allocated by \ref hs_alloc_scratch() for this database.; onEvent - Pointer to a match event callback function. If a NULL pointer is given, no matches will be returned.; context - The user defined pointer which will be passed to the callback function.
Returns:: Returns \ref HS_SUCCESS on success; \ref HS_SCAN_TERMINATED if the match callback indicated that scanning should stop; other values on error.

hs_scan

@Cast(value="hs_error_t")
public static int hs_scan(@Const
                                                    hs_database_t db,
                                                    String data,
                                                    @Cast(value="unsigned int")
                                                    int length,
                                                    @Cast(value="unsigned int")
                                                    int flags,
                                                    hs_scratch_t scratch,
                                                    match_event_handler onEvent,
                                                    Pointer context)

hs_scan_vector

@Cast(value="hs_error_t")
public static int hs_scan_vector(@Const
                                                           hs_database_t db,
                                                           @Cast(value="const char*const*")
                                                           PointerPointer data,
                                                           @Cast(value="const unsigned int*")
                                                           IntPointer length,
                                                           @Cast(value="unsigned int")
                                                           int count,
                                                           @Cast(value="unsigned int")
                                                           int flags,
                                                           hs_scratch_t scratch,
                                                           match_event_handler onEvent,
                                                           Pointer context)

The vectored regular expression scanner. This is the function call in which the actual pattern matching takes place for vectoring-mode pattern databases.

Parameters:: db - A compiled pattern database.; data - An array of pointers to the data blocks to be scanned.; length - An array of lengths (in bytes) of each data block to scan.; count - Number of data blocks to scan. This should correspond to the size of of the \p data and \p length arrays.; flags - Flags modifying the behaviour of this function. This parameter is provided for future use and is unused at present.; scratch - A per-thread scratch space allocated by \ref hs_alloc_scratch() for this database.; onEvent - Pointer to a match event callback function. If a NULL pointer is given, no matches will be returned.; context - The user defined pointer which will be passed to the callback function.
Returns:: Returns \ref HS_SUCCESS on success; \ref HS_SCAN_TERMINATED if the match callback indicated that scanning should stop; other values on error.

hs_scan_vector

@Cast(value="hs_error_t")
public static int hs_scan_vector(@Const
                                                           hs_database_t db,
                                                           @Cast(value="const char*const*") @ByPtrPtr
                                                           BytePointer data,
                                                           @Cast(value="const unsigned int*")
                                                           IntPointer length,
                                                           @Cast(value="unsigned int")
                                                           int count,
                                                           @Cast(value="unsigned int")
                                                           int flags,
                                                           hs_scratch_t scratch,
                                                           match_event_handler onEvent,
                                                           Pointer context)

hs_scan_vector

@Cast(value="hs_error_t")
public static int hs_scan_vector(@Const
                                                           hs_database_t db,
                                                           @Cast(value="const char*const*") @ByPtrPtr
                                                           ByteBuffer data,
                                                           @Cast(value="const unsigned int*")
                                                           IntBuffer length,
                                                           @Cast(value="unsigned int")
                                                           int count,
                                                           @Cast(value="unsigned int")
                                                           int flags,
                                                           hs_scratch_t scratch,
                                                           match_event_handler onEvent,
                                                           Pointer context)

hs_scan_vector

@Cast(value="hs_error_t")
public static int hs_scan_vector(@Const
                                                           hs_database_t db,
                                                           @Cast(value="const char*const*") @ByPtrPtr
                                                           byte[] data,
                                                           @Cast(value="const unsigned int*")
                                                           int[] length,
                                                           @Cast(value="unsigned int")
                                                           int count,
                                                           @Cast(value="unsigned int")
                                                           int flags,
                                                           hs_scratch_t scratch,
                                                           match_event_handler onEvent,
                                                           Pointer context)

hs_alloc_scratch
```
@Cast(value="hs_error_t")
public static int hs_alloc_scratch(@Const
                                                             hs_database_t db,
                                                             @Cast(value="hs_scratch_t**")
                                                             PointerPointer scratch)
```
Allocate a "scratch" space for use by Hyperscan. This is required for runtime use, and one scratch space per thread, or concurrent caller, is required. Any allocator callback set by \ref hs_set_scratch_allocator() or \ref hs_set_allocator() will be used by this function.

Parameters:

db - The database, as produced by \ref hs_compile().

scratch - On first allocation, a pointer to NULL should be provided so a new scratch can be allocated. If a scratch block has been previously allocated, then a pointer to it should be passed back in to see if it is valid for this database block. If a new scratch block is required, the original will be freed and the new one returned, otherwise the previous scratch block will be returned. On success, the scratch block will be suitable for use with the provided database in addition to any databases that original scratch space was suitable for.

Returns:

\ref HS_SUCCESS on successful allocation; \ref HS_NOMEM if the allocation fails. Other errors may be returned if invalid parameters are specified.

hs_alloc_scratch

@Cast(value="hs_error_t")
public static int hs_alloc_scratch(@Const
                                                             hs_database_t db,
                                                             @ByPtrPtr
                                                             hs_scratch_t scratch)

hs_clone_scratch
```
@Cast(value="hs_error_t")
public static int hs_clone_scratch(@Const
                                                             hs_scratch_t src,
                                                             @Cast(value="hs_scratch_t**")
                                                             PointerPointer dest)
```
Allocate a scratch space that is a clone of an existing scratch space. This is useful when multiple concurrent threads will be using the same set of compiled databases, and another scratch space is required. Any allocator callback set by \ref hs_set_scratch_allocator() or \ref hs_set_allocator() will be used by this function.

Parameters:

src - The existing \ref hs_scratch_t to be cloned.

dest - A pointer to the new scratch space will be returned here.

Returns:

\ref HS_SUCCESS on success; \ref HS_NOMEM if the allocation fails. Other errors may be returned if invalid parameters are specified.

hs_clone_scratch

@Cast(value="hs_error_t")
public static int hs_clone_scratch(@Const
                                                             hs_scratch_t src,
                                                             @ByPtrPtr
                                                             hs_scratch_t dest)

hs_scratch_size

@Cast(value="hs_error_t")
public static int hs_scratch_size(@Const
                                                            hs_scratch_t scratch,
                                                            @Cast(value="size_t*")
                                                            SizeTPointer scratch_size)

Provides the size of the given scratch space.

Parameters:: scratch - A per-thread scratch space allocated by \ref hs_alloc_scratch() or \ref hs_clone_scratch().; scratch_size - On success, the size of the scratch space in bytes is placed in this parameter.
Returns:: \ref HS_SUCCESS on success, other values on failure.

hs_free_scratch
```
@Cast(value="hs_error_t")
public static int hs_free_scratch(hs_scratch_t scratch)
```
Free a scratch block previously allocated by \ref hs_alloc_scratch() or \ref hs_clone_scratch(). The free callback set by \ref hs_set_scratch_allocator() or \ref hs_set_allocator() will be used by this function.

Parameters:

scratch - The scratch block to be freed. NULL may also be safely provided.

Returns:

\ref HS_SUCCESS on success, other values on failure.

Class hyperscan

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.bytedeco.hyperscan.presets.hyperscan

Methods inherited from class java.lang.Object

Field Detail

HS_SUCCESS

HS_INVALID

HS_NOMEM

HS_SCAN_TERMINATED

HS_COMPILER_ERROR

HS_DB_VERSION_ERROR

HS_DB_PLATFORM_ERROR

HS_DB_MODE_ERROR

HS_BAD_ALIGN

HS_BAD_ALLOC

HS_SCRATCH_IN_USE

HS_ARCH_ERROR

HS_INSUFFICIENT_SPACE

HS_UNKNOWN_ERROR

HS_EXT_FLAG_MIN_OFFSET

HS_EXT_FLAG_MAX_OFFSET

HS_EXT_FLAG_MIN_LENGTH

HS_EXT_FLAG_EDIT_DISTANCE

HS_EXT_FLAG_HAMMING_DISTANCE

HS_FLAG_CASELESS

HS_FLAG_DOTALL

HS_FLAG_MULTILINE

HS_FLAG_SINGLEMATCH

HS_FLAG_ALLOWEMPTY

HS_FLAG_UTF8

HS_FLAG_UCP

HS_FLAG_PREFILTER

HS_FLAG_SOM_LEFTMOST

HS_FLAG_COMBINATION

HS_FLAG_QUIET

HS_CPU_FEATURES_AVX2

HS_CPU_FEATURES_AVX512

HS_CPU_FEATURES_AVX512VBMI

HS_TUNE_FAMILY_GENERIC

HS_TUNE_FAMILY_SNB

HS_TUNE_FAMILY_IVB

HS_TUNE_FAMILY_HSW

HS_TUNE_FAMILY_SLM

HS_TUNE_FAMILY_BDW

HS_TUNE_FAMILY_SKL

HS_TUNE_FAMILY_SKX

HS_TUNE_FAMILY_GLM

HS_TUNE_FAMILY_ICL

HS_TUNE_FAMILY_ICX

HS_MODE_BLOCK

HS_MODE_NOSTREAM

HS_MODE_STREAM

HS_MODE_VECTORED

HS_MODE_SOM_HORIZON_LARGE

HS_MODE_SOM_HORIZON_MEDIUM

HS_MODE_SOM_HORIZON_SMALL

HS_OFFSET_PAST_HORIZON

HS_MAJOR

HS_MINOR

HS_PATCH

Constructor Detail

hyperscan

Method Detail

hs_free_database

hs_serialize_database

hs_serialize_database

hs_serialize_database

hs_serialize_database

hs_deserialize_database

hs_deserialize_database

hs_deserialize_database

hs_deserialize_database_at

hs_deserialize_database_at

hs_stream_size

hs_database_size

hs_serialized_database_size

hs_serialized_database_size

hs_database_info