mirror of
https://github.com/Zygo/bees.git
synced 2025-05-17 21:35:45 +02:00
e99a505b3b
operator<< was a friend class that locked the ByteVector, then invoked hexdump on the bytevector, which used ByteVector::operator[]...which locked the ByteVector, resulting in a deadlock. operator<< shouldn't be a friend class anyway. Make hexdump use the normal public access methods for ByteVector. Signed-off-by: Zygo Blaxell <bees@furryterror.org>
81 lines
2.2 KiB
C++
81 lines
2.2 KiB
C++
#ifndef _CRUCIBLE_BYTEVECTOR_H_
|
|
#define _CRUCIBLE_BYTEVECTOR_H_
|
|
|
|
#include <crucible/error.h>
|
|
|
|
#include <memory>
|
|
#include <mutex>
|
|
#include <ostream>
|
|
|
|
#include <cstdint>
|
|
#include <cstdlib>
|
|
|
|
namespace crucible {
|
|
using namespace std;
|
|
// new[] is a little slower than malloc
|
|
// shared_ptr is about 2x slower than unique_ptr
|
|
// vector<uint8_t> is ~160x slower
|
|
// so we won't bother with unique_ptr because we can't do shared copies with it
|
|
|
|
class ByteVector {
|
|
public:
|
|
using Pointer = shared_ptr<uint8_t>;
|
|
using value_type = Pointer::element_type;
|
|
using iterator = value_type*;
|
|
|
|
ByteVector() = default;
|
|
ByteVector(const ByteVector &that);
|
|
ByteVector& operator=(const ByteVector &that);
|
|
ByteVector(size_t size);
|
|
ByteVector(const ByteVector &that, size_t start, size_t length);
|
|
ByteVector(iterator begin, iterator end, size_t min_size = 0);
|
|
|
|
ByteVector at(size_t start, size_t length) const;
|
|
|
|
value_type& at(size_t) const;
|
|
iterator begin() const;
|
|
void clear();
|
|
value_type* data() const;
|
|
bool empty() const;
|
|
iterator end() const;
|
|
value_type& operator[](size_t) const;
|
|
size_t size() const;
|
|
bool operator==(const ByteVector &that) const;
|
|
|
|
// this version of erase only works at the beginning or end of the buffer, else throws exception
|
|
void erase(iterator first);
|
|
void erase(iterator first, iterator last);
|
|
|
|
// An important use case is ioctls that have a fixed-size header struct
|
|
// followed by a buffer for further arguments. These templates avoid
|
|
// doing reinterpret_casts every time.
|
|
template <class T> ByteVector(const T& object, size_t min_size);
|
|
template <class T> T* get() const;
|
|
private:
|
|
Pointer m_ptr;
|
|
size_t m_size = 0;
|
|
mutable mutex m_mutex;
|
|
};
|
|
|
|
template <class T>
|
|
ByteVector::ByteVector(const T& object, size_t min_size)
|
|
{
|
|
const auto size = max(min_size, sizeof(T));
|
|
m_ptr = Pointer(static_cast<value_type*>(malloc(size)), free);
|
|
memcpy(m_ptr.get(), &object, sizeof(T));
|
|
m_size = size;
|
|
}
|
|
|
|
template <class T>
|
|
T*
|
|
ByteVector::get() const
|
|
{
|
|
THROW_CHECK2(out_of_range, size(), sizeof(T), size() >= sizeof(T));
|
|
return reinterpret_cast<T*>(data());
|
|
}
|
|
|
|
ostream& operator<<(ostream &os, const ByteVector &bv);
|
|
}
|
|
|
|
#endif // _CRUCIBLE_BYTEVECTOR_H_
|