ByteBuf*
Folder_slurp_file(Folder *self, const CharBuf *path) {
InStream *instream = Folder_Open_In(self, path);
ByteBuf *retval = NULL;
if (!instream) {
RETHROW(INCREF(Err_get_error()));
}
else {
uint64_t length = InStream_Length(instream);
if (length >= SIZE_MAX) {
InStream_Close(instream);
DECREF(instream);
THROW(ERR, "File %o is too big to slurp (%u64 bytes)", path,
length);
}
else {
size_t size = (size_t)length;
char *ptr = (char*)MALLOCATE((size_t)size + 1);
InStream_Read_Bytes(instream, ptr, size);
ptr[size] = '\0';
retval = BB_new_steal_bytes(ptr, size, size + 1);
InStream_Close(instream);
DECREF(instream);
}
}
return retval;
}
void
NumSortCache_destroy(NumericSortCache *self) {
if (self->ord_in) {
InStream_Close(self->ord_in);
InStream_Dec_RefCount(self->ord_in);
}
if (self->dat_in) {
InStream_Close(self->dat_in);
InStream_Dec_RefCount(self->dat_in);
}
SUPER_DESTROY(self, NUMERICSORTCACHE);
}
void
DefHLReader_close(DefaultHighlightReader *self) {
if (self->dat_in != NULL) {
InStream_Close(self->dat_in);
DECREF(self->dat_in);
self->dat_in = NULL;
}
if (self->ix_in != NULL) {
InStream_Close(self->ix_in);
DECREF(self->ix_in);
self->ix_in = NULL;
}
}
void
DefDocReader_Close_IMP(DefaultDocReader *self) {
DefaultDocReaderIVARS *const ivars = DefDocReader_IVARS(self);
if (ivars->dat_in != NULL) {
InStream_Close(ivars->dat_in);
DECREF(ivars->dat_in);
ivars->dat_in = NULL;
}
if (ivars->ix_in != NULL) {
InStream_Close(ivars->ix_in);
DECREF(ivars->ix_in);
ivars->ix_in = NULL;
}
}
static void
S_read_fsfolder(RAMFolder *self)
{
u32_t i, max;
/* Open an FSFolder for reading. */
FSFolder *source_folder = FSFolder_new(self->path);
VArray *files = FSFolder_List(source_folder);
/* Copy every file in the FSFolder into RAM. */
for (i = 0, max = VA_Get_Size(files); i < max; i++) {
CharBuf *filepath = (CharBuf*)VA_Fetch(files, i);
InStream *source_stream
= FSFolder_Open_In(source_folder, filepath);
OutStream *outstream = RAMFolder_Open_Out(self, filepath);
if (!source_stream) { THROW("Can't open %o", filepath); }
if (!outstream) { THROW("Can't open %o", filepath); }
OutStream_Absorb(outstream, source_stream);
OutStream_Close(outstream);
InStream_Close(source_stream);
DECREF(outstream);
DECREF(source_stream);
}
DECREF(files);
FSFolder_Close(source_folder);
DECREF(source_folder);
}
void
TextSortCache_Destroy_IMP(TextSortCache *self) {
TextSortCacheIVARS *const ivars = TextSortCache_IVARS(self);
if (ivars->ord_in) {
InStream_Close(ivars->ord_in);
DECREF(ivars->ord_in);
}
if (ivars->ix_in) {
InStream_Close(ivars->ix_in);
DECREF(ivars->ix_in);
}
if (ivars->dat_in) {
InStream_Close(ivars->dat_in);
DECREF(ivars->dat_in);
}
SUPER_DESTROY(self, TEXTSORTCACHE);
}
void
SortCache_destroy(SortCache *self)
{
if (self->ord_in) {
InStream_Close(self->ord_in);
InStream_Dec_RefCount(self->ord_in);
}
if (self->ix_in) {
InStream_Close(self->ix_in);
InStream_Dec_RefCount(self->ix_in);
}
if (self->dat_in) {
InStream_Close(self->dat_in);
InStream_Dec_RefCount(self->dat_in);
}
FREE_OBJ(self);
}
void
TextSortCache_destroy(TextSortCache *self)
{
if (self->ord_in) {
InStream_Close(self->ord_in);
InStream_Dec_RefCount(self->ord_in);
}
if (self->ix_in) {
InStream_Close(self->ix_in);
InStream_Dec_RefCount(self->ix_in);
}
if (self->dat_in) {
InStream_Close(self->dat_in);
InStream_Dec_RefCount(self->dat_in);
}
SUPER_DESTROY(self, TEXTSORTCACHE);
}
void
InStream_destroy(InStream *self) {
if (self->file_handle) {
InStream_Close(self);
}
DECREF(self->filename);
DECREF(self->window);
SUPER_DESTROY(self, INSTREAM);
}
void
InStream_destroy(InStream *self) {
InStreamIVARS *const ivars = InStream_IVARS(self);
if (ivars->file_handle) {
InStream_Close(self);
}
DECREF(ivars->filename);
DECREF(ivars->window);
SUPER_DESTROY(self, INSTREAM);
}
static void
test_Close(TestBatchRunner *runner) {
RAMFile *file = RAMFile_new(NULL, false);
InStream *instream = InStream_open((Obj*)file);
InStream_Close(instream);
TEST_TRUE(runner, InStream_IVARS(instream)->file_handle == NULL,
"Close decrements FileHandle's refcount");
DECREF(instream);
DECREF(file);
}
Obj*
Json_slurp_json(Folder *folder, const CharBuf *path) {
InStream *instream = Folder_Open_In(folder, path);
if (!instream) {
ERR_ADD_FRAME(Err_get_error());
return NULL;
}
size_t len = (size_t)InStream_Length(instream);
char *buf = InStream_Buf(instream, len);
Obj *dump = S_parse_json(buf, len);
InStream_Close(instream);
DECREF(instream);
if (!dump) {
ERR_ADD_FRAME(Err_get_error());
}
return dump;
}
void
CFReader_Close_IMP(CompoundFileReader *self) {
CompoundFileReaderIVARS *const ivars = CFReader_IVARS(self);
InStream_Close(ivars->instream);
}
static void
S_do_consolidate(CompoundFileWriter *self, CompoundFileWriterIVARS *ivars) {
UNUSED_VAR(self);
Folder *folder = ivars->folder;
Hash *metadata = Hash_new(0);
Hash *sub_files = Hash_new(0);
Vector *files = Folder_List(folder, NULL);
Vector *merged = Vec_new(Vec_Get_Size(files));
String *cf_file = (String*)SSTR_WRAP_UTF8("cf.dat", 6);
OutStream *outstream = Folder_Open_Out(folder, (String*)cf_file);
bool rename_success;
if (!outstream) { RETHROW(INCREF(Err_get_error())); }
// Start metadata.
Hash_Store_Utf8(metadata, "files", 5, INCREF(sub_files));
Hash_Store_Utf8(metadata, "format", 6,
(Obj*)Str_newf("%i32", CFWriter_current_file_format));
Vec_Sort(files);
for (uint32_t i = 0, max = Vec_Get_Size(files); i < max; i++) {
String *infilename = (String*)Vec_Fetch(files, i);
if (!Str_Ends_With_Utf8(infilename, ".json", 5)) {
InStream *instream = Folder_Open_In(folder, infilename);
Hash *file_data = Hash_new(2);
int64_t offset, len;
if (!instream) { RETHROW(INCREF(Err_get_error())); }
// Absorb the file.
offset = OutStream_Tell(outstream);
OutStream_Absorb(outstream, instream);
len = OutStream_Tell(outstream) - offset;
// Record offset and length.
Hash_Store_Utf8(file_data, "offset", 6,
(Obj*)Str_newf("%i64", offset));
Hash_Store_Utf8(file_data, "length", 6,
(Obj*)Str_newf("%i64", len));
Hash_Store(sub_files, infilename, (Obj*)file_data);
Vec_Push(merged, INCREF(infilename));
// Add filler NULL bytes so that every sub-file begins on a file
// position multiple of 8.
OutStream_Align(outstream, 8);
InStream_Close(instream);
DECREF(instream);
}
}
// Write metadata to cfmeta file.
String *cfmeta_temp = (String*)SSTR_WRAP_UTF8("cfmeta.json.temp", 16);
String *cfmeta_file = (String*)SSTR_WRAP_UTF8("cfmeta.json", 11);
Json_spew_json((Obj*)metadata, (Folder*)ivars->folder, cfmeta_temp);
rename_success = Folder_Rename(ivars->folder, cfmeta_temp, cfmeta_file);
if (!rename_success) { RETHROW(INCREF(Err_get_error())); }
// Clean up.
OutStream_Close(outstream);
DECREF(outstream);
DECREF(files);
DECREF(metadata);
/*
HashIterator *iter = HashIter_new(sub_files);
while (HashIter_Next(iter)) {
String *merged_file = HashIter_Get_Key(iter);
if (!Folder_Delete(folder, merged_file)) {
String *mess = MAKE_MESS("Can't delete '%o'", merged_file);
DECREF(sub_files);
Err_throw_mess(ERR, mess);
}
}
DECREF(iter);
*/
DECREF(sub_files);
for (uint32_t i = 0, max = Vec_Get_Size(merged); i < max; i++) {
String *merged_file = (String*)Vec_Fetch(merged, i);
if (!Folder_Delete(folder, merged_file)) {
String *mess = MAKE_MESS("Can't delete '%o'", merged_file);
DECREF(merged);
Err_throw_mess(ERR, mess);
}
}
DECREF(merged);
}
void
CFReader_close(CompoundFileReader *self) {
InStream_Close(self->instream);
}