Quelle databuffer.cc Sprache: C

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "databuffer.h"
#include <algorithm>
#include <cassert>
#include <cstring>
#include <iomanip>
#include <iostream>
#if defined(WIN32) || defined(WIN64)
#include <winsock2.h>
#else
#include <arpa/inet.h>
#endif

namespace nss_test {

void DataBuffer::Assign(const uint8_t* d, size_t l) {
  if (d) {
    Allocate(l);
    memcpy(static_cast<void*>(data_), static_cast<const void*>(d), l);
  } else {
    assert(l == 0);
    data_ = nullptr;
    len_ = 0;
  }
}

// Write will do a new allocation and expand the size of the buffer if needed.
// Returns the offset of the end of the write.
size_t DataBuffer::Write(size_t index, const uint8_t* val, size_t count) {
  assert(val);
  if (index + count > len_) {
    size_t newlen = index + count;
    uint8_t* tmp = new uint8_t[newlen];  // Always > 0.
    if (data_) {
      memcpy(static_cast<void*>(tmp), static_cast<const void*>(data_), len_);
    }
    if (index > len_) {
      memset(static_cast<void*>(tmp + len_), 0, index - len_);
    }
    delete[] data_;
    data_ = tmp;
    len_ = newlen;
  }
  if (data_) {
    memcpy(static_cast<void*>(data_ + index), static_cast<const void*>(val),
           count);
  }
  return index + count;
}

// Write an integer, also performing host-to-network order conversion.
// Returns the offset of the end of the write.
size_t DataBuffer::Write(size_t index, uint32_t val, size_t count) {
  assert(count <= sizeof(uint32_t));
  uint32_t nvalue = htonl(val);
  auto* addr = reinterpret_cast<const uint8_t*>(&nvalue);
  return Write(index, addr + sizeof(uint32_t) - count, count);
}

void DataBuffer::Splice(const uint8_t* ins, size_t ins_len, size_t index,
                        size_t remove) {
  assert(ins);
  uint8_t* old_value = data_;
  size_t old_len = len_;

  // The amount of stuff remaining from the tail of the old.
  size_t tail_len = old_len - (std::min)(old_len, index + remove);
  // The new length: the head of the old, the new, and the tail of the old.
  len_ = index + ins_len + tail_len;
  data_ = new uint8_t[len_ ? len_ : 1];

  // The head of the old.
  if (old_value) {
    Write(0, old_value, (std::min)(old_len, index));
  }
  // Maybe a gap.
  if (old_value && index > old_len) {
    memset(old_value + index, 0, index - old_len);
  }
  // The new.
  Write(index, ins, ins_len);
  // The tail of the old.
  if (tail_len > 0) {
    Write(index + ins_len, old_value + index + remove, tail_len);
  }

  delete[] old_value;
}

// This can't use the same trick as Write(), since we might be reading from a
// smaller data source.
bool DataBuffer::Read(size_t index, size_t count, uint64_t* val) const {
  assert(count <= sizeof(uint64_t));
  assert(val);
  if ((index > len()) || (count > (len() - index))) {
    return false;
  }
  *val = 0;
  for (size_t i = 0; i < count; ++i) {
    *val = (*val << 8) | data()[index + i];
  }
  return true;
}

bool DataBuffer::Read(size_t index, size_t count, uint32_t* val) const {
  assert(count <= sizeof(uint32_t));
  uint64_t tmp;

  if (!Read(index, count, &tmp)) {
    return false;
  }
  *val = tmp & 0xffffffff;
  return true;
}

size_t DataBuffer::logging_limit = 32;

/* static */ void DataBuffer::SetLogLimit(size_t limit) {
  DataBuffer::logging_limit = limit;
}

}  // namespace nss_test

quality97%

¤ Dauer der Verarbeitung: 0.14 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.