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

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

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

<

CharType,

BV,

STR_SIZE>

bvector_type::size_type

;

{

(*

) ==

(ref); }

value_type* v = this->

.

();

{

(*

) ==

(ref); }

{

(

== it.pos_) && (

== it.sv_); }

{

< it.pos_; }

{

<= it.pos_; }

{

> it.pos_; }

{

>= it.pos_; }

{

this->

(); }

{ this->

();

*

; }

value_type*

()

;

bi.buf_matrix_.rows(), bi.buf_matrix_.cols());

{ this->

(v);

*

; }

<

StrType>

this->

(v.c_str());

*

;

bvector_type::optmode

= bvector_type::opt_compress;

(

!= &str_sv)

(

!= &str_sv)

this->

(str_sv);

<

StrType>

<

StrType>

(idx >= this->

())

this->

= idx+1;

CharType ch =

[

];

ch = CharType(remap_value);

bv_null->set_bit_no_check(idx);

<

StrType>

<

StrType>

<

StrType>

(

= 0;

; ++

)

remap_value = remap_row[unsigned(ch)];

ch = CharType(remap_value);

<

USE_PREFIX_BUF = false>

<

CharMatrix>

zero_mem =

)

0,

(str_len-1), zero_mem);

<

CharMatrix>

substr_from,

zero_mem =

)

sv_decode_visitor_func

sv_decode_visitor_func(CharMatrix& cmatr)

= substr_i_;

}

(++j < bits_size);

base = bv_offset - sv_off_;

= substr_i_;

substr_i_= 0;

(max_sz < dec_size)

(rows < dec_size)

sv_decode_visitor_func func(cmatr);

(

= substr_from;

<= substr_to; ++

)

func.substr_i_ =

- substr_from;

(

k =

* 8; k < (

* 8) + 8; ++k, ++bi)

func.sv_off_ = idx_from;

(

= 0;

< dec_size; ++

)

<

CharMatrix>

(idx_from < this->

)

this->

(idx_from, idx_from + imp_size - 1);

<

CharMatrix>

<

CharMatrix,

BufSize = ins_buf_size>

set_not_null =

)

max_str_size = 0;

(

j = 0; j < imp_size; ++j)

CharMatrix::size_type

;

CharMatrix::size_type cols = cmatr.cols();

(

= 0;

< cols; ++

)

(unsigned)((

> max_str_size) ?

: max_str_size);

remap_value =

[

] = CharType(remap_value);

unsigned_value_type ch_slice[BufSize];

(

= 0;

< max_str_size; ++

)

ch_acc = 0;

(

j = 0; j < imp_size; j+=4)

ch_slice[j] =

; ch_slice[j+1] =

;

ch_slice[j+2] =

; ch_slice[j+3] =

;

(

j = 0; j < imp_size; ++j)

idx_to = idx_from + imp_size - 1;

bv_null->set_range(idx_from, idx_to);

(idx_to >= this->

())

this->

= idx_to+1;

<

BufSize = ins_buf_size>

( ;ch_acc; ch_acc &= ch_acc - 1)

n_bits = 0;

= 1u << bi;

(

j = 0; j < imp_size; j+=4)

= ((unsigned)ch_slice[j+0]) |

((unsigned)ch_slice[j+1] << 8) |

((unsigned)ch_slice[j+2] << 16) |

((unsigned)ch_slice[j+3] << 24);

(

>> (bi+14)) | (

>> (bi+21));

bit_idx =

[n_bits++] = base_idx + bit_idx;

(

j = 0; j < imp_size; ++j)

ch = unsigned(ch_slice[j]);

[n_bits++] = idx_from + j;

bv->import_sorted(&

[0], n_bits,

);

*idx_from = from; *idx_to = to;

;

(back_insert_iterator& iit);

<

CharType,

BV,

STR_SIZE>

static_assert(STR_SIZE > 1,

);

<

CharType,

BV,

STR_SIZE>

remap_flags_(str_sv.remap_flags_),

remap_matrix1_(str_sv.remap_matrix1_),

remap_matrix2_(str_sv.remap_matrix2_)

static_assert(STR_SIZE > 1,

);

<

CharType,

BV,

STR_SIZE>

remap_flags_(str_sv.remap_flags_),

remap_matrix1_(str_sv.remap_matrix1_),

remap_matrix2_(str_sv.remap_matrix2_)

static_assert(STR_SIZE > 1,

);

<

CharType,

BV,

STR_SIZE>

remap_matrix1_.swap(str_sv.remap_matrix1_);

remap_matrix2_.swap(str_sv.remap_matrix2_);

<

CharType,

BV,

STR_SIZE>

(idx >= this->

())

this->size_ = idx+1;

set_value(idx,

);

<

CharType,

BV,

STR_SIZE>

(idx >= this->

())

this->size_ = idx+1;

set_value(idx,

);

insert_value(idx,

);

<

CharType,

BV,

STR_SIZE>

this->swap_elements(idx1, idx2);

<

CharType,

BV,

STR_SIZE>

(idx >= this->size_)

this->erase_column(idx,

);

<

CharType,

BV,

STR_SIZE>

(idx >= this->size_)

this->size_ = idx + 1;

this->bmatr_.clear_column(idx, 0);

<

CharType,

BV,

STR_SIZE>

this->size_ +=

;

<

CharType,

BV,

STR_SIZE>

set_value_no_null(idx,

);

bv_null->set_bit_no_check(idx);

<

CharType,

BV,

STR_SIZE>

(

= 0;

; ++

)

CharType ch =

[

];

this->clear_value_planes_from(

*8, idx);

= remap_matrix2_.rows();

remap_matrix1_.resize(

+ 1, remap_matrix1_.cols(),

);

remap_matrix2_.resize(

+ 1, remap_matrix2_.cols(),

);

remap_value = remap_matrix2_.get(

,

(ch));

this->clear_value_planes_from(

*8, idx);

ch = CharType(remap_value);

this->bmatr_.set_octet(idx,

, (

)ch);

<

CharType,

BV,

STR_SIZE>

insert_value_no_null(idx,

);

this->insert_null(idx,

);

<

CharType,

BV,

STR_SIZE>

(

= 0;

; ++

)

CharType ch =

[

];

this->insert_clear_value_planes_from(

*8, idx);

remap_value = remap_matrix2_.get(

,

(ch));

this->insert_clear_value_planes_from(

*8, idx);

ch = CharType(remap_value);

this->bmatr_.insert_octet(idx,

, (

)ch);

<

CharType,

BV,

STR_SIZE>

(;

; ++

)

CharType ch = CharType(this->bmatr_.get_octet(idx,

));

remap_matrix1_.remap(

,

);

<

CharType,

BV,

STR_SIZE>

bvector_type::optmode opt_mode,

bvector_type::statistics stbv;

parent_type::optimize(temp_block, opt_mode, &stbv);

<

CharType,

BV,

STR_SIZE>

bvector_type::statistics stbv;

parent_type::calc_stat(&stbv);

->bit_blocks += stbv.bit_blocks;

->gap_blocks += stbv.gap_blocks;

->ptr_sub_blocks += stbv.ptr_sub_blocks;

->bv_count += stbv.bv_count;

->max_serialize_mem += stbv.max_serialize_mem + 8;

->memory_used += stbv.memory_used;

->gap_cap_overhead += stbv.gap_cap_overhead;

remap_mem_usage =

(remap_flags_);

remap_mem_usage += remap_matrix1_.get_buffer().mem_usage();

remap_mem_usage += remap_matrix2_.get_buffer().mem_usage();

->memory_used += remap_mem_usage;

->max_serialize_mem += (remap_mem_usage * 2);

<

CharType,

BV,

STR_SIZE>

(

= 0;

; ++

)

CharType octet2 = str2[

];

CharType octet1 = str1[

];

res = (octet1 > octet2) - (octet1 < octet2);

<

CharType,

BV,

STR_SIZE>

CharType octet2, octet1;

(;

< min_len-3;

+=4)

::memcpy(&i2, &str2[

],

(i2));

::memcpy(&i1, &str1[

],

(i1));

res = (octet1 > octet2) - (octet1 < octet2);

octet2 = str2[

+1];

octet1 = str1[

+1];

res = (octet1 > octet2) - (octet1 < octet2);

octet2 = str2[

+2];

octet1 = str1[

+2];

res = (octet1 > octet2) - (octet1 < octet2);

octet2 = str2[

+3];

octet1 = str1[

+3];

res = (octet1 > octet2) - (octet1 < octet2);

(;

< min_len; ++

)

res = (octet1 > octet2) - (octet1 < octet2);

(;

; ++

)

res = (octet1 > octet2) - (octet1 < octet2);

<

CharType,

BV,

STR_SIZE>

(

= 0;

; ++

)

CharType octet2 =

[

];

CharType octet1 = (CharType)this->bmatr_.get_octet(idx,

);

* remap_row = remap_matrix1_.row(

);

CharType remap_value1 = (CharType)remap_row[

(octet1)];

res = (remap_value1 > octet2) - (remap_value1 < octet2);

<

CharType,

BV,

STR_SIZE>

(

= 0;

; ++

)

CharType octet2 =

[

];

CharType octet1 = (CharType)this->bmatr_.get_octet(idx,

);

res = (octet1 > octet2) - (octet1 < octet2);

<

CharType,

BV,

STR_SIZE>

res = remap_flags_ ? compare_remap(idx,

)

: compare_nomap(idx,

);

<

CharType,

BV,

STR_SIZE>

(

= 0;

; ++

)

CharType octet2 = (CharType)this->bmatr_.get_octet(idx2,

);

CharType octet1 = (CharType)this->bmatr_.get_octet(idx1,

);

* remap_row = remap_matrix1_.row(

);

remap_value1 = remap_row[unsigned(octet1)];

remap_value2 = remap_row[unsigned(octet2)];

res = (remap_value1 > remap_value2) - (remap_value1 < remap_value2);

(

= 0;

; ++

)

CharType octet2 = (CharType)this->bmatr_.get_octet(idx2,

);

CharType octet1 = (CharType)this->bmatr_.get_octet(idx1,

);

res = (octet1 > octet2) - (octet1 < octet2);

<

CharType,

BV,

STR_SIZE>

<

USE_PREFIX_BUF>

(!(prefix_buf && !USE_PREFIX_BUF));

CharType

= CharType(this->bmatr_.get_octet(idx1,

));

CharType

= CharType(this->bmatr_.get_octet(idx2,

));

constexpr(USE_PREFIX_BUF)

*prefix_buf++ =

;

(++

;

; ++

)

= CharType(this->bmatr_.get_octet(idx1,

));

= CharType(this->bmatr_.get_octet(idx2,

));

constexpr(USE_PREFIX_BUF)

*prefix_buf++ =

;

<

CharType,

BV,

STR_SIZE>

<

CharType,

BV,

STR_SIZE>

this->bmatr_.octet_size();

<

CharType,

BV,

STR_SIZE>

max_str_len = effective_max_str();

octet_matrix.

(max_str_len, 256,

);

(; it.

(); ++it)

(

= 0;

; ++

)

ch_idx = (

char)ch;

<

CharType,

BV,

STR_SIZE>

max_str_len = effective_max_str();

octet_remap_matrix1.

(max_str_len, 256,

);

octet_remap_matrix2.

(max_str_len, 256,

);

(

= 0;

< octet_occupancy_matrix.

(); ++

)

octet_occupancy_matrix.

(

);

* remap_row1 = octet_remap_matrix1.

(

);

* remap_row2 = octet_remap_matrix2.

(

);

octet_occupancy_matrix.

();

(

remap_code = 1;

; ++remap_code)

ch = (

char)char_idx;

remap_row1[remap_code] = ch;

remap_row2[ch] = (

char)remap_code;

frq_row[char_idx] = 0;

<

CharType,

BV,

STR_SIZE>

rows = remap_matrix1_.rows();

remap_matrix2_.resize(rows, remap_matrix1_.cols(),

);

remap_matrix2_.set_zero();

(

= 0;

< remap_matrix1_.rows(); ++

)

* remap_row1 = remap_matrix1_.row(

);

* remap_row2 = remap_matrix2_.row(

);

(

j = 1; j < remap_matrix1_.cols(); ++j)

ch_code = remap_row1[j];

remap_row2[ch_code] = (

char)j;

<

CharType,

BV,

STR_SIZE>

(!octet_remap_matrix2.rows())

* remap_row = octet_remap_matrix2.row(0);

(

= 0;

< buf_size; ++

, remap_row += 256)

CharType ch =

[

];

remap_value = remap_row[unsigned(ch)];

sv_str[

] = CharType(remap_value);

<

CharType,

BV,

STR_SIZE>

(in_len <= buf_size); (void) buf_size;

* remap_row = octet_remap_matrix2.row(0);

(

= 0;

< in_len; ++

, remap_row += 256)

CharType ch =

[

];

remap_value = remap_row[unsigned(ch)];

sv_str[

] = CharType(remap_value);

sv_str[in_len] = str_cp[in_len] = 0;

<

CharType,

BV,

MAX_STR_SIZE>

* remap_row = octet_remap_matrix1.row(0);

(

= 0;

< buf_size; ++

, remap_row += 256)

CharType ch = sv_str[

];

remap_value = remap_row[unsigned(ch)];

[

] = CharType(remap_value);

<

CharType,

BV,

MAX_STR_SIZE>

sv_tmp(this->get_null_support());

sv_tmp.

(*

);

<

CharType,

BV,

MAX_STR_SIZE>

sv_tmp(this->get_null_support());

sv_tmp.

(*

);

<

CharType,

BV,

STR_SIZE>

remap_from_impl(str_sv, omatrix,

);

<

CharType,

BV,

STR_SIZE>

buffer_size = ins_buf_size;

bvector_type::allocator_pool_type pool;

pool.set_block_limit(

+ 10);

this->clear_all(

);

(str_sv.

())

omatrix = &occ_matrix;

buffer_matrix_type cmatr(buffer_size, str_len);

dsize = str_sv.

(cmatr,

, buffer_size,

);

(move_data && (dsize == ins_buf_size))

this->

(cmatr,

, dsize);

*bv_null = *bv_null_arg;

<

CharType,

BV,

STR_SIZE>

recalc_remap_matrix2();

<

CharType,

BV,

STR_SIZE>

(remap_flags_ != sv.remap_flags_)

= remap_matrix1_.equal_overlap(sv.remap_matrix1_);

= remap_matrix2_.equal_overlap(sv.remap_matrix2_);

parent_type::equal(sv, null_able);

<

CharType,

BV,

STR_SIZE>

this->clear_all(

);

this->copy_range_slices(sv, left, right, slice_null);

<

CharType,

BV,

STR_SIZE>

(this->size_ < arg_size)

this->merge_matr(str_sv.

);

bv_null->set_range(0, arg_size-1);

<

CharType,

BV,

STR_SIZE>

this->keep_range_no_check(left, right, slice_null);

<

CharType,

BV,

STR_SIZE>

it_type(

);

<

CharType,

BV,

STR_SIZE>

parent_type::clear_all(free_mem);

(remap_flags_ && (remap == 0))

remap_matrix1_.free();

remap_matrix2_.free();

<

CharType,

BV,

STR_SIZE>

* err_msg)

std::range_error(err_msg);

<

CharType,

BV,

STR_SIZE>

* err_msg)

err_msg =

;

std::domain_error(err_msg);

<

CharType,

BV,

STR_SIZE>

: sv_(0), substr_from_(0), substr_to_(STR_SIZE),

<

CharType,

BV,

STR_SIZE>

substr_from_(it.substr_from_), substr_to_(it.substr_to_),

pos_(it.pos_), pos_in_buf_(~

(0))

<

CharType,

BV,

STR_SIZE>

substr_to_ = (unsigned) sv_->effective_max_str();

buf_matrix_.resize(n_rows, substr_to_+1);

<

CharType,

BV,

STR_SIZE>

substr_to_ = (unsigned) sv_->effective_max_str();

buf_matrix_.resize(n_rows, substr_to_+1);

<

CharType,

BV,

STR_SIZE>

= sv_->effective_max_str();

substr_from_ = from;

substr_to_ = from +

;

substr_to_ = substr_from_ + (

- 1);

buf_matrix_.resize(n_rows,

+1,

);

<

CharType,

BV,

STR_SIZE>

(!buf_matrix_.is_init())

d = sv_->decode_substr(buf_matrix_, pos_, n_rows,

substr_from_, substr_to_);

buf_matrix_.row(pos_in_buf_);

<

CharType,

BV,

STR_SIZE>

(!buf_matrix_.is_init())

d = sv_->decode_substr(buf_matrix_, pos_, n_rows,

substr_from_, substr_to_);

<

CharType,

BV,

STR_SIZE>

pos_ = (!sv_ || pos >= sv_->size()) ?

: pos;

<

CharType,

BV,

STR_SIZE>

(pos_ >= sv_->size())

(pos_in_buf_ >= n_rows)

<

CharType,

BV,

STR_SIZE>

: sv_(0), bv_null_(0), pos_in_buf_(~

(0))

<

CharType,

BV,

STR_SIZE>

bv_null_ = sv_->get_null_bvect();

esize = (unsigned) sv_->effective_max_str();

(esize < STR_SIZE)

buf_matrix_.init_resize(n_buf_size, esize);

bv_null_ = 0; prev_nb_ = 0;

<

CharType,

BV,

STR_SIZE>

: sv_(bi.sv_), bv_null_(bi.bv_null_), buf_matrix_(bi.buf_matrix_.rows(), bi.buf_matrix_.cols()),

pos_in_buf_(~

(0)), prev_nb_(bi.prev_nb_), opt_mode_(bi.opt_mode_),

<

CharType,

BV,

STR_SIZE>

<

CharType,

BV,

STR_SIZE>

(pos_in_buf_ == ~

(0) || !sv_);

<

CharType,

BV,

STR_SIZE>

sv_->remap(*

);

<

CharType,

BV,

STR_SIZE>

(this->

())

size_type imp_idx = sv_->size();

sv_->import_no_check(buf_matrix_, imp_idx, pos_in_buf_+1,

);

sv_->optimize_block(prev_nb_, opt_mode_);

<

CharType,

BV,

STR_SIZE>

bv_null_->set_bit_no_check(sz + buf_idx + 1);

<

CharType,

BV,

STR_SIZE>

this->add_value(

);

<

CharType,

BV,

STR_SIZE>

this->add_value(

);

<

CharType,

BV,

STR_SIZE>

slen = ::strlen(v);

orows = omatrix_.rows();

omatrix_.resize(slen, 256,

);

omatrix_.set_zero();

omatrix_.resize(slen, 256,

);

(; orows < omatrix_.rows(); ++orows)

::memset(

, 0, 256 *

(

[0]));

(

= 0;

< slen; ++

)

ch_idx = (

char)ch;

<

CharType,

BV,

STR_SIZE>

(pos_in_buf_ >= buf_matrix_.rows()-1)

(pos_in_buf_ == ~

(0) && (!buf_matrix_.is_init()))

pos_in_buf_ = 0; buf_matrix_.set_zero();

(

= 0;

< cols; ++

)

(cols =

;

; ++cols)

buf_matrix_.

(buf_matrix_.rows(), cols + 1);

= buf_matrix_.row(pos_in_buf_);

cols = buf_matrix_.cols();

(;

< cols; ++

)

<

CharType,

BV,

STR_SIZE>

found = bv_null->find_reverse(this->

);

this->

+= found;

ncbi::TMaskedQueryRegions mask

Algorithms for bvector<> (main include)

basic bit-matrix class and utilities

Constants, lookup tables and typedefs.

#define BM_ASSERT_THROW(x, xerrcode)

Utilities for bit transposition (internal) (experimental!)

void assign_if_not_set(POOL &pool, PCLASS &obj) BMNOEXCEPT

check if vector has no assigned allocator and set one

Base class for bit-transposed(bit-sliced) sparse vector construction.

void freeze_matr()

Turn on RO mode.

void resize(size_type new_size, bool set_null)

const bmatrix_type & get_bmatrix() const noexcept

const value_type & const_reference

void copy_from(const base_sparse_vector< CharType, BV, MAX_SIZE > &bsv)

void clear_range(size_type left, size_type right, bool set_null)

bvector_type_ptr get_create_slice(unsigned i)

get access to bit-plain, function checks and creates a plane

bool is_nullable() const noexcept

check if container supports NULL(unassigned) values

bool is_null(size_type idx) const noexcept

test if specified element is NULL

bmatrix_type bmatr_

bit-transposed matrix

void swap(base_sparse_vector< CharType, BV, MAX_SIZE > &bsv) noexcept

size_type size_

array size

void bit_and_rows(const bvector_type &bv)

Set AND (intersect) operation on all existing bit-slices.

std::make_unsigned< value_type >::type unsigned_value_type

void bit_sub_rows(const bvector_type &bv, bool use_null)

Set SUB (MINUS) operation on all existing bit-slices.

const bvector_type * get_null_bvector() const noexcept

Get bit-vector of assigned values or NULL (if not constructed that way)

bvector_type * get_null_bvect() noexcept

void clear_value_planes_from(unsigned plane_idx, size_type idx)

Basic dense bit-matrix class.

bool is_ro() const noexcept

return true if matrix is in read-only mode

unsigned char get_octet(size_type pos, size_type octet_idx) const noexcept

size_type rows_not_null() const noexcept

void allocate_rows(size_type rsize)

allocate matrix rows of bit-vectors (new rows are NULLs)

bvector_type_const_ptr get_row(size_type i) const noexcept

void set_octet(size_type pos, size_type octet_idx, unsigned char octet)

size_type rows() const noexcept

unsigned char * data() noexcept

Get write access to buffer memory.

size_t size() const noexcept

Get buffer size.

const unsigned char * buf() const noexcept

Get read access to buffer memory.

const value_type * row(size_type row_idx) const noexcept

buffer_type & get_buffer() noexcept

Get low-level buffer access.

void swap(dynamic_heap_matrix &other) noexcept

value_type get(size_type row_idx, size_type col_idx) noexcept

size_type rows() const noexcept

size_type cols() const noexcept

void remapz(VECT_TYPE *vect) const noexcept

void set_zero() noexcept

memset all buffer to all zeroes

void init_resize(size_type rows_in, size_type cols_in)

void resize(size_type rows_in, size_type cols_in, bool copy_content=true)

void init(bool set_z=false)

Post construction allocation, initialization.

value_type * data() const noexcept

void resize(size_type new_size)

vector resize

sparse vector de-serializer

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

Back insert iterator implements buffered insert, faster than generic access assignment.

bvector_type * bv_null_

!< pointer on the parent vector

back_insert_iterator & operator*()

noop

void add_remap_stat(const value_type *v)

account new value as remap statistics

void add(const value_type *v)

add value to the container

size_type pos_in_buf_

!< value buffer

octet_freq_matrix_type omatrix_

octet frequency matrix

void add_value(const value_type *v)

add value to the buffer without changing the NULL vector

back_insert_iterator & operator++()

noop

void flush()

flush the accumulated buffer.

unsigned remap_flags_

target remapping

void set_remap(bool flag) noexcept

Method to configure back inserter to collect statistics on optimal character codes.

buffer_matrix_type buf_matrix_

!< not NULL vector pointer

back_insert_iterator & operator++(int)

noop

str_sparse_vector_type * str_sparse_vector_type_ptr

bvector_type::block_idx_type block_idx_type

str_sparse_vector_type::value_type value_type

str_sparse_vector_type::size_type size_type

void add_null()

add NULL (no-value) to the container

back_insert_iterator() noexcept

bvector_type::allocator_type allocator_type

back_insert_iterator & operator=(const value_type *v)

push value to the vector

bvector_type::optmode opt_mode_

!< previous block added

bm::dynamic_heap_matrix< CharType, allocator_type > buffer_matrix_type

block_idx_type prev_nb_

!< buffer position

str_sparse_vector< CharType, BV, STR_SIZE > str_sparse_vector_type

std::output_iterator_tag iterator_category

unsigned get_remap() const noexcept

Get curent remap state flags.

void set_optimize(typename bvector_type::optmode opt_mode) noexcept

Set optimization on load option (deafult: false)

const octet_freq_matrix_type & get_octet_matrix() const noexcept

Get octet frequence matrix.

void add_null(size_type count)

add a series of consequitve NULLs (no-value) to the container

str_sparse_vector_type * sv_

allocator_type::allocator_pool_type allocator_pool_type

bool empty() const noexcept

return true if insertion buffer is empty

back_insert_iterator & operator=(const StrType &v)

push value to the vector

str_sparse_vector_type::bvector_type bvector_type

Const iterator to do quick traverse of the sparse vector.

str_sparse_vector_type * str_sparse_vector_type_ptr

std::input_iterator_tag iterator_category

dynamic_heap_matrix< CharType, allocator_type > buffer_matrix_type

bool operator==(const const_iterator &it) const noexcept

bool operator!=(const const_iterator &it) const noexcept

const value_type * operator*() const

Get current position (value)

bool operator<=(const const_iterator &it) const noexcept

const value_type * value() const

Get zero terminated string value at the current position.

allocator_type::allocator_pool_type allocator_pool_type

size_type pos_in_buf_

!< decode value buffer

const_iterator() noexcept

Construct iterator (not attached to any particular vector)

bvector_type::allocator_type allocator_type

void invalidate() noexcept

Invalidate current iterator.

buffer_matrix_type buf_matrix_

!< Position

size_type pos() const noexcept

Current position (index) in the vector.

unsigned substr_from_

!< ptr to parent

unsigned substr_to_

!< substring from

size_type pos_

!< substring to

bool is_null() const noexcept

Get NULL status.

str_sparse_vector< CharType, BV, STR_SIZE > str_sparse_vector_type

void go_to(size_type pos) noexcept

re-position to a specified position

str_sparse_vector_type::bvector_type bvector_type

void set_substr(unsigned from, unsigned len=0) noexcept

setup iterator to retrieve a sub-string of a string

bool operator>=(const const_iterator &it) const noexcept

long long difference_type

const str_sparse_vector_type * sv_

bool operator<(const const_iterator &it) const noexcept

str_sparse_vector_type::size_type size_type

str_sparse_vector_type::value_type value_type

string_view_type get_string_view() const

Get current string as string_view.

void advance() noexcept

advance iterator forward by one

bool valid() const noexcept

Returns true if iterator is at a valid position.

bool operator>(const const_iterator &it) const noexcept

const_iterator & operator++(int) noexcept

Advance to the next available value.

std::basic_string_view< CharType > string_view_type

const_iterator & operator++() noexcept

Advance to the next available value.

Reference class to access elements via common [] operator.

const_reference(const str_sparse_vector< CharType, BV, STR_SIZE > &str_sv, size_type idx)

const str_sparse_vector< CharType, BV, STR_SIZE > & str_sv_

const value_type * get() const noexcept

bool operator==(const const_reference &ref) const noexcept

bool is_null() const noexcept

bm::heap_vector< CharType, typename bvector_type::allocator_type, true > bufffer_type

Reference class to access elements via common [] operator.

str_sparse_vector< CharType, BV, STR_SIZE > & str_sv_

reference(str_sparse_vector< CharType, BV, STR_SIZE > &str_sv, size_type idx)

bool is_null() const noexcept

reference & operator=(const value_type *str)

const value_type * get() const noexcept

bool operator==(const reference &ref) const noexcept

reference & operator=(const reference &ref)

succinct sparse vector for strings with compression using bit-slicing ( transposition) method

void insert(size_type idx, const value_type *str)

insert the specified element

static bool remap_n_tosv_2way(value_type *sv_str, value_type *str_cp, size_type buf_size, const value_type *str, size_t in_len, const slice_octet_matrix_type &octet_remap_matrix2) noexcept

void calc_octet_stat(octet_freq_matrix_type &octet_matrix) const

void clear() noexcept

resize to zero, free memory, reset remapping

void optimize(bm::word_t *temp_block=0, typename bvector_type::optmode opt_mode=bvector_type::opt_compress, typename str_sparse_vector< CharType, BV, STR_SIZE >::statistics *stat=0)

run memory optimization for all vector planes

size_type get(size_type idx, value_type *str, size_type buf_size) const noexcept

get specified element

void set_value(size_type idx, const value_type *str)

set value without checking boundaries

void resize(size_type sz)

resize vector

bool empty() const

return true if vector is empty

static bool remap_tosv(value_type *sv_str, size_type buf_size, const value_type *str, const slice_octet_matrix_type &octet_remap_matrix2) noexcept

void recalc_remap_matrix2()

const_iterator get_const_iterator(size_type idx) const noexcept

Get const_itertor re-positioned to specific element.

int compare_remap(size_type idx, const value_type *str) const noexcept

Variant of compare for remapped vectors.

static constexpr bool is_str() noexcept

bool is_ro() const noexcept

Returns true if vector is read-only.

static size_type max_str()

get maximum string length capacity

unsigned char * init_remap_buffer()

void set_null(size_type idx)

set NULL status for the specified element Vector is resized automatically

void set_null(const bvector_type &bv_idx)

Set NULL all elements set as 1 in the argument vector.

void remap_from_impl(const str_sparse_vector &str_sv, octet_freq_matrix_type *omatrix, bool move_data)

Remap from implementation, please note that move_data flag can violate cosnt-ness.

slice_octet_matrix_type remap_matrix1_

octet remap table 1

const bvector_type * bvector_type_const_ptr

str_sparse_vector< CharType, BV, STR_SIZE > & merge(str_sparse_vector< CharType, BV, STR_SIZE > &str_sv)

merge with another sparse vector using OR operation Merge is different from join(),...

void assign(size_type idx, const StrType &str)

set specified element with bounds checking and automatic resize

bool remap_tosv(value_type *sv_str, size_type buf_size, const value_type *str) const noexcept

str_sparse_vector(bm::null_support null_able=bm::no_null, allocation_policy_type ap=allocation_policy_type(), size_type bv_max_size=bm::id_max, const allocator_type &alloc=allocator_type())

Sparse vector constructor.

bm::dynamic_heap_matrix< unsigned char, allocator_type > slice_octet_matrix_type

Matrix of character remappings.

void remap_from(const str_sparse_vector &str_sv, octet_freq_matrix_type *omatrix=0)

Build remapping profile and load content from another sparse vector Remapped vector likely saves memo...

void sync_size() noexcept

recalculate size to exclude tail NULL elements After this call size() will return the true size of th...

size_type size() const

return size of the vector

void build_octet_remap(slice_octet_matrix_type &octet_remap_matrix1, slice_octet_matrix_type &octet_remap_matrix2, octet_freq_matrix_type &octet_occupancy_matrix) const

void keep(const bvector_type &bv_idx)

Set NULL all elements NOT set as 1 in the argument vector.

void import_char_slice(const unsigned_value_type *ch_slice, unsigned ch_acc, size_type char_slice_idx, size_type idx_from, size_type imp_size)

bool is_remap() const noexcept

Get character remapping status (true | false)

void sync(bool force, bool sync_size)

syncronize internal structures

bm::basic_bmatrix< BV > bmatrix_type

unsigned common_prefix_length(size_type idx1, size_type idx2, value_type *prefix_buf=0) const noexcept

Find size of common prefix between two vector elements in octets.

void insert_value(size_type idx, const value_type *str)

insert value without checking boundaries

CharType * value_type_prt

void push_back(const StrType &str)

push back a string

void import_no_check(CharMatrix &cmatr, size_type idx_from, size_type imp_size, bool set_not_null=true)

bvector_type::allocation_policy allocation_policy_type

void clear(const bvector_type &bv_idx)

Set vector elements spcified by argument bit-vector to empty Note that set to empty elements are NOT ...

void freeze()

Turn sparse vector into immutable mode Read-only (immutable) vector uses less memory and allows faste...

BV::allocator_type allocator_type

void insert_value_no_null(size_type idx, const value_type *str)

insert value without checking boundaries or support of NULL

bm::dynamic_heap_matrix< size_t, allocator_type > octet_freq_matrix_type

Matrix of character frequencies (for optimal code remap)

slice_octet_matrix_type remap_matrix2_

octet remap table 2

bool resolve_range(size_type from, size_type to, size_type *idx_from, size_type *idx_to) const

parent_type::unsigned_value_type unsigned_value_type

void import_back(CharMatrix &cmatr, size_type imp_size)

Bulk push-back import of strings from a C-style matrix of chars.

static int compare_str(const value_type *str1, const value_type *str2) noexcept

size_type decode(CharMatrix &cmatr, size_type idx_from, size_type dec_size, bool zero_mem=true) const

Bulk export strings to a C-style matrix of chars.

void resize_internal(size_type sz)

bool try_get(size_type idx, StrType &str) const

get specified string element if NOT NULL Template method expects an STL-compatible type basic_string<...

bool remap_n_tosv_2way(value_type *sv_str, value_type *str_cp, size_type buf_size, const value_type *str, size_t in_len) const noexcept

void erase(size_type idx)

erase the specified element

size_type effective_size() const noexcept

size of sparse vector (may be different for RSC)

const unsigned char * get_remap_buffer() const

bvector_type * bvector_type_ptr

void insert(size_type idx, const StrType &str)

insert STL string

static void throw_bad_value(const char *err_msg)

throw domain error

void get(size_type idx, StrType &str) const

get specified string element Template method expects an STL-compatible type basic_string<>

reference operator[](size_type idx)

Operator to get write access to an element.

void push_back(const value_type *str)

push back a string (zero terminated)

str_sparse_vector< CharType, BV, STR_SIZE > & operator=(const str_sparse_vector< CharType, BV, STR_SIZE > &str_sv)

static constexpr bool is_compressed() noexcept

various type traits

size_type decode_substr(CharMatrix &cmatr, size_type idx_from, size_type dec_size, unsigned substr_from, unsigned substr_to, bool zero_mem=true) const

Bulk export strings to a C-style matrix of chars.

const remap_matrix_type * get_remap_matrix() const

base_sparse_vector< CharType, BV, STR_SIZE > parent_type

void push_back_null()

push back NULL value

size_type effective_vector_max() const

get effective string length used in vector

static bool remap_fromsv(value_type *str, size_type buf_size, const value_type *sv_str, const slice_octet_matrix_type &octet_remap_matrix1) noexcept

int compare_nomap(size_type idx, const value_type *str) const noexcept

Variant of compare for non-mapped vectors.

void remap()

Build remapping profile and re-load content to save memory.

back_insert_iterator get_back_inserter()

Provide back insert iterator Back insert iterator implements buffered insertion, which is faster,...

const_iterator begin() const noexcept

Provide const iterator access to container content.

void calc_stat(struct str_sparse_vector< CharType, BV, STR_SIZE >::statistics *st) const noexcept

Calculates memory statistics.

slice_octet_matrix_type remap_matrix_type

bvector_type::enumerator bvector_enumerator_type

void set_value_no_null(size_type idx, const value_type *str)

set value without checking boundaries or support of NULL

void copy_range(const str_sparse_vector< CharType, BV, STR_SIZE > &sv, size_type left, size_type right, bm::null_support slice_null=bm::use_null)

copy range of values from another sparse vector

size_t remap_size() const

bool equal(const str_sparse_vector< CharType, BV, STR_SIZE > &sv, bm::null_support null_able=bm::use_null) const noexcept

check if another sparse vector has the same content and size

static void throw_range_error(const char *err_msg)

throw range error

str_sparse_vector< CharType, BV, STR_SIZE > & clear_range(size_type left, size_type right, bool set_null=false)

clear range (assign bit 0 for all planes)

void swap(size_type idx1, size_type idx2)

swap two vector elements between each other

size_type size_internal() const

void set(size_type idx, const value_type *str)

set specified element with bounds checking and automatic resize

const_iterator end() const noexcept

Provide const iterator access to the end.

unsigned remap_flags_

remapping status

size_type effective_max_str() const noexcept

get effective string length used in vector Calculate and returns efficiency, how close are we to the ...

static bool find_rank(size_type rank, size_type &pos) noexcept

find position of compressed element by its rank

remap_matrix_type * get_remap_matrix()

int compare(size_type idx, const value_type *str) const noexcept

Compare vector element with argument lexicographically.

const const_reference operator[](size_type idx) const

Operator to get read access to an element.

void keep_range(size_type left, size_type right, bm::null_support slice_null=bm::use_null)

Keep only specified interval in the sparse vector, clear all other elements.

str_sparse_vector(str_sparse_vector< CharType, BV, STR_SIZE > &&str_sv) noexcept

allocator_type::allocator_pool_type allocator_pool_type

bvector_type::size_type size_type

void clear_all(bool free_mem, unsigned remap=0) noexcept

resize to zero, free memory

static const char * str(char *buf, int n)

void swap(NCBI_NS_NCBI::pair_base_member< T1, T2 > &pair1, NCBI_NS_NCBI::pair_base_member< T1, T2 > &pair2)

bm::id_t word_bitcount(bm::id_t w) noexcept

unsigned bit_list(T w, B *bits) noexcept

Unpacks word into list of ON bit indexes.

null_support

NULL-able value support.

@ use_null

support "non-assigned" or "NULL" logic

@ no_null

do not support NULL values

void xor_swap(W &x, W &y) noexcept

XOR swap two variables.

int for_each_bit_range_no_check(const BV &bv, typename BV::size_type left, typename BV::size_type right, Func &bit_functor)

Implementation of for_each_bit_range without boilerplave checks.

bool find_first_nz(const VT *arr, SZ arr_size, SZ *found_idx) noexcept

Find max non-zero value in an array.

bool find_max_nz(const VT *arr, SZ arr_size, SZ *found_idx) noexcept

Find max non-zero value in an array.

unsigned long long int id64_t

@ COPY_RTABLES

copy remap tables only (without data)

const unsigned gap_max_bits

const unsigned set_block_shift

bool has_zero_byte_u64(bm::id64_t v) noexcept

Returns true if INT64 contains 0 octet.

double value_type

The numeric datatype used by the parser.

const struct ncbi::grid::netcache::search::fields::SIZE size

void resize(vector< SMethodDef > &container)

static const BitmapCharRec ch3

static const BitmapCharRec ch1

static const BitmapCharRec ch0

static const BitmapCharRec ch2

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)

#define row(bind, expected)

Structure with statistical information about memory allocation footprint, serialization projection,...

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