// Copyright (c) 2011 The LevelDB Authors. All rights reserved.

// Use of this source code is governed by a BSD-style license that can be

// found in the LICENSE file. See the AUTHORS file for names of contributors.

#include "db/log_writer.h"

#include <stdint.h>

#include "leveldb/env.h"

#include "util/coding.h"

#include "util/crc32c.h"

namespace leveldb {

namespace log {

static void InitTypeCrc(uint32_t* type_crc) {

  for (int i = 0; i <= kMaxRecordType; i++) {

  Branch (17:19): [True: 24.2k, False: 4.84k]

    char t = static_cast<char>(i);

    type_crc[i] = crc32c::Value(&t, 1);

  }

}

Writer::Writer(WritableFile* dest) : dest_(dest), block_offset_(0) {

  InitTypeCrc(type_crc_);

}

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

    : dest_(dest), block_offset_(dest_length % kBlockSize) {

  InitTypeCrc(type_crc_);

}

Writer::~Writer() = default;

Status Writer::AddRecord(const Slice& slice) {

  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) {

  Branch (46:9): [True: 11, False: 28.3k]

      // Switch to a new block

      if (leftover > 0) {

  Branch (48:11): [True: 0, False: 11]

        // Fill the trailer (literal below relies on kHeaderSize being 7)

        static_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;

  Branch (60:36): [True: 28.3k, False: 11]

    RecordType type;

    const bool end = (left == fragment_length);

    if (begin && end) {

  Branch (64:9): [True: 28.3k, False: 11]
  Branch (64:18): [True: 28.3k, False: 11]

      type = kFullType;

    } else if (begin) {

  Branch (66:16): [True: 11, False: 11]

      type = kFirstType;

    } else if (end) {

  Branch (68:16): [True: 11, False: 0]

      type = kLastType;

    } else {

      type = kMiddleType;

    }

    s = EmitPhysicalRecord(type, ptr, fragment_length);

    ptr += fragment_length;

    left -= fragment_length;

    begin = false;

  } while (s.ok() && left > 0);

  Branch (78:12): [True: 28.3k, False: 0]
  Branch (78:22): [True: 11, False: 28.3k]

  return s;

}

Status Writer::EmitPhysicalRecord(RecordType t, const char* ptr,

                                  size_t length) {

  assert(length <= 0xffff);  // Must fit in two bytes

  assert(block_offset_ + kHeaderSize + length <= kBlockSize);

  // Format the header

  char buf[kHeaderSize];

  buf[4] = static_cast<char>(length & 0xff);

  buf[5] = static_cast<char>(length >> 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, length);

  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()) {

  Branch (100:7): [True: 28.3k, False: 0]

    s = dest_->Append(Slice(ptr, length));

    if (s.ok()) {

  Branch (102:9): [True: 28.3k, False: 0]

      s = dest_->Flush();

    }

  }

  block_offset_ += kHeaderSize + length;

  return s;

}

}  // namespace log

}  // namespace leveldb