leveldb::log::Writer Class Reference

#include <log_writer.h>

Collaboration diagram for leveldb::log::Writer:

Public Member Functions
	Writer (WritableFile *dest)
	Writer (WritableFile *dest, uint64_t dest_length)
	~Writer ()
Status	AddRecord (const Slice &slice)

Private Member Functions
Status	EmitPhysicalRecord (RecordType type, const char *ptr, size_t length)
	Writer (const Writer &)
void	operator= (const Writer &)

Private Attributes
WritableFile *	dest_
int	block_offset_
uint32_t	type_crc_ [kMaxRecordType+1]

Detailed Description

Definition at line 19 of file log_writer.h.

Constructor & Destructor Documentation

Writer() [1/3]

leveldb::log::Writer::Writer ( WritableFile *  dest )

explicit

Definition at line 22 of file log_writer.cc.

    : dest_(dest),
      block_offset_(0) {
  InitTypeCrc(type_crc_);
}

Here is the call graph for this function:

Writer() [2/3]

leveldb::log::Writer::Writer	(	WritableFile *	dest,
		uint64_t	dest_length
	)

Definition at line 28 of file log_writer.cc.

    : dest_(dest), block_offset_(dest_length % kBlockSize) {
  InitTypeCrc(type_crc_);
}

Here is the call graph for this function:

~Writer()

leveldb::log::Writer::~Writer

(

)

Definition at line 33 of file log_writer.cc.

                {
}

Writer() [3/3]

leveldb::log::Writer::Writer ( const Writer &  )

private

Member Function Documentation

AddRecord()

Status leveldb::log::Writer::AddRecord

(

const Slice &

slice

)

Definition at line 36 of file log_writer.cc.

                                           {
  const char* ptr = slice.data();
  size_t left = slice.size();

  // Fragment the record if necessary and emit it.  Note that if slice
  // is empty, we still want to iterate once to emit a single
  // zero-length record
  Status s;
  bool begin = true;
  do {
    const int leftover = kBlockSize - block_offset_;
    assert(leftover >= 0);
    if (leftover < kHeaderSize) {
      // Switch to a new block
      if (leftover > 0) {
        // Fill the trailer (literal below relies on kHeaderSize being 7)
        assert(kHeaderSize == 7);
        dest_->Append(Slice("\x00\x00\x00\x00\x00\x00", leftover));
      }
      block_offset_ = 0;
    }

    // Invariant: we never leave < kHeaderSize bytes in a block.
    assert(kBlockSize - block_offset_ - kHeaderSize >= 0);

    const size_t avail = kBlockSize - block_offset_ - kHeaderSize;
    const size_t fragment_length = (left < avail) ? left : avail;

    RecordType type;
    const bool end = (left == fragment_length);
    if (begin && end) {
      type = kFullType;
    } else if (begin) {
      type = kFirstType;
    } else if (end) {
      type = kLastType;
    } else {
      type = kMiddleType;
    }

    s = EmitPhysicalRecord(type, ptr, fragment_length);
    ptr += fragment_length;
    left -= fragment_length;
    begin = false;
  } while (s.ok() && left > 0);
  return s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

EmitPhysicalRecord()

Status leveldb::log::Writer::EmitPhysicalRecord ( RecordType  type, const char *  ptr, size_t  length  )

private

Definition at line 84 of file log_writer.cc.

                                                                         {
  assert(n <= 0xffff);  // Must fit in two bytes
  assert(block_offset_ + kHeaderSize + n <= kBlockSize);

  // Format the header
  char buf[kHeaderSize];
  buf[4] = static_cast<char>(n & 0xff);
  buf[5] = static_cast<char>(n >> 8);
  buf[6] = static_cast<char>(t);

  // Compute the crc of the record type and the payload.
  uint32_t crc = crc32c::Extend(type_crc_[t], ptr, n);
  crc = crc32c::Mask(crc);                 // Adjust for storage
  EncodeFixed32(buf, crc);

  // Write the header and the payload
  Status s = dest_->Append(Slice(buf, kHeaderSize));
  if (s.ok()) {
    s = dest_->Append(Slice(ptr, n));
    if (s.ok()) {
      s = dest_->Flush();
    }
  }
  block_offset_ += kHeaderSize + n;
  return s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

void leveldb::log::Writer::operator= ( const Writer &  )

private

Member Data Documentation

block_offset_

int leveldb::log::Writer::block_offset_

private

Definition at line 37 of file log_writer.h.

dest_

WritableFile* leveldb::log::Writer::dest_

private

Definition at line 36 of file log_writer.h.

type_crc_

uint32_t leveldb::log::Writer::type_crc_[kMaxRecordType+1]

private

Definition at line 42 of file log_writer.h.

---

The documentation for this class was generated from the following files:

• db/log_writer.h
• db/log_writer.cc