bool settings_save(Settings *setfile)
{
char setfilename_tmp[1024];
RFILE *fp = NULL;
if (!setfile)
setfile = &normal_settings;
retro_create_path_string(setfilename_tmp, sizeof(setfilename_tmp), g_dir, setfilename);
fp = filestream_open(setfilename_tmp, RETRO_VFS_FILE_ACCESS_WRITE,
RETRO_VFS_FILE_ACCESS_HINT_NONE);
if (!fp)
{
NX_ERR("Couldn't open file %s.\n", setfilename_tmp);
return 1;
}
NX_LOG("Writing settings...\n");
for(int i=0;i<INPUT_COUNT;i++)
setfile->input_mappings[i] = input_get_mapping(i);
setfile->version = SETTINGS_VERSION;
filestream_write(fp, setfile, sizeof(Settings));
filestream_close(fp);
return 0;
}
int filestream_putc(RFILE *stream, int c)
{
char c_char = (char)c;
if (!stream)
return EOF;
return filestream_write(stream, &c_char, 1)==1 ? c : EOF;
}
static JSON_Writer_HandlerResult RtlJSONOutputHandler(JSON_Writer writer, const char *pBytes, size_t length)
{
RtlJSONContext *context = (RtlJSONContext*)JSON_Writer_GetUserData(writer);
(void)writer; /* unused */
return filestream_write(context->file, pBytes, length) == length ? JSON_Writer_Continue : JSON_Writer_Abort;
}
static int node_iter(void *value, void *ctx)
{
struct node_iter_ctx *nictx = (struct node_iter_ctx*)ctx;
if (filestream_write(nictx->db->fd, value,
(ssize_t)(nictx->idx->key_size + sizeof(uint64_t))) > 0)
return 0;
return -1;
}
/**
* filestream_write_file:
* @path : path to file.
* @data : contents to write to the file.
* @size : size of the contents.
*
* Writes data to a file.
*
* Returns: true (1) on success, false (0) otherwise.
*/
bool filestream_write_file(const char *path, const void *data, ssize_t size)
{
ssize_t ret = 0;
RFILE *file = filestream_open(path, RFILE_MODE_WRITE, -1);
if (!file)
return false;
ret = filestream_write(file, data, size);
filestream_close(file);
return (ret == size);
}
int filestream_vprintf(RFILE *stream, const char* format, va_list args)
{
static char buffer[8 * 1024];
int numChars = vsprintf(buffer, format, args);
if (numChars < 0)
return -1;
else if (numChars == 0)
return 0;
return filestream_write(stream, buffer, numChars);
}
ssize_t intfstream_write(intfstream_internal_t *intf,
const void *s, size_t len)
{
if (!intf)
return 0;
switch (intf->type)
{
case INTFSTREAM_FILE:
return filestream_write(intf->file.fp, s, len);
case INTFSTREAM_MEMORY:
return memstream_write(intf->memory.fp, s, len);
}
return 0;
}
/**
* filestream_write_file:
* @path : path to file.
* @data : contents to write to the file.
* @size : size of the contents.
*
* Writes data to a file.
*
* Returns: true (1) on success, false (0) otherwise.
*/
bool filestream_write_file(const char *path, const void *data, int64_t size)
{
int64_t ret = 0;
RFILE *file = filestream_open(path,
RETRO_VFS_FILE_ACCESS_WRITE,
RETRO_VFS_FILE_ACCESS_HINT_NONE);
if (!file)
return false;
ret = filestream_write(file, data, size);
filestream_close(file);
if (ret != size)
return false;
return true;
}
int libretrodb_create(RFILE *fd, libretrodb_value_provider value_provider,
void *ctx)
{
int rv;
libretrodb_metadata_t md;
struct rmsgpack_dom_value item;
uint64_t item_count = 0;
libretrodb_header_t header = {{0}};
ssize_t root = filestream_seek(fd, 0, SEEK_CUR);
memcpy(header.magic_number, MAGIC_NUMBER, sizeof(MAGIC_NUMBER)-1);
/* We write the header in the end because we need to know the size of
* the db first */
filestream_seek(fd, sizeof(libretrodb_header_t), SEEK_CUR);
item.type = RDT_NULL;
while ((rv = value_provider(ctx, &item)) == 0)
{
if ((rv = libretrodb_validate_document(&item)) < 0)
goto clean;
if ((rv = rmsgpack_dom_write(fd, &item)) < 0)
goto clean;
rmsgpack_dom_value_free(&item);
item.type = RDT_NULL;
item_count++;
}
if (rv < 0)
goto clean;
if ((rv = rmsgpack_dom_write(fd, &sentinal)) < 0)
goto clean;
header.metadata_offset = swap_if_little64(filestream_seek(fd, 0, SEEK_CUR));
md.count = item_count;
libretrodb_write_metadata(fd, &md);
filestream_seek(fd, root, SEEK_SET);
filestream_write(fd, &header, sizeof(header));
clean:
rmsgpack_dom_value_free(&item);
return rv;
}
int64_t rfwrite(void const* buffer,
size_t elem_size, size_t elem_count, RFILE* stream)
{
return filestream_write(stream, buffer, elem_size * elem_count);
}
void FileStream::write(const void *data, uint64_t count)
{
if (!fp)
return;
filestream_write(fp, data, count);
}
