void
DefDelWriter_Finish_IMP(DefaultDeletionsWriter *self) {
DefaultDeletionsWriterIVARS *const ivars = DefDelWriter_IVARS(self);
Folder *const folder = ivars->folder;
for (uint32_t i = 0, max = VA_Get_Size(ivars->seg_readers); i < max; i++) {
SegReader *seg_reader = (SegReader*)VA_Fetch(ivars->seg_readers, i);
if (ivars->updated[i]) {
BitVector *deldocs = (BitVector*)VA_Fetch(ivars->bit_vecs, i);
int32_t doc_max = SegReader_Doc_Max(seg_reader);
double used = (doc_max + 1) / 8.0;
uint32_t byte_size = (uint32_t)ceil(used);
uint32_t new_max = byte_size * 8 - 1;
String *filename = S_del_filename(self, seg_reader);
OutStream *outstream = Folder_Open_Out(folder, filename);
if (!outstream) { RETHROW(INCREF(Err_get_error())); }
// Ensure that we have 1 bit for each doc in segment.
BitVec_Grow(deldocs, new_max);
// Write deletions data and clean up.
OutStream_Write_Bytes(outstream,
(char*)BitVec_Get_Raw_Bits(deldocs),
byte_size);
OutStream_Close(outstream);
DECREF(outstream);
DECREF(filename);
}
}
Seg_Store_Metadata_Utf8(ivars->segment, "deletions", 9,
(Obj*)DefDelWriter_Metadata(self));
}
void
BitVec_set(BitVector *self, uint32_t tick) {
if (tick >= self->cap) {
uint32_t new_cap = (uint32_t)Memory_oversize(tick + 1, 0);
BitVec_Grow(self, new_cap);
}
NumUtil_u1set(self->bits, tick);
}
void
BitVec_Set_IMP(BitVector *self, size_t tick) {
BitVectorIVARS *const ivars = BitVec_IVARS(self);
if (tick >= ivars->cap) {
size_t new_cap = (size_t)Memory_oversize(tick + 1, 0);
BitVec_Grow(self, new_cap);
}
NumUtil_u1set(ivars->bits, tick);
}
void
BitVec_mimic(BitVector *self, Obj *other) {
BitVector *twin = (BitVector*)CERTIFY(other, BITVECTOR);
const uint32_t my_byte_size = (uint32_t)ceil(self->cap / 8.0);
const uint32_t twin_byte_size = (uint32_t)ceil(twin->cap / 8.0);
if (my_byte_size > twin_byte_size) {
uint32_t space = my_byte_size - twin_byte_size;
memset(self->bits + twin_byte_size, 0, space);
}
else if (my_byte_size < twin_byte_size) {
BitVec_Grow(self, twin->cap - 1);
}
memcpy(self->bits, twin->bits, twin_byte_size);
}
void
BitVec_Mimic_IMP(BitVector *self, Obj *other) {
CERTIFY(other, BITVECTOR);
BitVectorIVARS *const ivars = BitVec_IVARS(self);
BitVectorIVARS *const ovars = BitVec_IVARS((BitVector*)other);
const size_t my_byte_size = SI_octet_size(ivars->cap);
const size_t other_byte_size = SI_octet_size(ovars->cap);
if (my_byte_size > other_byte_size) {
size_t space = my_byte_size - other_byte_size;
memset(ivars->bits + other_byte_size, 0, space);
}
else if (my_byte_size < other_byte_size) {
BitVec_Grow(self, ovars->cap - 1);
}
memcpy(ivars->bits, ovars->bits, other_byte_size);
}
