// 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 "util/coding.h"

namespace leveldb {

void PutFixed32(std::string* dst, uint32_t value) {

  char buf[sizeof(value)];

  EncodeFixed32(buf, value);

  dst->append(buf, sizeof(buf));

}

void PutFixed64(std::string* dst, uint64_t value) {

  char buf[sizeof(value)];

  EncodeFixed64(buf, value);

  dst->append(buf, sizeof(buf));

}

char* EncodeVarint32(char* dst, uint32_t v) {

  // Operate on characters as unsigneds

  uint8_t* ptr = reinterpret_cast<uint8_t*>(dst);

  static const int B = 128;

  if (v < (1 << 7)) {

  Branch (25:7): [True: 251M, False: 310k]

    *(ptr++) = v;

  } else if (v < (1 << 14)) {

  Branch (27:14): [True: 310k, False: 0]

    *(ptr++) = v | B;

    *(ptr++) = v >> 7;

  } else if (v < (1 << 21)) {

  Branch (30:14): [True: 0, False: 0]

    *(ptr++) = v | B;

    *(ptr++) = (v >> 7) | B;

    *(ptr++) = v >> 14;

  } else if (v < (1 << 28)) {

  Branch (34:14): [True: 0, False: 0]

    *(ptr++) = v | B;

    *(ptr++) = (v >> 7) | B;

    *(ptr++) = (v >> 14) | B;

    *(ptr++) = v >> 21;

  } else {

    *(ptr++) = v | B;

    *(ptr++) = (v >> 7) | B;

    *(ptr++) = (v >> 14) | B;

    *(ptr++) = (v >> 21) | B;

    *(ptr++) = v >> 28;

  }

  return reinterpret_cast<char*>(ptr);

}

void PutVarint32(std::string* dst, uint32_t v) {

  char buf[5];

  char* ptr = EncodeVarint32(buf, v);

  dst->append(buf, ptr - buf);

}

char* EncodeVarint64(char* dst, uint64_t v) {

  static const int B = 128;

  uint8_t* ptr = reinterpret_cast<uint8_t*>(dst);

  while (v >= B) {

  Branch (58:10): [True: 336, False: 919]

    *(ptr++) = v | B;

    v >>= 7;

  }

  *(ptr++) = static_cast<uint8_t>(v);

  return reinterpret_cast<char*>(ptr);

}

void PutVarint64(std::string* dst, uint64_t v) {

  char buf[10];

  char* ptr = EncodeVarint64(buf, v);

  dst->append(buf, ptr - buf);

}

void PutLengthPrefixedSlice(std::string* dst, const Slice& value) {

  PutVarint32(dst, value.size());

  dst->append(value.data(), value.size());

}

int VarintLength(uint64_t v) {

  int len = 1;

  while (v >= 128) {

  Branch (79:10): [True: 155k, False: 124M]

    v >>= 7;

    len++;

  }

  return len;

}

const char* GetVarint32PtrFallback(const char* p, const char* limit,

                                   uint32_t* value) {

  uint32_t result = 0;

  for (uint32_t shift = 0; shift <= 28 && p < limit; shift += 7) {

  Branch (89:28): [True: 310k, False: 0]
  Branch (89:43): [True: 310k, False: 81]

    uint32_t byte = *(reinterpret_cast<const uint8_t*>(p));

    p++;

    if (byte & 128) {

  Branch (92:9): [True: 155k, False: 155k]

      // More bytes are present

      result |= ((byte & 127) << shift);

    } else {

      result |= (byte << shift);

      *value = result;

      return reinterpret_cast<const char*>(p);

    }

  }

  return nullptr;

}

bool GetVarint32(Slice* input, uint32_t* value) {

  const char* p = input->data();

  const char* limit = p + input->size();

  const char* q = GetVarint32Ptr(p, limit, value);

  if (q == nullptr) {

  Branch (108:7): [True: 81, False: 124M]

    return false;

  } else {

    *input = Slice(q, limit - q);

    return true;

  }

}

const char* GetVarint64Ptr(const char* p, const char* limit, uint64_t* value) {

  uint64_t result = 0;

  for (uint32_t shift = 0; shift <= 63 && p < limit; shift += 7) {

  Branch (118:28): [True: 2.03k, False: 0]
  Branch (118:43): [True: 2.03k, False: 0]

    uint64_t byte = *(reinterpret_cast<const uint8_t*>(p));

    p++;

    if (byte & 128) {

  Branch (121:9): [True: 843, False: 1.19k]

      // More bytes are present

      result |= ((byte & 127) << shift);

    } else {

      result |= (byte << shift);

      *value = result;

      return reinterpret_cast<const char*>(p);

    }

  }

  return nullptr;

}

bool GetVarint64(Slice* input, uint64_t* value) {

  const char* p = input->data();

  const char* limit = p + input->size();

  const char* q = GetVarint64Ptr(p, limit, value);

  if (q == nullptr) {

  Branch (137:7): [True: 0, False: 1.19k]

    return false;

  } else {

    *input = Slice(q, limit - q);

    return true;

  }

}

const char* GetLengthPrefixedSlice(const char* p, const char* limit,

                                   Slice* result) {

  uint32_t len;

  p = GetVarint32Ptr(p, limit, &len);

  if (p == nullptr) return nullptr;

  Branch (149:7): [True: 0, False: 0]

  if (p + len > limit) return nullptr;

  Branch (150:7): [True: 0, False: 0]

  *result = Slice(p, len);

  return p + len;

}

bool GetLengthPrefixedSlice(Slice* input, Slice* result) {

  uint32_t len;

  if (GetVarint32(input, &len) && input->size() >= len) {

  Branch (157:7): [True: 124M, False: 0]
  Branch (157:35): [True: 124M, False: 0]

    *result = Slice(input->data(), len);

    input->remove_prefix(len);

    return true;

  } else {

    return false;

  }

}

}  // namespace leveldb