//! Swap operator
void swap(wt_int_rlmn& wt) {
if (this != &wt) {
std::swap(m_size, wt.m_size);
m_bl.swap(wt.m_bl);
m_bf.swap(wt.m_bf);
m_wt.swap(wt.m_wt);
m_bl_rank.swap(wt.m_bl_rank);
m_bl_rank.set_vector(&m_bl);
wt.m_bl_rank.set_vector(&(wt.m_bl));
m_bf_rank.swap(wt.m_bf_rank);
m_bf_rank.set_vector(&m_bf);
wt.m_bf_rank.set_vector(&(wt.m_bf));
m_bl_select.swap(wt.m_bl_select);
m_bl_select.set_vector(&m_bl);
wt.m_bl_select.set_vector(&(wt.m_bl));
m_bf_select.swap(wt.m_bf_select);
m_bf_select.set_vector(&m_bf);
wt.m_bf_select.set_vector(&(wt.m_bf));
m_C.swap(wt.m_C);
m_C_bf_rank.swap(wt.m_C_bf_rank);
}
}
//! Loads the data structure from the given istream.
void load(std::istream& in) {
read_member(m_size, in);
m_bl.load(in);
m_bf.load(in);
m_wt.load(in);
m_bl_rank.load(in, &m_bl);
m_bf_rank.load(in, &m_bf);
m_bl_select.load(in, &m_bl);
m_bf_select.load(in, &m_bf);
m_C.load(in);
m_C_bf_rank.load(in);
}
//! Serializes the data structure into the given ostream
size_type serialize(std::ostream& out, structure_tree_node* v=nullptr, std::string name="")const {
structure_tree_node* child = structure_tree::add_child(v, name, util::class_name(*this));
size_type written_bytes = 0;
written_bytes += write_member(m_size, out, child, "size");
written_bytes += m_bl.serialize(out, child, "bl");
written_bytes += m_bf.serialize(out, child, "bf");
written_bytes += m_wt.serialize(out, child, "wt");
written_bytes += m_bl_rank.serialize(out, child, "bl_rank");
written_bytes += m_bf_rank.serialize(out, child, "bf_rank");
written_bytes += m_bl_select.serialize(out, child, "bl_select");
written_bytes += m_bf_select.serialize(out, child, "bf_select");
written_bytes += m_C.serialize(out, child, "C");
written_bytes += m_C_bf_rank.serialize(out, child, "C_bf_rank");
structure_tree::add_size(child, written_bytes);
return written_bytes;
}
//! Swap operator
void swap(int_alphabet& strat) {
m_char.swap(strat.m_char);
util::swap_support(m_char_rank, strat.m_char_rank, &m_char, &(strat.m_char));
util::swap_support(m_char_select, strat.m_char_select, &m_char, &(strat.m_char));
m_C.swap(strat.m_C);
std::swap(m_sigma,strat.m_sigma);
}
void load(std::istream& in) {
m_bv.load(in);
m_bv_select1.load(in);
m_bv_select1.set_vector(&m_bv);
m_bv_select0.load(in);
m_bv_select0.set_vector(&m_bv);
}
//! Swap operator
void swap(succinct_byte_alphabet_strategy& strat){
m_char.swap(strat.m_char);
util::swap_support(m_char_rank, strat.m_char_rank, &m_char, &(strat.m_char) );
util::swap_support(m_char_select, strat.m_char_select, &m_char, &(strat.m_char) );
m_C.swap(strat.m_C);
std::swap(m_sigma,strat.m_sigma);
}
size_type serialize(std::ostream& out, structure_tree_node* v=nullptr, std::string name="")const {
structure_tree_node* child = structure_tree::add_child(v, name, util::class_name(*this));
size_type written_bytes = 0;
m_bv.serialize(out, child, "bitvector");
m_bv_select1(out, child, "select1");
m_bv_select0(out, child, "select0");
structure_tree::add_size(child, written_bytes);
return written_bytes;
}
//! Load method
void load(std::istream& in) {
m_char.load(in);
m_char_rank.load(in);
m_char_rank.set_vector(&m_char);
m_char_select.load(in);
m_char_select.set_vector(&m_char);
m_C.load(in);
read_member(m_sigma, in);
}
//! Serialize method
size_type serialize(std::ostream& out, structure_tree_node* v=nullptr, std::string name="")const {
structure_tree_node* child = structure_tree::add_child(v, name, util::class_name(*this));
size_type written_bytes = 0;
written_bytes += m_char.serialize(out, child, "m_char");
written_bytes += m_char_rank.serialize(out, child, "m_char_rank");
written_bytes += m_char_select.serialize(out, child, "m_char_select");
written_bytes += m_C.serialize(out, child, "m_C");
written_bytes += write_member(m_sigma, out, child, "m_sigma");
structure_tree::add_size(child, written_bytes);
return written_bytes;
}
/*! \param i Argument for the length of the prefix v[0..i-1], with \f$0\leq i \leq size()\f$.
\returns Number of 1-bits in the prefix [0..i-1] of the original bit_vector.
\par Time complexity
\f$ \Order{ sample\_rate of the rrr\_vector} \f$
*/
const size_type rank(size_type i)const {
assert(m_v != nullptr);
assert(i <= m_v->size());
size_type bt_idx = i/t_bs;
size_type sample_pos = bt_idx/t_k;
size_type btnrp = m_v->m_btnrp[ sample_pos ];
size_type rank = m_v->m_rank[ sample_pos ];
if (sample_pos+1 < m_v->m_rank.size()) {
size_type diff_rank = m_v->m_rank[ sample_pos+1 ] - rank;
#ifndef RRR_NO_OPT
if (diff_rank == (size_type)0) {
return rank_support_rrr_trait<t_b>::adjust_rank(rank, i);
} else if (diff_rank == (size_type)t_bs*t_k) {
return rank_support_rrr_trait<t_b>::adjust_rank(
rank + i - sample_pos*t_k*t_bs, i);
}
#endif
}
const bool inv = m_v->m_invert[ sample_pos ];
for (size_type j = sample_pos*t_k; j < bt_idx; ++j) {
uint16_t r = m_v->m_bt[j];
rank += (inv ? t_bs - r: r);
btnrp += rrr_helper_type::space_for_bt(r);
}
uint16_t off = i % t_bs;
if (!off) { // needed for special case: if i=size() is a multiple of t_bs
// the access to m_bt would cause a invalid memory access
return rank_support_rrr_trait<t_b>::adjust_rank(rank, i);
}
uint16_t bt = inv ? t_bs - m_v->m_bt[ bt_idx ] : m_v->m_bt[ bt_idx ];
uint16_t btnrlen = rrr_helper_type::space_for_bt(bt);
number_type btnr = rrr_helper_type::decode_btnr(m_v->m_btnr, btnrp, btnrlen);
uint16_t popcnt = rrr_helper_type::decode_popcount(bt, btnr, off);
return rank_support_rrr_trait<t_b>::adjust_rank(rank + popcnt, i);
}
const size_type size()const {
return m_v->size();
}
void swap(louds_tree& tree) {
m_bv.swap(tree.m_bv);
util::swap_support(m_bv_select1, tree.m_select1, &m_bv, &(tree.m_bv));
util::swap_support(m_bv_select0, tree.m_select0, &m_bv, &(tree.m_bv));
}
/*! \param v A node.
*/
bool is_leaf(const node_type& v) const {
// node is the last leaf or has no children, so m_bv[v.pos]==1
return (v.pos+1 == m_bv.size()) or m_bv[v.pos+1];
}
//! Returns the number of nodes in the tree.
size_type nodes()const {
return (m_bv.size()+1)/2;
}
//! Returns the number of nodes in the tree.
size_type nodes()const {
return m_bv.size()+1/2;
}
