{

/** Bind a seekable output stream and capture its current position as origin.

explicit streams_encoder(std::ostream& stream);

/** Inspect channel and stream state.

bool is_good() const BMNOEXCEPT;

/** Access the borrowed stream for channel-specific error interrogation.

std::ostream& stream() BMNOEXCEPT;

/** Measure all encoded bytes relative to the channel origin.

size_t size() const BMNOEXCEPT;

/** Access the RAM encoder used by serialization helpers.

bm::encoder& get_encoder() BMNOEXCEPT;

/** Attach serializer-owned working memory without writing to the stream.

void bind_buffer(unsigned char* data, size_t capacity) BMNOEXCEPT;

/** Release the borrowed buffer and reset the RAM encoder without I/O.

void unbind_buffer() BMNOEXCEPT;

/** Write pending encoded bytes and reset the RAM cursor.

bool flush();

/** Replace previously encoded bytes while preserving the append position.

bool patch(size_t offset, const unsigned char* data, size_t count);

/** Copy construction is disabled because the stream and buffer are borrowed.

streams_encoder(const streams_encoder& other) = delete;

/** Copy assignment is disabled to preserve unique channel state.

streams_encoder& operator=(const streams_encoder& other) = delete;

/** Grow the serializer-owned buffer after submitting pending bytes.

template<class Buffer>

bool reserve(Buffer& buffer, size_t capacity);

/** Complete caller-owned output synchronization without closing the stream.

bool finish();

/** Check conversion to the stream offset and transfer-count types.

static bool fits(size_t n) BMNOEXCEPT;

/** Check whether an origin-relative position fits the stream offset type.

bool position_fits(size_t n) const BMNOEXCEPT;

std::ostream& stream_; ///< Borrowed output stream.

std::streampos origin_; ///< Initial physical output position.

bm::encoder enc_; ///< RAM encoder bound to serializer memory.

unsigned char* data_; ///< Borrowed working buffer, or null.

size_t capacity_; ///< Bound buffer capacity in bytes.

size_t written_; ///< Bytes submitted since origin_.

bool good_; ///< Sticky channel success state.

{

/** Signal an attempted read or position outside the bound RAM window.

struct exhausted {};

/** Construct an unbound, empty RAM decoder without allocating memory.

bounded_decoder() BMNOEXCEPT;

/** Bind a readable RAM window and reset its cursor.

void bind(const unsigned char* p, size_t n) BMNOEXCEPT;

/** Inspect bytes consumed from the current window.

size_t size() const BMNOEXCEPT;

/** Inspect the readable suffix of the window.

size_t remaining() const BMNOEXCEPT;

/** Access the current RAM position.

const unsigned char* get_pos() const BMNOEXCEPT;

/** Move the RAM cursor without reading or performing I/O.

void set_pos(const unsigned char* p);

/** Move the RAM cursor by a signed byte displacement.

void seek(int delta);

/** Read one 8-bit unsigned value and advance the RAM cursor.

unsigned char get_8();

/** Read one 16-bit unsigned value and advance the RAM cursor.

bm::short_t get_16();

/** Read one 24-bit unsigned value and advance the RAM cursor.

bm::word_t get_24();

/** Read one 32-bit unsigned value and advance the RAM cursor.

bm::word_t get_32();

/** Read one 48-bit unsigned value and advance the RAM cursor.

bm::id64_t get_48();

/** Read one 64-bit unsigned value and advance the RAM cursor.

bm::id64_t get_64();

/** Read the mask-prefixed h64 representation from the RAM window.

bm::id64_t get_h64();

/** Read an array of 16-bit values using the original RAM decoder.

void get_16(bm::short_t* dst, unsigned count);

/** Read an array of 32-bit values using the original RAM decoder.

void get_32(bm::word_t* dst, unsigned count);

/** Decode 32-bit words and combine them into an existing array with OR.

bool get_32_OR(bm::word_t* dst, unsigned count);

/** Decode 32-bit words and combine them into an existing array with AND.

void get_32_AND(bm::word_t* dst, unsigned count);

/** Copy raw bytes and advance the RAM cursor.

void memcpy(unsigned char* dst, size_t count);

/** Validate a byte-count request without advancing the cursor.

void require(size_t n) const;

/** Validate array size without overflowing a count-times-width calculation.

void require_array(unsigned n, unsigned width) const;

const unsigned char* data_; ///< Start of the borrowed RAM window.

size_t count_; ///< Valid bytes in the bound window.

size_t pos_; ///< Current byte offset within the window.

{

enum { streaming = true }; ///< Select exact physical BLOB-end accounting.

/** Persistent channel error categories, independent of stream exception masks. */

enum error_code

{

no_error, ///< No channel error has been recorded.

io_error, ///< Input, positioning, or stream-state failure.

invalid_input ///< Invalid request or exhausted encoded input.

};

/** Borrow an input stream without reading or capturing a BLOB origin yet.

explicit streams_decoder(std::istream& stream) BMNOEXCEPT;

/** Inspect both sticky channel status and the current stream state.

bool is_good() const BMNOEXCEPT;

/** Inspect the first recorded channel error.

error_code error() const BMNOEXCEPT;

/** Access the borrowed stream for errors or between-record application payloads.

std::istream& stream() BMNOEXCEPT;

/** Access the checked RAM decoder used by the shared traversal.

bounded_decoder& get_decoder() BMNOEXCEPT;

/** Inspect the logical input cursor independently of physical read-ahead.

size_t tell() const BMNOEXCEPT;

/** Start a BLOB at the stream current position and borrow working memory.

bool begin(unsigned char* data, size_t capacity);

/** Release borrowed memory and empty the RAM window without performing I/O.

void unbind_buffer() BMNOEXCEPT;

/** Record a channel failure while preserving the first error.

bool fail(error_code e = invalid_input) BMNOEXCEPT;

/** Make an upcoming encoded record available in the RAM window.

bool prepare(size_t n);

/** Move the logical cursor to a BLOB-relative position.

bool seek(size_t pos);

/** Restore the underlying stream to the logical cursor after decoding.

bool complete();

/** Copy construction is disabled because the stream and buffer are borrowed.

streams_decoder(const streams_decoder& other) = delete;

/** Copy assignment is disabled to preserve unique channel state.

streams_decoder& operator=(const streams_decoder& other) = delete;

/** Grow the owner buffer while preserving unread input and its logical offset.

template<class Buffer>

bool reserve(Buffer& buffer, size_t capacity);

/** Seek the physical stream using a checked origin-relative offset.

bool seek_stream(size_t pos);

std::istream& stream_; ///< Borrowed input stream.

std::streampos origin_ = std::streampos(0); ///< Current BLOB physical origin.

bounded_decoder dec_; ///< Checked decoder over borrowed memory.

unsigned char* data_ = 0; ///< Deserializer-owned buffer, or null.

size_t capacity_ = 0; ///< Bound capacity in bytes.

size_t offset_ = 0; ///< BLOB-relative start of the RAM window.

bool eof_ = false; ///< Last refill reached physical EOF.

error_code error_ = no_error; ///< First recorded channel failure.

{

/** Shared RAM/stream traversal with checked primitive decoding. */

typedef bm::deserializer<BV, bm::bounded_decoder> parent_type;

/** Working-memory owner using the bit-vector allocator contract. */

typedef bm::byte_buffer<typename BV::allocator_type> buffer_type;

/** Deserialize one BLOB and restore the underlying stream to its exact end.

template<class IN> bool deserialize(BV& bv, IN& input);

/** @internal Restore destination strategy and release memory on every exit.

template<class IN> struct release

{

IN& in; ///< Channel borrowing the retained working memory.

BV& target; ///< Destination whose original strategy is restored.

bm::strategy strategy; ///< Allocation strategy saved at entry.

/** Restore the target strategy and unbind channel memory without I/O. */

~release();

};

/** @internal Adapt an input channel and buffer owner to the shared traversal.

template<class IN> struct source

{

enum { streaming = true }; ///< Request complete physical BLOB consumption.

/** Bind references to the channel and retained working buffer.

source(IN& input, buffer_type& memory);

/** Access the checked RAM decoder without reading the stream.

bm::bounded_decoder& get_decoder();

/** Ensure buffer capacity, then prepare the next RAM decoding window.

bool prepare(size_t n);

/** Forward a BLOB-relative cursor move to the channel.

bool seek(size_t pos);

/** Read the logical cursor without physical stream I/O.

size_t tell() const;

IN& in; ///< Borrowed channel used by the traversal.

buffer_type& buffer; ///< Retained memory owner used when capacity grows.

};

buffer_type buffer_; ///< Allocator-typed memory retained across BLOBs.

{

typedef sparse_vector_deserializer<SV> base_type; ///< Shared sparse-vector state.

typedef typename SV::bvector_type bvector_type; ///< Plane and mask type.

typedef typename base_type::deserialization_index_type deserialization_index_type; ///< Plane index collection.

/** Restore an object or gather selected logical addresses.

bool deserialize(SV& sv, std::istream& stream, const bvector_type* mask = 0);

/** Construct reusable plane indexes without restoring the full vector.

bool construct_deserialization_index(deserialization_index_type& index,

std::istream& stream);

/** Read metadata, then decode planes in dependency order.

bool read(SV& sv, std::istream& stream, const bvector_type* mask,

deserialization_index_type* build);

/** Seek to a checked object-relative offset.

static bool seek(std::istream& stream, std::streampos origin, size_t offset);

streams_deserializer<bvector_type> reader_; ///< Retained plane decoder buffer.

typename serializer<bvector_type>::buffer metadata_; ///< Small offset-table buffer.

{

typedef typename SV::bvector_type bvector_type; ///< Address mask type.

typedef sparse_vector_float_deserialization_index<SV> deserialization_index_type; ///< Composite index.

typedef typename serializer<bvector_type>::bv_ref_vector_type bv_ref_vector_type; ///< XOR references.

/** Restore all values or a logical gather.

bool deserialize(SV& sv, std::istream& stream, const bvector_type* mask = 0);

/** Build indexes for the two integer components.

bool construct_deserialization_index(deserialization_index_type& index, std::istream& stream);

/** Attach a borrowed index. @param index Matching index or null to detach. */

void set_deserialization_index(deserialization_index_type* index);

/** Control index-assisted reads. @param enable Whether to use attached indexes. */

void set_deserialization_index_use(bool enable = true);

/** Attach external XOR references. @param refs References or null to detach. */

void set_xor_ref(bv_ref_vector_type* refs);

/** Validate the native header and calculate absolute component boundaries.

static bool header(std::istream& stream, std::streampos (&positions)[4]);

streams_deserializer<bvector_type> signs_; ///< Retained sign decoder.

streams_sparse_vector_deserializer<typename SV::sparse_vector_u> exponents_; ///< Exponent decoder.

streams_sparse_vector_deserializer<typename SV::sparse_vector_u> mantissas_; ///< Mantissa decoder.

{

std::ostream& stream; ///< Borrowed stream.

std::streampos origin; ///< Physical record origin.

size_t pos = 0; ///< Bytes written relative to origin.

/** Capture stream origin. @param s Seekable output. */

explicit stream_output(std::ostream& s);

/** Write bytes. @param p Source. @param n Length. @return I/O success. */

bool write(const unsigned char* p, size_t n);

/** Patch framing and restore position. @param at Relative offset. @param p Source.

bool patch(size_t at, const unsigned char* p, size_t n);

{

std::istream& stream; ///< Borrowed stream.

size_t remaining = 0; ///< Remaining bytes within current record/physical extent.

size_t pos = 0; ///< Bytes read relative to origin.

/** Capture input extent and restore the initial position. @param s Seekable input. */

explicit stream_input(std::istream& s);

/** Read within the current bound. @param p Destination. @param n Length. @return I/O success. */

bool read(unsigned char* p, size_t n);

: stream_(stream), origin_(stream.tellp()), enc_(0, 0),

data_(0), capacity_(0), written_(0), good_(false)

{

good_ = stream_.good() && origin_ != std::streampos(-1);

{

BM_ASSERT(!data_);

data_ = data; capacity_ = capacity;

enc_ = bm::encoder(data, capacity);

{

data_ = 0; capacity_ = 0;

enc_ = bm::encoder(0, 0);

{

if (!is_good()) return false;

const size_t count = data_ ? enc_.size() : 0;

if (!count) return true;

if (!fits(count) || count > size_t(-1) - written_ ||

!position_fits(written_ + count))

return good_ = false;

// Mark failure before potentially throwing stream operations.

good_ = false;

stream_.write(reinterpret_cast<const char*>(data_),

std::streamsize(count));

if (!stream_.good()) return false;

written_ += count;

enc_.reset();

return good_ = true;

{

if (!is_good()) return false;

const size_t total = size();

if (offset > total || count > total - offset)

return good_ = false;

// A patch may target this region before it is submitted.

if (offset >= written_)

{

if (count) ::memcpy(data_ + offset - written_, data, count);

return true;

}

if (!flush() || !fits(offset) || !fits(written_) || !fits(count))

return good_ = false;

good_ = false;

stream_.seekp(origin_ + std::streamoff(offset));

if (!stream_.good()) return false;

stream_.write(reinterpret_cast<const char*>(data), std::streamsize(count));

if (!stream_.good()) return false;

stream_.seekp(origin_ + std::streamoff(written_));

return good_ = stream_.good();

{

if (!flush()) return false;

good_ = false;

stream_.flush();

return good_ = stream_.good();

{

return n <= size_t((std::numeric_limits<std::streamoff>::max)()) &&

n <= size_t((std::numeric_limits<std::streamsize>::max)());

{

const std::streamoff base = std::streamoff(origin_);

return base >= 0 && n <= size_t(

(std::numeric_limits<std::streamoff>::max)() - base);

{

if (capacity <= capacity_) return is_good();

if (!flush()) return false;

// Clear the borrowed pointer before allocation (which may throw).

unbind_buffer();

buffer.resize(capacity, false);

bind_buffer(buffer.data(), buffer.size());

return true;

{

data_ = p;

count_ = n;

pos_ = 0;

{

if (p < data_ || p > data_ + count_) throw exhausted();

pos_ = size_t(p - data_);

{

if (delta < 0)

{

size_t n = size_t(-static_cast<long long>(delta));

if (n > pos_) throw exhausted();

pos_ -= n;

}

else

{

require(size_t(delta));

pos_ += size_t(delta);

}

{

require(1);

return data_[pos_++];

{

require(2);

bm::decoder d(data_ + pos_);

pos_ += 2;

return d.get_16();

{

require(3);

bm::decoder d(data_ + pos_);

pos_ += 3;

return d.get_24();

{

require(4);

bm::decoder d(data_ + pos_);

pos_ += 4;

return d.get_32();

{

require(6);

bm::decoder d(data_ + pos_);

pos_ += 6;

return d.get_48();

{

require(8);

bm::decoder d(data_ + pos_);

pos_ += 8;

return d.get_64();

{

bm::id64_t value = 0;

unsigned mask = get_8();

for (unsigned i = 0; i < 8; ++i)

if (mask & (1u << i)) value |= bm::id64_t(get_8()) << (i * 8);

return value;

{

require_array(count, 2);

bm::decoder d(data_ + pos_); d.get_16(dst, count); pos_ += size_t(count) * 2;

{

require_array(count, 4);

bm::decoder d(data_ + pos_); d.get_32(dst, count); pos_ += size_t(count) * 4;

{

require_array(count, 4);

bm::decoder d(data_ + pos_);

bool full = d.get_32_OR(dst, count); pos_ += size_t(count) * 4; return full;

{

require_array(count, 4);

bm::decoder d(data_ + pos_); d.get_32_AND(dst, count); pos_ += size_t(count) * 4;

{

require(count);

if (dst && count) ::memcpy(dst, data_ + pos_, count);

pos_ += count;

: stream_(stream)

{