Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/bmsparsevec__serial_8h_source.html below:

NCBI C++ ToolKit: include/util/bitset/bmsparsevec_serial.h Source File

<

BV,

TOut>

tout << bv.count() <<

;

BV::enumerator en = bv.first();

(; en.valid(); ++en)

<

SV>

<

SV>

*

,

clear_sv =

);

clear_sv =

);

*

,

*

);

*

,

*

,

(SV& sv,

* remap_buf_ptr);

sv_serializer.

(sv, sv_layout);

*

,

<

CBC>

<

CBC>

*

,

<

CBC>

buffer_coll.calc_stat(&

);

.resize(

.max_serialize_mem);

* buf_ptr =

.data();

enc.

((

)bo);

* mbuf1 = enc.

();

addr_bv_size = bvs.

(bv, buf_ptr,

.size());

buf_ptr += addr_bv_size;

enc.

(addr_bv_size);

coll_size = buffer_coll.size();

(

= 0;

< buffer_coll.size(); ++

)

sz = cbuf.size();

(

= 0;

< buffer_coll.size(); ++

)

sz = cbuf.size();

enc.

(cbuf.buf(), sz);

<

CBC>

*

,

h1 = dec.

();

h2 = dec.

();

(h1 !=

&& h2 !=

)

* bv_buf_ptr = dec.

();

bvector_type::size_type addr_cnt = bv.count();

dec.

((

)addr_bv_size);

(coll_size != addr_cnt)

vect_size_type;

buf_size_vec.

(vect_size_type(coll_size));

(

= 0;

< coll_size; ++

)

buf_size_vec[

] = sz;

buf_vect.

(vect_size_type(coll_size));

(

= 0;

< coll_size; ++

)

dec.

(

.data(),

(sz));

<

SV>

<

SV>

bv_ref_ptr_ = bv_ref_ptr;

is_xor_ref_ =

(bv_ref_ptr);

<

SV>

is_xor_ref_ = is_enabled;

<

SV>

bvs_.compute_sim_model(sim_model,

, params);

<

SV>

sim_model_ptr_ = sim_model;

<

SV>

bv_ref_.build(sv.get_bmatrix());

<

SV>

SV::remap_matrix_type* rm = sv.get_remap_matrix();

rows = rmatr.rows();

cols = rmatr.cols();

remap_rlen_vect_.resize(0);

(

= 0;

< rows; ++

)

*

remap_row = rmatr.row(

);

remap_rlen_vect_.push_back(

(

));

rows = remap_rlen_vect_.size();

(

= 0;

< rows; ++

)

rl = remap_rlen_vect_[

];

csr_size_max += rl * 2;

remap_size = sv.remap_size();

(remap_size < csr_size_max)

* matrix_buf = sv.get_remap_buffer();

enc.

(matrix_buf,

(remap_size));

enc.

(

(rows));

(

= 0;

< rows; ++

)

rl = remap_rlen_vect_[

];

(

= 0;

< rows; ++

)

(

j = 0; j < cols; ++j)

v =

[j];

enc.

((

)j);

<

SV>

bvs_.allow_stat_reset(

);

bvs_.reset_compression_stats();

[0]=

;

[1] =

;

& bmatr = sv.get_bmatrix();

bmatr.build_plane_digest(plane_digest_bv_);

plane_digest_bv_.optimize();

bvs_.set_ref_vectors(0);

bvs_.serialize(plane_digest_bv_, plane_digest_buf_);

planes = (unsigned)bmatr.rows();

SV::statistics sv_stat;

sv.calc_stat(&sv_stat);

sv_stat.max_serialize_mem += plane_digest_buf_.size() + (8 * planes);

*

= sv_layout.

(sv_stat.max_serialize_mem);

h_size = 1 + 1 +

bvs_.set_ref_vectors(bv_ref_ptr_);

bvs_.set_sim_model(sim_model_ptr_);

build_xor_ref_vector(sv);

bvs_.set_ref_vectors(&bv_ref_);

(bvs_.compute_sim_model(sim_model_, bv_ref_, xs_params))

bvs_.set_sim_model(&sim_model_);

::memset(

, 0, h_size);

* buf_ptr =

+ h_size;

(

= 0;

< planes; ++

)

SV::bvector_type_const_ptr bv = bmatr.row(

);

idx = (unsigned)bv_ref_ptr_->find_bv(bv);

idx = (unsigned)bv_ref_.find_bv(bv);

bvs_.set_curr_ref_idx(idx);

buf_size = (size_t)

bvs_.serialize(*bv, buf_ptr, sv_stat.max_serialize_mem);

sv_layout.

(

, buf_ptr, buf_size);

buf_ptr += buf_size;

(sv_stat.max_serialize_mem > buf_size)

sv_stat.max_serialize_mem -= buf_size;

bvs_.set_ref_vectors(0);

enc_m(buf_ptr, sv_stat.max_serialize_mem);

encode_remap_matrix(enc_m, sv);

enc_m.

(

);

buf_ptr += enc_m.

();

digest_offset = size_t(buf_ptr -

);

pd_size = plane_digest_buf_.size();

::memcpy(buf_ptr, plane_digest_buf_.buf(), pd_size);

use_64bit =

;

plane_off_vect_.resize(0);

(

= 0;

< planes; ++

)

* p = sv_layout.

(

);

plane_off_vect_.push_back(

(

));

enc_o(buf_ptr, sv_stat.max_serialize_mem);

(use_64bit || (plane_off_vect_.size() < 4))

enc_o.

(

);

(

= 0;

< planes; ++

)

* p = sv_layout.

(

);

(plane_off_vect_.size() == plane_digest_bv_.count());

min_v = plane_off_vect_[0];

max_v = plane_off_vect_[plane_off_vect_.size()-1];

enc_o.

(

);

(plane_off_vect_.size()-2),

buf_ptr += enc_o.

();

sv_layout.

(

(buf_ptr -

));

(sv.is_compressed())

enc.

((

)bo);

matr_s_ser = 1;

enc.

(matr_s_ser);

planes_code = planes | (1ull << 63);

enc.

(planes_code);

enc.

(sv.size_internal());

<

SV>

temp_block_ = alloc_.alloc_bit_block();

not_null_mask_bv_.set_allocator_pool(&pool_);

rsc_mask_bv_.set_allocator_pool(&pool_);

<

SV>

alloc_.free_bit_block(temp_block_);

<

SV>

this->is_final_ = is_final;

<

SV>

bv_ref_ptr_ = bv_ref_ptr;

clear_xor_compression();

<

SV>

op_deserial_.set_ref_vectors(0);

deserial_.set_ref_vectors(0);

<

SV>

op_deserial_.set_ref_vectors(bv_ref_ptr_);

deserial_.set_ref_vectors(bv_ref_ptr_);

op_deserial_.set_ref_vectors(&bv_ref_);

deserial_.set_ref_vectors(&bv_ref_);

<

SV>

*

,

idx_range_set_ =

;

deserialize_sv(sv,

, 0, clear_sv);

<

SV>

*

)

matr_s_ser = 0;

planes = load_header(dec, sv, matr_s_ser);

load_planes_off_table(

, dec, planes);

sv.get_bmatrix().allocate_rows(planes);

(

= 0;

< planes; ++

)

(!off_vect_[

])

<

SV>

*

,

sv.clear_all(

, 1);

idx_range_set_ =

; idx_range_from_ = from; idx_range_to_ = to;

matr_s_ser = 0;

planes = load_header(dec, sv, matr_s_ser);

sv.resize_internal(

(sv_size_));

load_planes_off_table(

, dec, planes);

setup_xor_compression();

sv.get_bmatrix().allocate_rows(planes);

planes = (unsigned)load_null_plane(sv,

(planes),

, 0);

range_valid = sv.resolve_range(from, to, &sv_left, &sv_right);

idx_range_set_ =

;

idx_range_set_ =

; idx_range_from_ = sv_left; idx_range_to_ = sv_right;

deserialize_planes(sv, planes,

, 0);

clear_xor_compression();

load_remap(sv, remap_buf_ptr_);

sv.sync(

,

);

idx_range_set_ =

;

<

SV>

*

,

sv.clear_all(

, 1);

matr_s_ser = 0;

planes = load_header(dec, sv, matr_s_ser);

sv.resize_internal(

(sv_size_));

load_planes_off_table(

, dec, planes);

setup_xor_compression();

sv.get_bmatrix().allocate_rows(planes);

planes = (unsigned)load_null_plane(sv,

(planes),

, mask_bv);

rsc_mask_bv_.clear(

);

not_null_mask_bv_.bit_and(*bv_null, *mask_bv, bvector_type::opt_compress);

rsc_compressor_.compress(rsc_mask_bv_, *bv_null, not_null_mask_bv_);

mask_bv = &rsc_mask_bv_;

rsc_mask_bv_.find_range(idx_range_from_, idx_range_to_);

deserialize_planes(sv, planes,

, mask_bv);

(sv.max_vector_size == 1)

sv.get_bmatrix().get_row(sv.sv_value_slices);

sv.mark_null_idx(sv.sv_value_slices);

clear_xor_compression();

load_remap(sv, remap_buf_ptr_);

sv.sync(

,

);

<

SV>

& dec, SV& sv,

& matr_s_ser)

h1 = dec.

();

h2 = dec.

();

(h1 ==

&& (h2 ==

|| h2 ==

|| h2 ==

));

sig2_ok = (h2 ==

|| h2 ==

|| h2 ==

);

(h1 !=

|| !sig2_ok)

raise_invalid_header();

planes = 0;

bv_bo = dec.

(); (void) bv_bo;

planes = dec.

();

matr_s_ser = dec.

();

planes_code = dec.

();

planes = (unsigned) planes_code;

(matr_s_ser == 2)

raise_invalid_64bit();

sv_planes = sv.stored_slices();

(!planes || planes > sv_planes)

raise_invalid_bitdepth();

sv_size_ = dec.

();

(planes_code & (1ull << 63))

digest_offset_ = dec.

();

<

SV>

*

,

(mask_bv && !idx_range_set_)

idx_range_set_ = mask_bv->find_range(idx_range_from_, idx_range_to_);

(

=

(planes-1);

>= 0; --

)

= off_vect_[unsigned(

)];

* bv_buf_ptr =

+

;

bv_ref_.add(bv,

(

));

bvector_type::mem_pool_guard mp_g_z(pool_, *bv);

deserial_.deserialize(*bv, bv_buf_ptr, temp_block_);

remap_buf_ptr_ = bv_buf_ptr + read_bytes;

bv->bit_and(*mask_bv, bvector_type::opt_compress);

deserial_.set_range(idx_range_from_, idx_range_to_);

deserial_.deserialize(*bv, bv_buf_ptr);

bv->bit_and(*mask_bv, bvector_type::opt_compress);

deserial_.deserialize(*bv, bv_buf_ptr, temp_block_);

remap_buf_ptr_ = bv_buf_ptr + read_bytes;

bv->keep_range(idx_range_from_, idx_range_to_);

deserial_.set_range(idx_range_from_, idx_range_to_);

deserial_.deserialize(*bv, bv_buf_ptr);

bv->keep_range(idx_range_from_, idx_range_to_);

deserial_.deserialize(*bv, bv_buf_ptr, temp_block_);

sv.set_ro_flag(

);

deserial_.unset_range();

<

SV>

*

,

(!sv.is_nullable())

= off_vect_[unsigned(

)];

* bv_buf_ptr =

+

;

* bv = sv.get_bmatrix().get_row(

(

));

bv_ref_.add(bv,

(

));

read_bytes = deserial_.deserialize(*bv, bv_buf_ptr, temp_block_);

remap_buf_ptr_ = bv_buf_ptr + read_bytes;

read_bytes = deserial_.deserialize(*bv, bv_buf_ptr, temp_block_);

remap_buf_ptr_ = bv_buf_ptr + read_bytes;

bv->keep_range(idx_range_from_, idx_range_to_);

deserial_.set_range(idx_range_from_, idx_range_to_);

deserial_.deserialize(*bv, bv_buf_ptr, temp_block_);

bv->keep_range(idx_range_from_, idx_range_to_);

deserial_.unset_range();

deserial_.deserialize(*bv, bv_buf_ptr, temp_block_);

bv->bit_and(*mask_bv, bvector_type::opt_compress);

<

SV>

off_vect_.resize(planes);

plane_digest_bv_.clear(

);

* buf_ptr =

+ digest_offset_;

deserial_.deserialize(plane_digest_bv_, buf_ptr, temp_block_);

buf_ptr += read_bytes;

dtype = dec_o.

();

(

= 0;

< planes; ++

)

(plane_digest_bv_.test(

))

osize = (unsigned)plane_digest_bv_.count();

off32_vect_.resize(osize);

min_v = dec_o.

();

max_v = dec_o.

();

off32_vect_[0] = min_v;

off32_vect_[osize-1] = max_v;

(

= 0;

< planes; ++

)

(plane_digest_bv_.test(

))

off_vect_[

] = off32_vect_[k];

(

= 0;

< planes; ++

)

<

SV>

* remap_buf_ptr)

rh = dec_m.

();

remap_size = (size_t) dec_m.

();

* remap_buf = sv.init_remap_buffer();

target_remap_size = sv.remap_size();

(!remap_size || !remap_buf || remap_size != target_remap_size)

raise_invalid_format();

dec_m.

(remap_buf, remap_size);

SV::remap_matrix_type* rmatr = sv.get_remap_matrix();

raise_missing_remap_matrix();

rows = (size_t) dec_m.

();

cols = dec_m.

();

raise_invalid_format();

rmatr->resize(rows, cols,

);

remap_rlen_vect_.resize(0);

(

= 0;

< rows; ++

)

rl = bi.

();

remap_rlen_vect_.push_back(rl);

(

= 0;

< rows; ++

)

= remap_rlen_vect_[

];

raise_invalid_format();

(

j = 0; j <

; ++j)

idx = dec_m.

();

v = dec_m.

();

raise_invalid_format();

end_tok = dec_m.

();

(end_tok !=

)

raise_invalid_format();

<

SV>

std::logic_error(

);

BM_THROW(BM_ERR_SERIALFORMAT);

<

SV>

std::logic_error(

);

BM_THROW(BM_ERR_SERIALFORMAT);

<

SV>

std::logic_error(

);

BM_THROW(BM_ERR_SERIALFORMAT);

<

SV>

std::logic_error(

);

BM_THROW(BM_ERR_SERIALFORMAT);

<

SV>

std::logic_error(

);

BM_THROW(BM_ERR_SERIALFORMAT);

Serialization / compression of bvector<>. Set theoretical operations on compressed BLOBs.

Sparse constainer sparse_vector<> for integer types using bit-transposition transform.

Byte based reader for un-aligned bit streaming.

unsigned gamma() noexcept

decode unsigned value using Elias Gamma coding

void bic_decode_u32_cm(bm::word_t *arr, unsigned sz, bm::word_t lo, bm::word_t hi) noexcept

Binary Interpolative array decode (32-bit)

Byte based writer for un-aligned bit streaming.

void gamma(unsigned value) noexcept

Elias Gamma encode the specified value.

void bic_encode_u32_cm(const bm::word_t *arr, unsigned sz, bm::word_t lo, bm::word_t hi) noexcept

Binary Interpolative encoding (array of 32-bit ints) cm - "center-minimal".

void flush() noexcept

Flush the incomplete 32-bit accumulator word.

List of reference bit-vectors with their true index associations.

Deseriaizer for compressed collections.

bvector_type::allocator_type allocator_type

CBC::buffer_type buffer_type

CBC::bvector_type bvector_type

CBC::statistics statistics_type

CBC::container_type container_type

CBC compressed_collection_type

int deserialize(CBC &buffer_coll, const unsigned char *buf, bm::word_t *temp_block=0)

CBC::address_resolver_type address_resolver_type

Seriaizer for compressed collections.

void serialize(const CBC &buffer_coll, buffer_type &buf, bm::word_t *temp_block=0)

Serialize compressed collection into memory buffer.

CBC compressed_collection_type

CBC::bvector_type bvector_type

CBC::statistics statistics_type

CBC::address_resolver_type address_resolver_type

CBC::buffer_type buffer_type

const unsigned char * get_pos() const noexcept

Return current buffer pointer.

unsigned char get_8() noexcept

Reads character from the decoding buffer.

void memcpy(unsigned char *dst, size_t count) noexcept

read bytes from the decode buffer

void seek(int delta) noexcept

change current position

Class for decoding data from memory buffer.

bm::id64_t get_64() noexcept

Reads 64-bit word from the decoding buffer.

bm::short_t get_16() noexcept

Reads 16-bit word from the decoding buffer.

bm::word_t get_32() noexcept

Reads 32-bit word from the decoding buffer.

void put_16(bm::short_t s) noexcept

Puts short word (16 bits) into the encoding buffer.

void put_32(bm::word_t w) noexcept

Puts 32 bits word into encoding buffer.

void put_64(bm::id64_t w) noexcept

Puts 64 bits word into encoding buffer.

size_t size() const noexcept

Returns size of the current encoding stream.

void put_8(unsigned char c) noexcept

Puts one character into the encoding buffer.

void set_pos(unsigned char *buf_pos) noexcept

Set current memory stream position.

void memcpy(const unsigned char *src, size_t count) noexcept

copy bytes into target buffer or just rewind if src is NULL

unsigned char * get_pos() const noexcept

Get current memory stream position.

void resize(size_type new_size)

vector resize

Bit-vector serialization class.

void set_bookmarks(bool enable, unsigned bm_interval=256) noexcept

Add skip-markers to serialization BLOB for faster range decode at the expense of some BLOB size incre...

void gap_length_serialization(bool value) noexcept

Set GAP length serialization (serializes GAP levels of the original vector)

size_type serialize(const BV &bv, unsigned char *buf, size_t buf_size)

Bitvector serialization into memory block.

sparse vector de-serializer

sparse_vector_deserializer()

void deserialize_planes(SV &sv, unsigned planes, const unsigned char *buf, const bvector_type *mask_bv=0)

deserialize bit-vector planes

void setup_xor_compression()

setup deserializers

allocator_pool_type pool_

bm::operation_deserializer< bvector_type > op_deserial_

void deserialize(SV &sv, const unsigned char *buf, bool clear_sv=true)

bm::serializer< bvector_type >::bv_ref_vector_type bv_ref_vector_type

void deserialize(SV &sv, const unsigned char *buf, const bvector_type &mask_bv)

bm::rank_compressor< bvector_type > rsc_compressor_

void deserialize_structure(SV &sv, const unsigned char *buf)

bm::id64_t digest_offset_

void deserialize_sv(SV &sv, const unsigned char *buf, const bvector_type *mask_bv, bool clear_sv)

static void raise_invalid_bitdepth()

throw error on incorrect deserialization

static void raise_invalid_header()

throw error on incorrect deserialization

SV::bvector_type bvector_type

size_type idx_range_from_

bvector_type not_null_mask_bv_

bvector_type::allocator_type::allocator_pool_type allocator_pool_type

bvector_type::allocator_type alloc_type

static void raise_invalid_format()

throw error on incorrect deserialization

unsigned load_header(bm::decoder &dec, SV &sv, unsigned char &matr_s_ser)

Deserialize header/version and other common info.

void deserialize(SV &sv, const unsigned char *buf, size_type from, size_type to)

bm::heap_vector< size_t, alloc_type, true > off_vect_

~sparse_vector_deserializer()

bm::heap_vector< unsigned, alloc_type, true > off32_vect_

bvector_type * bvector_type_ptr

static void raise_invalid_64bit()

throw error on incorrect deserialization

bvector_type plane_digest_bv_

static void raise_missing_remap_matrix()

throw error on incorrect deserialization

sparse_vector_deserializer(const sparse_vector_deserializer &)=delete

const bvector_type * bvector_type_const_ptr

void set_xor_ref(bv_ref_vector_type *bv_ref_ptr)

Set external XOR reference vectors (data frame referenece vectors)

bv_ref_vector_type * bv_ref_ptr_

external ref bit-vect

rlen_vector_type remap_rlen_vect_

void set_finalization(bm::finalization is_final)

Set deserialization finalization to force deserialized vectors into READONLY (or READWRITE) mode.

bvector_type rsc_mask_bv_

bm::deserializer< bvector_type, bm::decoder > deserial_

const unsigned char * remap_buf_ptr_

bv_ref_vector_type bv_ref_

reference vector

sparse_vector_deserializer & operator=(const sparse_vector_deserializer &)=delete

int load_null_plane(SV &sv, int planes, const unsigned char *buf, const bvector_type *mask_bv)

load NULL bit-plane (returns new planes count)

void deserialize_range(SV &sv, const unsigned char *buf, size_type from, size_type to, bool clear_sv=true)

void load_planes_off_table(const unsigned char *buf, bm::decoder &dec, unsigned planes)

load offset table

void clear_xor_compression()

unset XOR compression vectors

void load_remap(SV &sv, const unsigned char *remap_buf_ptr)

load string remap dict

bm::finalization is_final_

bm::heap_vector< unsigned, alloc_type, true > rlen_vector_type

SV::value_type value_type

Serialize sparse vector into a memory buffer(s) structure.

sparse_vector_serializer()

bvector_type plane_digest_bv_

bv.digest of bit-planes

u32_vector_type remap_rlen_vect_

void set_bookmarks(bool enable, unsigned bm_interval=256) noexcept

Add skip-markers for faster range deserialization.

void encode_remap_matrix(bm::encoder &enc, const SV &sv)

serialize the remap matrix used for SV encoding

sparse_vector_serializer & operator=(const sparse_vector_serializer &)=delete

serializer_type::buffer buffer_type

void set_sim_model(const xor_sim_model_type *sim_model) noexcept

Attach serizalizer to a pre-computed similarity model.

bm::serializer< bvector_type >::bv_ref_vector_type bv_ref_vector_type

bool is_xor_ref() const noexcept

Returns the XOR reference compression status (enabled/disabled)

const bv_ref_vector_type * bv_ref_ptr_

bvector_type * bvector_type_ptr

void build_xor_ref_vector(const SV &sv)

SV::value_type value_type

const bvector_type * bvector_type_const_ptr

void compute_sim_model(xor_sim_model_type &sim_model, const bv_ref_vector_type &ref_vect, const bm::xor_sim_params &params)

Calculate XOR similarity model for ref_vector refernece vector must be associated before.

alloc_type::allocator_pool_type allocator_pool_type

buffer_type plane_digest_buf_

serialization buf

void set_xor_ref(bool is_enabled) noexcept

Turn ON and OFF XOR compression of sparse vectors Enables XOR reference compression for the sparse ve...

u32_vector_type plane_off_vect_

bm::serializer< bvector_type > serializer_type

SV::remap_matrix_type remap_matrix_type

void serialize(const SV &sv, sparse_vector_serial_layout< SV > &sv_layout)

Serialize sparse vector into a memory buffer(s) structure.

xor_sim_model_type sim_model_

void enable_xor_compression() noexcept

Enable XOR compression on vector serialization.

const xor_sim_model_type * sim_model_ptr_

bm::heap_vector< unsigned, alloc_type, true > u32_vector_type

SV::bvector_type bvector_type

bm::serializer< bvector_type > bvs_

bvector_type::allocator_type alloc_type

bv_ref_vector_type bv_ref_

bm::serializer< bvector_type >::xor_sim_model_type xor_sim_model_type

void disable_xor_compression() noexcept

Disable XOR compression on serialization.

bm::serializer< bvector_type > & get_bv_serializer() noexcept

Get access to the underlying bit-vector serializer This access can be used to fine tune compression s...

sparse_vector_serializer(const sparse_vector_serializer &)=delete

finalization

copy strategy

@ READONLY

immutable (read-only object)

size_t deserialize(BV &bv, const unsigned char *buf, bm::word_t *temp_block=0, const bm::bv_ref_vector< BV > *ref_vect=0)

Bitvector deserialization from a memory BLOB.

void sparse_vector_serialize(const SV &sv, sparse_vector_serial_layout< SV > &sv_layout, bm::word_t *temp_block=0)

Serialize sparse vector into a memory buffer(s) structure.

int sparse_vector_deserialize(SV &sv, const unsigned char *buf, bm::word_t *temp_block=0)

Deserialize sparse vector.

SZ count_nz(const VT *arr, SZ arr_size) noexcept

Find count of non-zero elements in the array.

ByteOrder

Byte orders recognized by the library.

void _print_bv(TOut &tout, const BV &bv)

unsigned long long int id64_t

unsigned short gap_word_t

double value_type

The numeric datatype used by the parser.

const GenericPointer< typename T::ValueType > T2 value

double r(size_t dimension_, const Int4 *score_, const double *prob_, double theta_)

static SLJIT_INLINE sljit_ins st(sljit_gpr r, sljit_s32 d, sljit_gpr x, sljit_gpr b)

std::vector< bm::id64_t > ref_vect

#define row(bind, expected)

ad-hoc conditional expressions

static ByteOrder byte_order()

layout class for serialization buffer structure

SV::bvector_type bvector_type

sizet_vector_type plane_size_

serialized plane size

serializer< bvector_type >::buffer buffer_type

void resize(size_t ssize)

Set new serialized size.

void shrink(size_t ssize)

Set new serialized size (shrink)

const unsigned char * buf() const noexcept

Return serialization buffer pointer.

const unsigned char * data() const noexcept

Return serialization buffer pointer.

unsigned char * reserve(size_t capacity)

resize capacity

void resize_slices(unsigned new_slices_size)

Resize for the target number of plains / bit-slices.

bm::heap_vector< unsigned char *, allocator_type, true > ptr_vector_type

ptr_vector_type plane_ptrs_

pointers on serialized bit-planes

size_t size() const noexcept

return current serialized size

buffer_type buf_

serialization buffer

size_t capacity() const noexcept

return serialization buffer capacity

void operator=(const sparse_vector_serial_layout &)

void set_plane(unsigned i, unsigned char *ptr, size_t buf_size) noexcept

Set plane output pointer and size.

bvector_type::allocator_type allocator_type

bm::heap_vector< size_t, allocator_type, true > sizet_vector_type

sparse_vector_serial_layout(const sparse_vector_serial_layout &)

SV::value_type value_type

sparse_vector_serial_layout() noexcept

void freemem() noexcept

free memory

const unsigned char * get_plane(unsigned i) const noexcept

Get plane pointer.

~sparse_vector_serial_layout()

Parameters for XOR similarity search.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4