Struct sibyl::Raw

pub struct Raw<'e> { /* fields omitted */ }

Represents RAW and LONG RAW data types.

Methods

impl<'e> Raw<'e>

pub fn from_bytes(data: &[u8], env: &'e dyn Env) -> Result<Self>

Returns a new Raw constructed with the copy of the data

Example

use sibyl as oracle;

let env = oracle::env()?;
let data: [u8;5] = [1,2,3,4,5];
let raw = oracle::Raw::from_bytes(&data, &env)?;

let size = raw.capacity()?;
assert!(5 <= size);

let len = raw.len();
assert_eq!(5, len);

let raw_data_ptr = raw.as_raw_ptr();
assert!(raw_data_ptr != std::ptr::null_mut::<u8>());

let raw_data: &[u8] = unsafe { std::slice::from_raw_parts(raw_data_ptr, len as usize) };
assert_eq!(data, raw_data);

pub fn from_raw(other: &Raw<'e>) -> Result<Self>

Returns a new Raw constructed with the copy of the date from the other Raw.

Example

use sibyl as oracle;

let env = oracle::env()?;
let data: [u8;5] = [1,2,3,4,5];
let src = oracle::Raw::from_bytes(&data, &env)?;
let dst = oracle::Raw::from_raw(&src)?;

let raw_data_ptr = src.as_raw_ptr();
assert!(raw_data_ptr != std::ptr::null_mut::<u8>());

let len = src.len();
assert_eq!(5, len);

let src_data: &[u8] = unsafe { std::slice::from_raw_parts(raw_data_ptr, len as usize) };
let raw_data_ptr = dst.as_raw_ptr();
assert!(raw_data_ptr != std::ptr::null_mut::<u8>());

let len = dst.len();
assert_eq!(5, len);

let dst_data: &[u8] = unsafe { std::slice::from_raw_parts(raw_data_ptr, len as usize) };
assert_eq!(dst_data, src_data);

pub fn with_capacity(size: usize, env: &'e dyn Env) -> Result<Self>

Returns a new Raw with the memory allocated for the raw data.

Example

use sibyl as oracle;

let env = oracle::env()?;
let raw = oracle::Raw::with_capacity(19, &env)?;

let size = raw.capacity()?;
assert!(19 <= size);

let len = raw.len();
assert_eq!(0, len);

pub fn len(&self) -> usize

Returns the size of the raw data in bytes.

Example

use sibyl as oracle;

let env = oracle::env()?;
let data: [u8;5] = [1,2,3,4,5];
let raw = oracle::Raw::from_bytes(&data, &env)?;
let len = raw.len();

assert_eq!(5, len);

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

Returns the allocated size of raw memory in bytes

Example

use sibyl as oracle;

let env = oracle::env()?;
let raw = oracle::Raw::with_capacity(19, &env)?;
let size = raw.capacity()?;

assert!(19 <= size);

pub fn resize(&mut self, new_size: usize) -> Result<()>

Changes the size of the memory of this raw binary in the object cache. Previous content is not preserved.

Example

use sibyl as oracle;

let env = oracle::env()?;
let mut bin = oracle::Raw::with_capacity(10, &env)?;
let cap = bin.capacity()?;
assert!(cap >= 10);

bin.resize(20);
let cap = bin.capacity()?;
assert!(cap >= 20);

bin.resize(0);
let cap = bin.capacity()?;
assert_eq!(0, cap);

bin.resize(16);
let cap = bin.capacity()?;
assert!(cap >= 16);

pub fn as_raw_ptr(&self) -> *mut u8

Returns unsafe pointer to the RAW data

Example

use sibyl as oracle;

let env = oracle::env()?;
let data: [u8;5] = [1,2,3,4,5];
let raw = oracle::Raw::from_bytes(&data, &env)?;

let raw_data_ptr = raw.as_raw_ptr();
assert!(raw_data_ptr != std::ptr::null_mut::<u8>());

let raw_data: &[u8] = unsafe { std::slice::from_raw_parts(raw_data_ptr, raw.len() as usize) };
assert_eq!(data, raw_data);

Trait Implementations

impl<'_> ToSql for Raw<'_>

fn to_sql(&self) -> (u16, *const c_void, usize)

Returns a tuple with (SQLT type, pointer to the data buffer, length of the data in the buffer)

impl<'_> ToSqlOut for Raw<'_>

fn to_sql_output(&mut self, _col_size: usize) -> (u16, *mut c_void, usize)

Returns output buffer characteristics as a tuple of (SQLT type, buffer pointer, buffer size)

fn set_len(&mut self, _new_len: usize)

Called to set the received data length (always less than the initial capacity)

impl<'_> Drop for Raw<'_>

fn drop(&mut self)

Executes the destructor for this type.