forked from mirrors/gecko-dev
122 lines
3.5 KiB
C++
122 lines
3.5 KiB
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/. */
|
|
|
|
#ifndef databuffer_h__
|
|
#define databuffer_h__
|
|
|
|
#include <algorithm>
|
|
#include <cstdint>
|
|
#include <cstring>
|
|
#include <iomanip>
|
|
#include <iostream>
|
|
|
|
namespace nss_test {
|
|
|
|
class DataBuffer {
|
|
public:
|
|
DataBuffer() : data_(nullptr), len_(0) {}
|
|
DataBuffer(const uint8_t* d, size_t l) : data_(nullptr), len_(0) {
|
|
Assign(d, l);
|
|
}
|
|
DataBuffer(const DataBuffer& other) : data_(nullptr), len_(0) {
|
|
Assign(other);
|
|
}
|
|
explicit DataBuffer(size_t l) : data_(nullptr), len_(0) { Allocate(l); }
|
|
~DataBuffer() { delete[] data_; }
|
|
|
|
DataBuffer& operator=(const DataBuffer& other) {
|
|
if (&other != this) {
|
|
Assign(other);
|
|
}
|
|
return *this;
|
|
}
|
|
DataBuffer& operator=(DataBuffer&& other) {
|
|
if (this != &other) {
|
|
delete[] data_;
|
|
data_ = other.data_;
|
|
len_ = other.len_;
|
|
other.data_ = nullptr;
|
|
other.len_ = 0;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
void Allocate(size_t l) {
|
|
delete[] data_;
|
|
data_ = new uint8_t[l ? l : 1](); // Don't depend on new [0].
|
|
len_ = l;
|
|
}
|
|
|
|
void Truncate(size_t l) { len_ = (std::min)(len_, l); }
|
|
|
|
void Assign(const DataBuffer& other) { Assign(other.data(), other.len()); }
|
|
|
|
void Assign(const uint8_t* d, size_t l);
|
|
|
|
// 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 Write(size_t index, const uint8_t* val, size_t count);
|
|
size_t Write(size_t index, const DataBuffer& buf) {
|
|
return Write(index, buf.data(), buf.len());
|
|
}
|
|
|
|
// Write an integer, also performing host-to-network order conversion.
|
|
// Returns the offset of the end of the write.
|
|
size_t Write(size_t index, uint32_t val, size_t count);
|
|
|
|
// Starting at |index|, remove |remove| bytes and replace them with the
|
|
// contents of |buf|.
|
|
void Splice(const DataBuffer& buf, size_t index, size_t remove = 0) {
|
|
Splice(buf.data(), buf.len(), index, remove);
|
|
}
|
|
|
|
void Splice(const uint8_t* ins, size_t ins_len, size_t index,
|
|
size_t remove = 0);
|
|
void Append(const DataBuffer& buf) { Splice(buf, len_); }
|
|
|
|
bool Read(size_t index, size_t count, uint64_t* val) const;
|
|
bool Read(size_t index, size_t count, uint32_t* val) const;
|
|
|
|
const uint8_t* data() const { return data_; }
|
|
uint8_t* data() { return data_; }
|
|
size_t len() const { return len_; }
|
|
bool empty() const { return len_ == 0; }
|
|
|
|
static void SetLogLimit(size_t limit);
|
|
friend std::ostream& operator<<(std::ostream& stream, const DataBuffer& buf);
|
|
|
|
private:
|
|
static size_t logging_limit;
|
|
uint8_t* data_;
|
|
size_t len_;
|
|
};
|
|
|
|
inline std::ostream& operator<<(std::ostream& stream, const DataBuffer& buf) {
|
|
stream << "[" << buf.len() << "] ";
|
|
for (size_t i = 0; i < buf.len(); ++i) {
|
|
if (i >= DataBuffer::logging_limit) {
|
|
stream << "...";
|
|
break;
|
|
}
|
|
stream << std::hex << std::setfill('0') << std::setw(2)
|
|
<< static_cast<unsigned>(buf.data()[i]);
|
|
}
|
|
stream << std::dec;
|
|
return stream;
|
|
}
|
|
|
|
inline bool operator==(const DataBuffer& a, const DataBuffer& b) {
|
|
return (a.empty() && b.empty()) ||
|
|
(a.len() == b.len() && 0 == memcmp(a.data(), b.data(), a.len()));
|
|
}
|
|
|
|
inline bool operator!=(const DataBuffer& a, const DataBuffer& b) {
|
|
return !(a == b);
|
|
}
|
|
|
|
} // namespace nss_test
|
|
|
|
#endif
|