C++ int_vector类代码示例

        //! Constructor
        lcp_byte(cache_config& config) {
            std::string lcp_file = cache_file_name(conf::KEY_LCP, config);
            int_vector_buffer<> lcp_buf(lcp_file);
            m_small_lcp = int_vector<8>(lcp_buf.size());
            size_type l=0, max_l=0, max_big_idx=0, big_sum=0;

            for (size_type i=0; i < m_small_lcp.size(); ++i) {
                if ((l=lcp_buf[i]) < 255) {
                    m_small_lcp[i] = l;
                } else {
                    m_small_lcp[i] = 255;
                    if (l > max_l) max_l = l;
                    max_big_idx = i;
                    ++big_sum;
                }
            }
            m_big_lcp     = int_vector<>(big_sum, 0, bits::hi(max_l)+1);
            m_big_lcp_idx = int_vector<>(big_sum, 0, bits::hi(max_big_idx)+1);

            for (size_type i=0,ii=0; i<m_small_lcp.size(); ++i) {
                if ((l=lcp_buf[i]) >= 255) {
                    m_big_lcp[ii] = l;
                    m_big_lcp_idx[ii] = i;
                    ++ii;
                }
            }
        }

// query by keywords
std::vector<double> queryImgIDKeywords(const int dbId, long int id, int numres, int kwJoinType, int_vector keywords, bool colorOnly){
	if (!validate_dbid(dbId)) { cerr << "ERROR: database space not found (" << dbId << ")" << endl; return std::vector<double>();}

	if ((id != 0) && !validate_imgid(dbId, id)) { // not search random and image doesnt exist
		cerr << "ERROR: image id (" << id << ") not found on given dbid (" << dbId << ") or dbid not existant" << endl ;
		return std::vector<double>();
	}

	if (keywords.size() < 1) {
		cerr << "ERROR: At least one keyword must be supplied" << endl ;
		return std::vector<double>();
	}

	// populate filter
	intVectorIterator it = keywords.begin();
	bloom_filter* bf = 0;

    // OR or AND each kwd postings filter to get final filter
    // start with the first one
    bf = new bloom_filter(*(getKwdPostings(*it)->imgIdsFilter));
    it++;
    for (; it != keywords.end(); it++) { // iterate the rest
        if (kwJoinType) { // and'd
            (*bf) &= *(getKwdPostings(*it)->imgIdsFilter);
        } else { // or'd
            (*bf) |= *(getKwdPostings(*it)->imgIdsFilter);
        }
    }

	if (id == 0) { // random images with these kwds

		vector<double> V; // select all images with the desired keywords
		for (sigIterator sit = dbSpace[dbId]->sigs.begin(); sit != dbSpace[dbId]->sigs.end(); sit++) {
			if (V.size() > 20*numres) break;

			if ((bf == 0) || (bf->contains((*sit).first))) { // image has desired keyword or we're querying random
				V.insert(V.end(), (*sit).first);
				V.insert(V.end(), 0);
			}
		}

		vector<double> Vres;

		for (int var = 0; var < min(V.size()/2, numres); ) { // var goes from 0 to numres
			int rint = rand()%(V.size()/2);
			if (V[rint*2] > 0) { // havent added this random result yet
				Vres.insert(Vres.end(), V[rint*2] );
				Vres.insert(Vres.end(), 0 );
				V[rint*2] = 0;
				++var;
			}
			++var;
		}

		return Vres;
	}
	return queryImgIDFiltered(dbId, id, numres, bf, colorOnly);

}

bool ternary::encode(const int_vector &v, int_vector &z){
	z.setIntWidth( v.getIntWidth() );
	size_t z_bit_size = 0;
	for(typename int_vector::const_iterator it = v.begin(), end = v.end(); it != end; ++it){
		z_bit_size += encoding_length(*it);
	}
	z.bit_resize( z_bit_size ); // Initial size of z
	if( z_bit_size & 0x3F ){ // if z_bit_size % 64 != 0
		*(z.m_data + (z_bit_size>>6)) = 0; // initialize last word
	}

std::vector<int> const build_vector()
{
    typedef std::vector<int> int_vector;
    static int_vector data = init_vector();
    int_vector::size_type const size = data.size();
    int_vector::iterator it = data.begin();
    int_vector::iterator const end = data.end();
    for (; it != end; ++it)
        *it += size;
    return data;
}

		/*! 
		 * Constructor for building the Index
		 * \param[in] str C-string of the text
		 */
		index_sa_text_psi(const unsigned char* str) : index() {

			size_t n = strlen((const char*)str);
			sa = int_vector<>(n+1, 0, bit_magic::l1BP(n+1)+1);
			algorithm::calculate_sa(str, n+1, sa);   // calculate the suffix array sa of str
			sdsl::algorithm::sa2psi(sa, psi);
			setText(str, n+1);

			text = int_vector<>(sa.size(), 0, bit_magic::l1BP(sigma)+1);
			for (size_t i=0; i<sa.size(); i++) text[i] = char2comp[str[i]];
		}

std::unordered_set<int> const build_unordered_set()
{
    typedef std::unordered_set<int> int_set;
    typedef std::vector<int> int_vector;

    int_set result;
    int_vector const data = build_vector();
    int_vector::const_iterator it = data.begin();
    int_vector::const_iterator const end = data.end();
    result.insert(it, end);
    return result;
}

 //! Load from a stream.
 void load(std::istream& in) {
     m_data.load(in);
     m_overflow.load(in);
     m_overflow_rank.load(in, &m_overflow);
     m_level_pointer_and_rank.load(in);
     read_member(m_max_level, in);
 }

        //! 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);
            }
        }

 impl()
 {
     m_nr_to_bin.resize(1<<n);
     m_bin_to_nr.resize(1<<n);
     for (int i=0, cnt=0, class_cnt=0; i<=n; ++i) {
         m_C[i] = cnt;
         class_cnt = 0;
         std::vector<bool> b(n,0);
         for (int j=0; j<i; ++j) b[n-j-1] = 1;
         do {
             uint32_t x=0;
             for (int k=0; k<n; ++k)
                 x |= ((uint32_t)b[n-k-1])<<(n-1-k);
             m_nr_to_bin[cnt] = x;
             m_bin_to_nr[x] = class_cnt;
             ++cnt;
             ++class_cnt;
         } while (next_permutation(b.begin(), b.end()));
         if (class_cnt == 1)
             m_space_for_bt[i] = 0;
         else
             m_space_for_bt[i] = bits::hi(class_cnt)+1;
     }
     if (n == 15) {
         for (int x=0; x<256; ++x) {
             m_space_for_bt_pair[x] = m_space_for_bt[x>>4] + m_space_for_bt[x&0x0F];
         }
     }
 }

 //! Loads the data structure from the given istream.
 void load(std::istream& in) {
     read_member(m_size, in);
     m_bt.load(in);
     m_btnr.load(in);
     m_btnrp.load(in);
     m_rank.load(in);
     m_invert.load(in);
 }

 /*! \param in In-Stream to load the rank_support data from.
  */
 void load(std::istream& in) {
     m_abs_samples.load(in);
     m_differences.load(in);
     read_member(m_ones, in);
     read_member(m_size, in);
     m_contains_abs_sample.load(in);
     m_rank_contains_abs_sample.load(in, &m_contains_abs_sample);
 }

        //! Swap method for lcp_dac
        void swap(lcp_dac& lcp_c) {
            m_data.swap(lcp_c.m_data);
            m_overflow.swap(lcp_c.m_overflow);
            util::swap_support(m_overflow_rank, lcp_c.m_overflow_rank,
                               &m_overflow, &(lcp_c.m_overflow));

            m_level_pointer_and_rank.swap(lcp_c.m_level_pointer_and_rank);
            std::swap(m_max_level, lcp_c.m_max_level);
        }

 //! Swap method
 void swap(rrr_vector& rrr) {
     if (this != &rrr) {
         std::swap(m_size, rrr.m_size);
         m_bt.swap(rrr.m_bt);
         m_btnr.swap(rrr.m_btnr);
         m_btnrp.swap(rrr.m_btnrp);
         m_rank.swap(rrr.m_rank);
         m_invert.swap(rrr.m_invert);
     }
 }

size_t index_sa_text_psi::serialize(std::ostream &out) const {
	size_t written_bytes = 0;
	out.put('1');
	written_bytes += sizeof(char);
	superserialize(out);
	written_bytes += sa.serialize(out);
	written_bytes += text.serialize(out);
	written_bytes += psi.serialize(out);
	return written_bytes;
}

 /*! \param i Index of the value. \f$ i \in [0..size()-1]\f$.
  * Time complexity: O(1) for small and O(log n) for large values
  */
 inline value_type operator[](size_type i)const {
     if (m_small_lcp[i]!=255) {
         return m_small_lcp[i];
     } else {
         size_type idx = lower_bound(m_big_lcp_idx.begin(),
                                     m_big_lcp_idx.end(),i)
                         - m_big_lcp_idx.begin();
         return m_big_lcp[idx];
     }
 }