write_rds.hpp

Go to the documentation of this file.

#ifndef RDS2CPP_WRITE_RDS_HPP
#define RDS2CPP_WRITE_RDS_HPP
 
#include <vector>
#include <cstddef>
 
#include "byteme/byteme.hpp"
#include "sanisizer/sanisizer.hpp"
 
#include "RdsFile.hpp"
#include "RObject.hpp"
#include "utils_write.hpp"
#include "write_object.hpp"
#include "SharedWriteInfo.hpp"
 
namespace rds2cpp {
 
struct WriteRdsOptions {
    bool parallel = false;
 
    std::size_t buffer_size = sanisizer::cap<std::size_t>(65536);
};
 
template<class Writer>
void write_rds(const RdsFile& info, Writer& writer, const WriteRdsOptions& options) {
    std::unique_ptr<byteme::BufferedWriter<unsigned char> > bufwriter;
    if (options.parallel) {
        bufwriter.reset(new byteme::ParallelBufferedWriter<unsigned char, Writer*>(&writer, options.buffer_size));
    } else {
        bufwriter.reset(new byteme::SerialBufferedWriter<unsigned char, Writer*>(&writer, options.buffer_size));
    }
 
    bufwriter->write("X\n");
    inject_integer<std::int32_t>(info.format_version, *bufwriter);
    write_version(info.writer_version, *bufwriter);
    write_version(info.reader_version, *bufwriter);
 
    const std::string encoding = string_encoding_to_name(info.encoding);
    inject_integer<std::int32_t>(sanisizer::cast<std::int32_t>(encoding.size()), *bufwriter);
    bufwriter->write(encoding);
 
    SharedWriteInfo shared(info.symbols, info.environments, info.external_pointers);
    write_object(info.object.get(), *bufwriter, shared); 
}
 
inline void write_rds(const RdsFile& info, const char* path, const WriteRdsOptions& options) {
    byteme::GzipFileWriter writer(path, {});
    write_rds(info, writer, options);
}
 
inline void write_rds(const RdsFile& info, std::string path, const WriteRdsOptions& options) {
    write_rds(info, path.c_str(), options);
}
 
 
}
 
#endif