fcb_writer.hpp

Go to the documentation of this file.

#pragma once
 
#ifdef FCB_WITH_JSON
 
#    include <fcb/layout.hpp>
#    include <fcb/writer/attribute.hpp>
#    include <fcb/writer/header_serializer.hpp>
#    include <fcb/writer/rtree_builder.hpp>
 
#    include <nlohmann/json.hpp>
 
#    include <array>
#    include <cstdint>
#    include <cstdio>
#    include <optional>
#    include <ostream>
#    include <string>
#    include <vector>
 
namespace fcb {
 
struct FcbWriterOptions {
    bool write_index = true;
    std::uint16_t index_node_size = kDefaultNodeSize;
    std::vector<std::pair<std::string, std::optional<std::uint16_t>>> attribute_indices;
    std::optional<std::array<double, 6>> geographical_extent;
};
 
class FcbWriter {
  public:
    FcbWriter(nlohmann::ordered_json cj, FcbWriterOptions options, AttributeSchema attr_schema,
              std::optional<AttributeSchema> semantic_attr_schema);
    ~FcbWriter();
 
    FcbWriter(const FcbWriter&) = delete;
    FcbWriter& operator=(const FcbWriter&) = delete;
    FcbWriter(FcbWriter&&) = delete;
    FcbWriter& operator=(FcbWriter&&) = delete;
 
    void add_feature(const nlohmann::ordered_json& city_json_feature);
 
    void write(std::ostream& out);
 
    std::vector<std::uint8_t> write();
 
  private:
    struct FeatureSlot {
        std::uint64_t offset;
        std::uint64_t size;
    };
 
    nlohmann::ordered_json cj_;
    FcbWriterOptions options_;
    AttributeSchema attr_schema_;
    std::optional<AttributeSchema> semantic_attr_schema_;
    std::vector<std::string> indexing_attr_;
 
    double scale_x_;
    double scale_y_;
    double translate_x_;
    double translate_y_;
 
    // `std::tmpfile()`, not a hand-rolled path under
    // `std::filesystem::temp_directory_path()`: the C standard guarantees
    // it names a file "different from any other existing file" and removes
    // it automatically on close, which is exactly the anonymous,
    // collision-safe temp file Rust's own `tempfile` crate provides --
    // reusing that guarantee is safer than reimplementing it. 64-bit
    // seeking uses `fseeko`/`ftello` (POSIX) or `_fseeki64` (MSVC) instead
    // of `fseek`'s `long` offset, which is only 32 bits wide on some
    // platforms -- a real limit for a writer whose whole point is handling
    // files too large to fit in memory.
    std::FILE* tmp_ = nullptr;
    std::uint64_t tmp_write_pos_ = 0;
    bool written_ = false;
 
    std::vector<FeatureSlot> feat_offsets_;
    std::vector<NodeItem> feat_nodes_;
    std::vector<std::vector<AttributeIndexEntry>> index_entries_by_feature_;
};
 
}  // namespace fcb
 
#endif  // FCB_WITH_JSON