C++ BitSet::get方法代码示例

int main(const int argc, const char** argv) {
	BitSet<24, char> bitset;

	bitset.set(14);
	std::cout << bitset.get(14) << "\n";
	bitset.debug_print();
	const size_t test_indices[] = {
		26, 155, 95, 9, 3, 183, 154, 130, 102, 103, 105, 19, 
		161, 190, 61, 162, 183, 11, 3, 88, 18, 155, 169, 73, 
		59, 58, 0, 105, 191, 140, 191, 91, 3, 4, 139, 176, 176, 
		180, 168, 16, 143, 96, 77, 38, 178, 189, 118, 109, 138, 
		69, 110, 102, 66, 85, 32, 190, 76, 66, 86, 40, 35, 104, 
		101, 89, 124, 27, 125, 46, 134, 96, 93, 161, 178, 83, 114, 
		128, 8, 55, 108, 167, 11, 184, 74, 164, 169, 101, 140, 31, 
		120, 167, 190, 85, 158, 118, 19, 63, 175, 155, 80, 58
	};
	
	for (const auto& test_idx: test_indices) {
		bitset.set(test_idx);
		bool ans = bitset.get(test_idx);
		if (!ans) {
			throw std::runtime_error("Failed test");
 		}
	}
	bitset.debug_print();

}

	void ChunkManager::dataChecked(const BitSet & ok_chunks)
	{
		// go over all chunks at check each of them
		for (Uint32 i = 0;i < chunks.count();i++)
		{
			Chunk* c = chunks[i];
			if (ok_chunks.get(i) && !bitset.get(i))
			{
				// We think we do not hae a chunk, but we do have it
				bitset.set(i,true);
				todo.set(i,false);
				// the chunk must be on disk
				c->setStatus(Chunk::ON_DISK);
				tor.updateFilePercentage(i,bitset); 
			}
			else if (!ok_chunks.get(i) && bitset.get(i))
			{
				Out(SYS_DIO|LOG_IMPORTANT) << "Previously OK chunk " << i << " is corrupt !!!!!" << endl;
				// We think we have a chunk, but we don't
				bitset.set(i,false);
				todo.set(i,!only_seed_chunks.get(i) && !excluded_chunks.get(i));
				if (c->getStatus() == Chunk::ON_DISK)
				{
					c->setStatus(Chunk::NOT_DOWNLOADED);
					tor.updateFilePercentage(i,bitset);
				}
				else if (c->getStatus() == Chunk::MMAPPED || c->getStatus() == Chunk::BUFFERED)
				{
					resetChunk(i);
				}
				else
				{
					tor.updateFilePercentage(i,bitset);
				}
			}
		}
		recalc_chunks_left = true;
		try
		{
			saveIndexFile();
		}
		catch (bt::Error & err)
		{
			Out(SYS_DIO|LOG_DEBUG) << "Failed to save index file : " << err.toString() << endl;
		}
		catch (...)
		{
			Out(SYS_DIO|LOG_DEBUG) << "Failed to save index file : unkown exception" << endl;
		}
		chunksLeft();
		corrupted_count = 0;
	}

/**
 * helper - add the users of the Defs of a given
 * instruction to the passed worklist.
 *
 * This encapsulates several nontrivial pieces of logic:
 * 1. Skip use instructions that haven't been reached yet.
 * 2. Skip over dead arms of constant conditionals.
 * 3. Jump the call-site gap between block delims.
 *    (goto -> label, cond -> arm)
 * 4. When reaching a block the first time, mark all its instructions reached
 *    *and* enque them, because they could have been previously skipped.
 */
void SCCP::addInstrUsers(Instr* instr) {
    for (AllUsesRange u(instr); !u.empty(); u.popFront()) {
        Instr* use_instr = user(u.front());
        if (mark.get(use_instr->id))
            ssawork.add(use_instr);
    }
}

	void ChunkCounter::decBitSet(const BitSet & bs)
	{
		for (Uint32 i = 0;i < cnt.size();i++)
		{
			if(bs.get(i))
				dec(i);
		}
	}

	void ChunkCounter::incBitSet(const BitSet & bs)
	{
		for (Uint32 i = 0;i < cnt.size();i++)
		{
			if(bs.get(i))
				cnt[i]++;
		}
	}

BitSet BitSet::operator+(const BitSet& that)
{
    BitSet result(*this);
    for (int i = 0; i < that.length(); ++i) {
        result.add(that.get(i));
    }
    return result;
}

	void BitSet::orBitSet(const BitSet & other)
	{
		Uint32 i = 0;
		while (i < num_bits)
		{
			bool val = get(i) || other.get(i);
			set(i,val);
			i++;
		}
	}

 void add(T item) {
     if (members.get(item->id))
         return;
     Seq<T>* n = newnode(item);
     n->tail = 0;
     if (end)
         end->tail = n;
     else
         work = n;
     end = n;
 }

void PVCopy::updateCopyFromBitSet(
    PVStructure &copyPVStructure,BitSet &bitSet,bool lockRecord)
{
    bool doAll = bitSet.get(0);
    if(lockRecord) pvRecord.lock();
    try {
        if(headNode->isStructure) {
            StructureNode *node = static_cast<StructureNode*>(headNode);
            updateStructureNodeFromBitSet(
                copyPVStructure,*node,bitSet,true,doAll);
        } else {
            RecordNode *node = static_cast<RecordNode*>(headNode);
            updateSubFieldFromBitSet(
                copyPVStructure,node->recordPVField,bitSet, true,doAll);
        }
        if(lockRecord) pvRecord.unlock();
    } catch(...) {
        if(lockRecord) pvRecord.unlock();
        throw;
    }
}

void
CLuceneIndexWriter::deleteEntry(const string& entry,
        lucene::index::IndexReader* reader) {
    int deleted = 0;
    wstring path(utf8toucs2(entry));
{
    Term t(systemlocation(), path.c_str());
    deleted += reader->deleteDocuments(&t);
    // if no file was deleted, no more can be deleted
    if (deleted == 0) return;
}
{
    Term t(parentlocation(), path.c_str());
    deleted += reader->deleteDocuments(&t);

    // if we have only deleted one file up to now, we cannot delete more
    if (deleted < 2) return;
}
{
    // delete all deeper nested files
    wstring v = utf8toucs2(entry+"/");
    Term* t = _CLNEW Term(parentlocation(), v.c_str());
    PrefixFilter* filter = _CLNEW PrefixFilter(t);
    BitSet* b = filter->bits(reader);
    _CLDELETE(filter);
    _CLDECDELETE(t);
    int32_t size = b->size();
    for (int id = 0; id < size; ++id) {
        if (b->get(id) && !reader->isDeleted(id)) {
            reader->deleteDocument(id);
            deleted++;
        }
    }
    _CLDELETE(b);
}
}

/**
 * Enque the block.  If it is already visited, just enqueu it.
 * Otherwise, mark it reached and enque all the instructions in the block.
 */
void SCCP::addBlock(BlockStartInstr* block) {
    if (!mark.get(block->id))
        cfgwork.push(block);
    else
        ssawork.add(block);
}