sdds::Writer::Impl Struct Reference

Public Member Functions
void	writeCurrent (bool keepOpen)

Public Attributes
std::filesystem::path	path
WriterOptions	options
std::shared_ptr< Layout >	layout
std::unique_ptr< BufferedStream >	stream
std::optional< Page >	current
std::int64_t	pageNumber = 0
std::int64_t	expectedRows = 0
std::int64_t	updateInterval = 0
std::optional< std::uint64_t >	pageStart
std::optional< std::uint64_t >	disconnectedOffset
std::unique_ptr< PathLock >	lock
FileIdentity	identity
bool	snapshotWritten = false
bool	rewriteLastPage = false
bool	pathBacked = false
bool	disconnected = false
bool	closed = false

Detailed Description

Definition at line 3416 of file SDDSModern.cc.

Member Function Documentation

writeCurrent()

void sdds::Writer::Impl::writeCurrent ( bool keepOpen )

inline

Definition at line 3435 of file SDDSModern.cc.

                                   {
    if (!current)
      throwState("no page has been started");
    if (disconnected)
      throwState("writer is disconnected");
    validatePage(*current, *layout);
    if (rewriteLastPage) {
      const std::filesystem::path temporary(path.string() + ".sddspp.tmp");
      if (std::filesystem::exists(temporary))
        throwState("temporary rewrite file already exists: " + temporary.string());
      try {
        Layout outputLayout = *layout;
        BufferedStream output(openOutput(temporary,
                                         compressionFor(path, options.compression), "wb",
                                         options.bufferBytes, options.gzipLevel,
                                         options.lzmaPreset, options.lzmaCheck));
        writeLayout(output, outputLayout, options);
        std::int64_t number = 0;
        Reader source = Reader::open(path);
        while (number < pageNumber) {
          auto page = source.next();
          if (!page)
            throwState("source file lost a page during atomic last-page update");
          writePageData(output, *page, outputLayout, options, ++number);
        }
        source.close();
        writePageData(output, *current, outputLayout, options, ++number);
        output.close();
#if defined(_WIN32)
        lock.reset();
#endif
        replaceFile(temporary, path);
        identity = fileIdentity(path);
        if (options.lockMode != LockMode::None)
          lock = acquirePathLock(path, options.lockMode, false);
      } catch (...) {
        std::error_code ignored;
        std::filesystem::remove(temporary, ignored);
        throw;
      }
      snapshotWritten = true;
    } else {
      if (!stream)
        throwState("writer has no output stream");
      if (snapshotWritten) {
        if (!pageStart || !stream->seekable())
          throwState("page update requires a seekable, uncompressed output");
        stream->seek(*pageStart);
      } else {
        pageStart = stream->seekable() ? std::optional<std::uint64_t>(stream->tell())
                                       : std::nullopt;
      }
      writePageData(*stream, *current, *layout, options, pageNumber + 1);
      if (snapshotWritten)
        stream->truncate(stream->tell());
      snapshotWritten = true;
      stream->flush();
    }
    if (!keepOpen) {
      ++pageNumber;
      current.reset();
      pageStart.reset();
      snapshotWritten = false;
    }
  }

Member Data Documentation

closed

bool sdds::Writer::Impl::closed = false

Definition at line 3433 of file SDDSModern.cc.

current

std::optional<Page> sdds::Writer::Impl::current

Definition at line 3421 of file SDDSModern.cc.

disconnected

bool sdds::Writer::Impl::disconnected = false

Definition at line 3432 of file SDDSModern.cc.

disconnectedOffset

std::optional<std::uint64_t> sdds::Writer::Impl::disconnectedOffset

Definition at line 3426 of file SDDSModern.cc.

expectedRows

std::int64_t sdds::Writer::Impl::expectedRows = 0

Definition at line 3423 of file SDDSModern.cc.

identity

FileIdentity sdds::Writer::Impl::identity

Definition at line 3428 of file SDDSModern.cc.

layout

std::shared_ptr<Layout> sdds::Writer::Impl::layout

Definition at line 3419 of file SDDSModern.cc.

lock

std::unique_ptr<PathLock> sdds::Writer::Impl::lock

Definition at line 3427 of file SDDSModern.cc.

options

WriterOptions sdds::Writer::Impl::options

Definition at line 3418 of file SDDSModern.cc.

pageNumber

std::int64_t sdds::Writer::Impl::pageNumber = 0

Definition at line 3422 of file SDDSModern.cc.

pageStart

std::optional<std::uint64_t> sdds::Writer::Impl::pageStart

Definition at line 3425 of file SDDSModern.cc.

path

std::filesystem::path sdds::Writer::Impl::path

Definition at line 3417 of file SDDSModern.cc.

pathBacked

bool sdds::Writer::Impl::pathBacked = false

Definition at line 3431 of file SDDSModern.cc.

rewriteLastPage

bool sdds::Writer::Impl::rewriteLastPage = false

Definition at line 3430 of file SDDSModern.cc.

snapshotWritten

bool sdds::Writer::Impl::snapshotWritten = false

Definition at line 3429 of file SDDSModern.cc.

stream

std::unique_ptr<BufferedStream> sdds::Writer::Impl::stream

Definition at line 3420 of file SDDSModern.cc.

updateInterval

std::int64_t sdds::Writer::Impl::updateInterval = 0

Definition at line 3424 of file SDDSModern.cc.

---

The documentation for this struct was generated from the following file:

• SDDS/SDDSlib++/SDDSModern.cc