基于C++的ByteBuf封装
1、说明
netty 的 ByteBuf 中的 readerIndex 和 writerIndex 的设置十分巧妙，它内部对读取和写入位置进行控制，避免自己处理index的时候的各种麻烦，大大减少业务处理时的代码量
用 C++ 重构一下，删减了 netty 的 ByteBuf 中的一些不常用的接口
代码中其中只用到了 STL 的 string 和 unique_ptr，除此以外，再无其他依赖，轻量，易用，至少需要C++11以上的支持
直接上代码（含注释）
2、代码
ByteBuf.h
#ifndef SH_BYTE_BUF_H
#define SH_BYTE_BUF_H
#include <string>
#include <memory>
class ByteBufData;
namespace sh
{
enum Case
{
Lower = 0, //小写
Upper, //大写
};
/**
* ByteBuf封装，内置readerIndex和writerIndex基数，用于记录当前读取和写入的位置
*
* +-------------------+------------------+------------------+
* | discardable bytes | readable bytes | writable bytes |
* | | (CONTENT) | |
* +-------------------+------------------+------------------+
* | | | |
* 0 <= readerIndex <= writerIndex <= capacity
*
* @author: sherlock_lht
*/
class ByteBuf
{
public:
static char toHexLower(uint32_t value) noexcept;
static char toHexUpper(uint32_t value) noexcept;
static int32_t fromHex(uint32_t c) noexcept;
static ByteBuf fromHex(const std::string &hexEncoded) noexcept;
public:
explicit ByteBuf();
explicit ByteBuf(const char *data, int32_t size = -1);
explicit ByteBuf(const std::string &data);
explicit ByteBuf(int32_t size, char ch);
ByteBuf(const ByteBuf &other);
virtual ~ByteBuf();
ByteBuf &operator=(const ByteBuf &other);
/**
* 转换成16进制字符串
*/
std::string toHexString(Case type = Case::Lower, const std::string &fill_str = "") const;
/**
* 返回现有的字节数组
*/
const char *data() const noexcept;
/**
* 从readerIndex开始（包括readerIndex），到writerIndex结束（不包括writerIndex），找到buff内第一次出现的value的位置
* 该方法不会改变readerIndex和writerIndex
*
* @return value出现的位置到readerIndex之间的字节数，如果没找到则返回-1
*/
int32_t bytesBefore(char value);
/**
* 从readerIndex开始（包括readerIndex），到writerIndex结束（不包括writerIndex），找到buff内第一次出现连续长度为length的value的位置
* 该方法不会改变readerIndex和writerIndex
*
* @return value出现的位置到readerIndex之间的字节数，如果没找到则返回-1
*/
int32_t bytesBefore(int32_t length, char value);
/**
* 从index开始（包括index），到writerIndex结束（不包括writerIndex），找到buff内第一次出现连续长度为length的value的位置
* 该方法不会改变readerIndex和writerIndex
*
* @return value出现的位置到readerIndex之间的字节数，如果没找到则返回-1
*/
int32_t bytesBefore(int32_t index, int32_t length, char value);
/**
* 返回为对象分配的存储空间大小
*/
int32_t capacity() const;
/**
* 重新分配对象的存储空间大小，如果new_capacity不够存储现有的数据，则capacity保持不变
*/
ByteBuf &capacity(int32_t new_capacity);
/**
* readerIndex和writerIndex全部归零，等同于setIndex(0, 0)
*/
ByteBuf &clear();
/**
* 比较缓存区的数据内容，同strcmp
*/
int32_t compareTo(const ByteBuf &buffer) const;
/**
* 返回对象的可读字节数据的副本，即从readerIndex开始到writerIndex结束的数据
* 等同于 buf.copy(buf.readerIndex(), buf.readableBytes())
* 不影响原始对象的readerIndex和writerIndex，且两个对象互不影响
*/
ByteBuf copy() const;
/**
* 返回对象数据从index开始，长度的length的数据的副本
* 不影响原始对象的readerIndex和writerIndex，且两个对象互不影响
*/
ByteBuf copy(int32_t index, int32_t length) const;
/**
* 丢弃从0th到readerIndex之间的所有数据
* 即移动readerIndex到writerIndex之间的数据到0th，并且设置readerIndex和writerIndex为0
*/
ByteBuf &discardReadBytes();
/**
* 从buffer中定位第一次出现的value字符，搜索从fromIndex（包括fromIndex）到toIndex（不包括toIndex）
* 该方法不会改变readerIndex和writerIndex
*
* @return value第一次出现的下表，没找到返回-1
*/
int32_t indexOf(int32_t fromIndex, int32_t toIndex, char value) const;
/**
* 设置readerIndex和writerIndex，如果buffer内无数据，则无效;
* 如果readerIndex超出了buffer内数据的长度，则readerIndex = buffer.length() - 1;
* 如果writerIndex超出了buffer内数据的长度，则writerIndex = buffer.length()
*/
ByteBuf setIndex(int32_t readerIndex, int32_t writerIndex);
/**
* 只有当this.writerIndex - this.readerIndex大于0时，返回true
*/
bool isReadable() const;
/**
* 只有当this.writerIndex - this.readerIndex大于size时，返回true
*/
bool isReadable(int32_t size);
/**
* 标记当前的readerIndex，后面可以使用resetReaderIndex()撤回readerIndex到标记位置，初始标记位置为0
*/
ByteBuf &markReaderIndex();
/**
* 标记当前的writerIndex，后面可以使用resetWriterIndex()撤回resetWriterIndex到标记位置，初始标记位置为0
*/
ByteBuf &markWriterIndex();
/**
* 返回readerIndex
*/
int32_t readerIndex() const;
/**
* 设置readerIndex
*/
ByteBuf &readerIndex(int32_t reader_index);
/**
* 重新定位readerIndex到标记的readerIndex位置
*/
ByteBuf &resetReaderIndex();
/**
* 返回writerIndex
*/
int32_t writerIndex() const;
/**
* 设置writerIndex
*/
ByteBuf &writerIndex(int32_t writer_index);
/**
* 重新定位writerIndex到标记的writerIndex位置
*/
ByteBuf &resetWriterIndex();
/**
* 返回当前buffer中的可读的字节数，等同于(this.writerIndex - this.readerIndex)
*/
int32_t readableBytes() const;
/**
* 获取指定下标的字符
* 该方法不会修改readerIndex和writerIndex
*
* @return 如果index超出buffer数据长度，返回0
*/
char getByte(int32_t index) const;
/**
* 从指定的index位置，获取符合条件的字符，该方法不会修改readerIndex和writerIndex
*
* @return 返回实际获取的字符数目
*/
int32_t getBytes(int32_t index, char *dst) const;
int32_t getBytes(int32_t index, char *dst, int32_t length) const;
/**
* 从指定的index位置，获取符合条件的字符，该方法不会修改readerIndex和writerIndex
*/
ByteBuf getBytes(int32_t index) const;
ByteBuf getBytes(int32_t index, int32_t length) const;
ByteBuf getBytes(int32_t index, int32_t dstIndex, int32_t length) const;
/**
* 以下方法分别从index位置读取8/16/32/64位的数据，不会修改readerIndex和writerIndex
*/
int8_t getChar(int32_t index) const;
uint8_t getUnsignedChar(int32_t index) const;
int16_t getShort(int32_t index) const;
int16_t getShortLE(int32_t index) const;
uint16_t getUnsignedShort(int32_t index) const;
uint16_t getUnsignedShortLE(int32_t index) const;
int32_t getInt(int32_t index) const;
int32_t getIntLE(int32_t index) const;
uint32_t getUnsignedInt(int32_t index) const;
uint32_t getUnsignedIntLE(int32_t index) const;
int64_t getLong(int32_t index) const;
int64_t getLongLE(int32_t index) const;
uint64_t getUnsignedLong(int32_t index) const;
uint64_t getUnsignedLongLE(int32_t index) const;
float getFloat(int32_t index) const;
float getFloatLE(int32_t index) const;
double getDouble(int32_t index) const;
double getDoubleLE(int32_t index) const;
/**
* 以下方法分别从readerIndex位置读取8/16/32/64位的数据，readerIndex根据实际读出的位数增加
*/
int8_t readChar();
uint8_t readUnsignedChar();
int16_t readShort();
int16_t readShortLE();
uint16_t readUnsignedShort();
uint16_t readUnsignedShortLE();
int32_t readInt();
int32_t readIntLE();
uint32_t readUnsignedInt();
uint32_t readUnsignedIntLE();
int64_t readLong();
int64_t readLongLE();
uint64_t readUnsignedLong();
uint64_t readUnsignedLongLE();
ByteBuf readBytes(int32_t length);
double readDouble();
double readDoubleLE();
/**
* readerIndex增加指定长度
*/
ByteBuf &skipBytes(int32_t length);
/**
* 以下方法在index位置写入8/16/32/64位的数据，如果index超出现有数据范围，则追加，否则插入，不会修改readerIndex和writerIndex
*/
ByteBuf &setChar(int32_t index, int8_t value);
ByteBuf &setUnsignedChar(int32_t index, uint8_t value);
ByteBuf &setShort(int32_t index, int16_t value);
ByteBuf &setShortLE(int32_t index, int16_t value);
ByteBuf &setUnsignedShort(int32_t index, uint16_t value);
ByteBuf &setUnsignedShortLE(int32_t index, uint16_t value);
ByteBuf &setInt(int32_t index, int32_t value);
ByteBuf &setIntLE(int32_t index, int32_t value);
ByteBuf &setUnsignedInt(int32_t index, uint32_t value);
ByteBuf &setUnsignedIntLE(int32_t index, uint32_t value);
ByteBuf &setLong(int32_t index, int64_t value);
ByteBuf &setLongLE(int32_t index, int64_t value);
ByteBuf &setUnsignedLong(int32_t index, uint64_t value);
ByteBuf &setUnsignedLongLE(int32_t index, uint64_t value);
ByteBuf &setBytes(int32_t index, const ByteBuf &buf);
ByteBuf &setBytes(int32_t index, const char *data, int32_t size);
/**
* 从index位置填充指定长度的0，index超出现有数据，则追加，否则，插入，readerIndex和writerIndex不会改变
*/
ByteBuf &setZero(int32_t index, int32_t length);
/**
* 以下方法会在writerIndex位置写入8/16/32/64位数据，若writerIndex超出现有数据范围，则追加并调整，否则插入，writerIndex根据实际写入的情况调整位置
*/
ByteBuf &writeChar(int8_t value);
ByteBuf &writeUnsignedChar(uint8_t value);
ByteBuf &writeShort(int16_t value);
ByteBuf &writeShortLE(int16_t value);
ByteBuf &writeUnsignedShort(uint16_t value);
ByteBuf &writeUnsignedShortLE(uint16_t value);
ByteBuf &writeInt(int32_t value);
ByteBuf &writeIntLE(int32_t value);
ByteBuf &writeUnsignedInt(uint32_t value);
ByteBuf &writeUnsignedIntLE(uint32_t value);
ByteBuf &writeLong(int64_t value);
ByteBuf &writeLongLE(int64_t value);
ByteBuf &writeUnsignedLong(uint64_t value);
ByteBuf &writeUnsignedLongLE(uint64_t value);
ByteBuf &writeBytes(const ByteBuf &buf);
ByteBuf &writeBytes(const char *data, int32_t size);
/**
* 从writerIndex位置填充指定长度的0，writerIndex超出现有数据，则追加并调整，否则插入，writerIndex根据实际写入的情况调整位置
*/
ByteBuf &writeZero(int32_t length);
private:
std::unique_ptr<ByteBufData> d;
};
}
#endif//SH_BYTE_BUF_H
ByteBuf.cpp
#include "ByteBuf.h"
namespace
{
#define INT8_BIT sizeof(int8_t)
#define INT16_BIT sizeof(int16_t)
#define INT32_BIT sizeof(int32_t)
#define INT64_BIT sizeof(int64_t)
#define FLOAT_BIT sizeof(float)
#define DOUBLE_BIT sizeof(double)
}
class ByteBufData
{
public:
ByteBufData()
: readerIndex(0), writerIndex(0), markedReaderIndex(0), markedWriterIndex(0)
{}
private:
friend class sh::ByteBuf;
std::string originData;
int32_t readerIndex;
int32_t writerIndex;
int32_t markedReaderIndex;
int32_t markedWriterIndex;
private:
template<class T>
T getT(int32_t index, uint8_t max_bit) const
{
if (originData.length() - index < max_bit)
{
return 0;
}
T value = 0;
for (uint8_t delta = 0; delta < max_bit; delta++)
{
value += (originData.at(delta + index) & 0xff) << (8 * (max_bit - delta - 1));
}
return value;
}
template<class T>
T getTLE(int32_t index, uint8_t max_bit) const
{
if (originData.length() - index < max_bit)
{
return 0;
}
T value = 0;
for (uint8_t delta = 0; delta < max_bit; delta++)
{
value += (originData.at(delta + index) & 0xff) << (8 * delta);
}
return value;
}
template<class T>
T readT(uint8_t max_bit)
{
if (originData.length() - readerIndex < max_bit)
{
return 0;
}
T value = 0;
for (uint8_t delta = 0; delta < max_bit; delta++)
{
value += (originData.at(delta + readerIndex) & 0xff) << (8 * (max_bit - delta - 1));
}
readerIndex += max_bit;
return value;
}
template<class T>
T readTLE(uint8_t max_bit)
{
if (originData.length() - readerIndex < max_bit)
{
return 0;
}
T value = 0;
for (uint8_t delta = 0; delta < max_bit; delta++)
{
value += (originData.at(delta + readerIndex) & 0xff) << (8 * delta);
}
readerIndex += max_bit;
return value;
}
template<class T>
void setT(int32_t index, T value)
{
setData(index, toBinary(value));
}
template<class T>
void setTLE(int32_t index, T value)
{
setData(index, toBinaryLE(value));
}
void setData(int32_t index, const std::string &data)
{
if (index > originData.length())
{
originData.append(data);
}
else
{
originData.insert(index, data);
}
}
template<class T>
void writeT(T value)
{
writeData(toBinary(value));
}
template<class T>
void writeTLE(T value)
{
writeData(toBinaryLE(value));
}
void writeData(const std::string &data)
{
if (writerIndex > originData.length())
{
originData.append(data);
writerIndex = (int32_t) originData.length();
}
else
{
originData.insert(writerIndex, data);
writerIndex += (int32_t) data.length();
}
}
template<class T>
std::string toBinary(T value)
{
std::string result;
int8_t max_bit = sizeof(T);
for (uint8_t index = 0; index < max_bit; index++)
{
result.push_back(value >> (8 * (max_bit - index - 1)) & 0xff);
}
return result;
}
template<class T>
std::string toBinaryLE(T value)
{
std::string result;
int8_t max_bit = sizeof(T);
for (uint8_t index = 0; index < max_bit; index++)
{
result.push_back(value >> (8 * index) & 0xff);
}
return result;
}
};
sh::ByteBuf::ByteBuf()
{
d = std::unique_ptr<::ByteBufData>(new ByteBufData());
}
sh::ByteBuf::ByteBuf(const char *data, int32_t size)
{
d = std::unique_ptr<::ByteBufData>(new ByteBufData());
d->originData.append(data, size);
d->writerIndex += size;
}
sh::ByteBuf::ByteBuf(const std::string &data)
{
d = std::unique_ptr<::ByteBufData>(new ByteBufData());
d->originData.append(data);
d->writerIndex += data.length();
}
sh::ByteBuf::ByteBuf(int32_t size, char ch)
{
d = std::unique_ptr<::ByteBufData>(new ByteBufData());
d->originData.append(size, ch);
d->writerIndex += size;
}
sh::ByteBuf::ByteBuf(const sh::ByteBuf &other)
{
d = std::unique_ptr<::ByteBufData>(new ByteBufData());
d->originData.append(other.d->originData);
d->readerIndex = other.d->readerIndex;
d->writerIndex = other.d->writerIndex;
d->markedReaderIndex = other.d->markedReaderIndex;
d->markedWriterIndex = other.d->markedWriterIndex;
}
sh::ByteBuf::~ByteBuf() = default;
sh::ByteBuf &sh::ByteBuf::operator=(const sh::ByteBuf &other)
{
if (&other != this)
{
d->originData.append(other.d->originData);
d->readerIndex = other.d->readerIndex;
d->writerIndex = other.d->writerIndex;
d->markedReaderIndex = other.d->markedReaderIndex;
d->markedWriterIndex = other.d->markedWriterIndex;
}
return *this;
}
std::string sh::ByteBuf::toHexString(Case type, const std::string &fill_str) const
{
std::string result;
for (char ch: d->originData)
{
if (Case::Lower == type)
{
result.push_back(toHexLower(ch >> 4));
result.push_back(toHexLower(ch & 0xF));
}
else
{
result.push_back(toHexUpper(ch >> 4));
result.push_back(toHexUpper(ch & 0xF));
}
result.append(fill_str);
}
return result;
}
const char *sh::ByteBuf::data() const noexcept
{
return d->originData.data();
}
int32_t sh::ByteBuf::bytesBefore(char value)
{
for (int32_t index = d->readerIndex; index < d->writerIndex; index++)
{
if (d->originData.at(index) == value)
{
return index - d->readerIndex;
}
}
return -1;
}
int32_t sh::ByteBuf::bytesBefore(int32_t length, char value)
{
return bytesBefore(d->readerIndex, length, value);
}
int32_t sh::ByteBuf::bytesBefore(int32_t index, int32_t length, char value)
{
bool last_ok;
int32_t second_index;
for (; index < d->writerIndex - length; index++)
{
//找到第一个符合 && 剩余的长度足够
if (d->originData.at(index) == value && (index + length) < d->writerIndex)
{
last_ok = true;
//从后一个开始检查length-1个字符
for (second_index = index + 1; second_index < (index + length); second_index++)
{
if (d->originData.at(second_index) != value)
{
last_ok = false;
break;
}
}
if (last_ok)
{
return index - d->readerIndex;
}
}
}
return -1;
}
int32_t sh::ByteBuf::capacity() const
{
return (int32_t) d->originData.capacity();
}
sh::ByteBuf &sh::ByteBuf::capacity(int32_t new_capacity)
{
d->originData.reserve(new_capacity);
return *this;
}
sh::ByteBuf &sh::ByteBuf::clear()
{
d->readerIndex = 0;
d->writerIndex = 0;
return *this;
}
int32_t sh::ByteBuf::compareTo(const sh::ByteBuf &buffer) const
{
return d->originData.compare(buffer.d->originData);
}
sh::ByteBuf sh::ByteBuf::copy() const
{
return sh::ByteBuf(d->originData);
}
sh::ByteBuf sh::ByteBuf::copy(int32_t index, int32_t length) const
{
return sh::ByteBuf(d->originData.substr(index, length));
}
sh::ByteBuf &sh::ByteBuf::discardReadBytes()
{
d->originData = d->originData.substr(d->readerIndex + 1);
d->readerIndex = 0;
d->writerIndex = 0;
return *this;
}
int32_t sh::ByteBuf::indexOf(int32_t fromIndex, int32_t toIndex, char value) const
{
for (int32_t index = fromIndex; index < d->originData.length() && index < toIndex; index++)
{
if (d->originData.at(index) == value)
{
return index;
}
}
return -1;
}
sh::ByteBuf sh::ByteBuf::setIndex(int32_t readerIndex, int32_t writerIndex)
{
if (d->originData.empty())
{
return *this;
}
d->readerIndex = readerIndex;
d->writerIndex = writerIndex;
if (d->readerIndex >= d->originData.length())
{
d->readerIndex = (int32_t) d->originData.length() - 1;
}
if (d->writerIndex > d->originData.length())
{
d->writerIndex = (int32_t) d->originData.length();
}
return *this;
}
bool sh::ByteBuf::isReadable() const
{
return (d->writerIndex - d->readerIndex) > 0;
}
bool sh::ByteBuf::isReadable(int32_t size)
{
return (d->writerIndex - d->readerIndex) >= size;
}
sh::ByteBuf &sh::ByteBuf::markReaderIndex()
{
d->markedReaderIndex = d->readerIndex;
return *this;
}
sh::ByteBuf &sh::ByteBuf::markWriterIndex()
{
d->markedWriterIndex = d->writerIndex;
return *this;
}
int32_t sh::ByteBuf::readerIndex() const
{
return d->readerIndex;
}
sh::ByteBuf &sh::ByteBuf::readerIndex(int32_t reader_index)
{
if (reader_index <= d->writerIndex)
{
d->readerIndex = reader_index;
}
return *this;
}
sh::ByteBuf &sh::ByteBuf::resetReaderIndex()
{
d->readerIndex = d->markedReaderIndex;
return *this;
}
int32_t sh::ByteBuf::writerIndex() const
{
return d->writerIndex;
}
sh::ByteBuf &sh::ByteBuf::writerIndex(int32_t writer_index)
{
if (writer_index < d->originData.length())
{
d->writerIndex = writer_index;
}
return *this;
}
sh::ByteBuf &sh::ByteBuf::resetWriterIndex()
{
d->writerIndex = d->markedWriterIndex;
return *this;
}
int32_t sh::ByteBuf::readableBytes() const
{
return d->writerIndex - d->readerIndex;
}
char sh::ByteBuf::getByte(int32_t index) const
{
if (index >= d->originData.length())
{
return 0;
}
return d->originData.at(index);
}
int32_t sh::ByteBuf::getBytes(int32_t index, char *dst) const
{
if (index >= d->originData.length())
{
return 0;
}
std::string res = d->originData.substr(index);
*dst = *res.data();
return (int32_t) res.length();
}
int32_t sh::ByteBuf::getBytes(int32_t index, char *dst, int32_t length) const
{
if (index >= d->originData.length())
{
return 0;
}
std::string res = d->originData.substr(index, length);
*dst = *res.data();
return (int32_t) res.length();
}
sh::ByteBuf sh::ByteBuf::getBytes(int32_t index) const
{
if (index >= d->originData.length())
{
return sh::ByteBuf();
}
std::string res = d->originData.substr(index);
return sh::ByteBuf(res);
}
sh::ByteBuf sh::ByteBuf::getBytes(int32_t index, int32_t length) const
{
if (index >= d->originData.length())
{
return sh::ByteBuf();
}
std::string res = d->originData.substr(index, length);
return sh::ByteBuf(res);
}
sh::ByteBuf sh::ByteBuf::getBytes(int32_t index, int32_t dstIndex, int32_t length) const
{
if (index >= d->originData.length())
{
return sh::ByteBuf();
}
sh::ByteBuf data(dstIndex, 0);
std::string res = d->originData.substr(index, length);
data.writeBytes(res.data(), (int32_t) res.length());
return data;
}
int8_t sh::ByteBuf::getChar(int32_t index) const
{
if (index >= d->originData.length())
{
return 0;
}
return d->originData.at(index);
}
uint8_t sh::ByteBuf::getUnsignedChar(int32_t index) const
{
return getChar(index);
}
int16_t sh::ByteBuf::getShort(int32_t index) const
{
return d->getT<int16_t>(index, INT16_BIT);
}
int16_t sh::ByteBuf::getShortLE(int32_t index) const
{
return d->getTLE<int16_t>(index, INT16_BIT);
}
uint16_t sh::ByteBuf::getUnsignedShort(int32_t index) const
{
return d->getT<int16_t>(index, INT16_BIT);
}
uint16_t sh::ByteBuf::getUnsignedShortLE(int32_t index) const
{
return d->getTLE<int16_t>(index, INT16_BIT);
}
int32_t sh::ByteBuf::getInt(int32_t index) const
{
return d->getT<int32_t>(index, INT32_BIT);
}
int32_t sh::ByteBuf::getIntLE(int32_t index) const
{
return d->getTLE<int32_t>(index, INT32_BIT);
}
uint32_t sh::ByteBuf::getUnsignedInt(int32_t index) const
{
return d->getT<int32_t>(index, INT32_BIT);
}
uint32_t sh::ByteBuf::getUnsignedIntLE(int32_t index) const
{
return d->getTLE<int32_t>(index, INT32_BIT);
}
int64_t sh::ByteBuf::getLong(int32_t index) const
{
return d->getT<int64_t>(index, INT64_BIT);
}
int64_t sh::ByteBuf::getLongLE(int32_t index) const
{
return d->getTLE<int64_t>(index, INT64_BIT);
}
uint64_t sh::ByteBuf::getUnsignedLong(int32_t index) const
{
return d->getT<int64_t>(index, INT64_BIT);
}
uint64_t sh::ByteBuf::getUnsignedLongLE(int32_t index) const
{
return d->getTLE<int64_t>(index, INT64_BIT);
}
float sh::ByteBuf::getFloat(int32_t index) const
{
float result = 0.00;
if (d->originData.length() - index < FLOAT_BIT)
{
return 0.00;
}
char *p = (char *) &result;
for (; index < index + FLOAT_BIT; index++)
{
*(p + index) = d->originData.at(index);
}
return result;
}
float sh::ByteBuf::getFloatLE(int32_t index) const
{
float result = 0.00;
if (d->originData.length() - index < FLOAT_BIT)
{
return 0.00;
}
char *p = (char *) &result;
for (; index < index + FLOAT_BIT; index++)
{
*(p + index) = d->originData.at(FLOAT_BIT - index - 1);
}
return result;
}
double sh::ByteBuf::getDouble(int32_t index) const
{
double result = 0.00;
if (d->originData.length() - index < DOUBLE_BIT)
{
return 0.00;
}
char *p = (char *) &result;
for (; index < index + DOUBLE_BIT; index++)
{
*(p + index) = d->originData.at(index);
}
return result;
}
double sh::ByteBuf::getDoubleLE(int32_t index) const
{
double result = 0.00;
if (d->originData.length() - index < DOUBLE_BIT)
{
return 0.00;
}
char *p = (char *) &result;
for (; index < index + DOUBLE_BIT; index++)
{
*(p + index) = d->originData.at(DOUBLE_BIT - index - 1);
}
return result;
}
int8_t sh::ByteBuf::readChar()
{
if (d->originData.length() - d->readerIndex < INT8_BIT)
{
return 0;
}
return d->originData.at(d->readerIndex++);
}
uint8_t sh::ByteBuf::readUnsignedChar()
{
return readChar();
}
int16_t sh::ByteBuf::readShort()
{
return d->readT<int16_t>(INT16_BIT);
}
int16_t sh::ByteBuf::readShortLE()
{
return d->readTLE<int16_t>(INT16_BIT);
}
uint16_t sh::ByteBuf::readUnsignedShort()
{
return d->readT<int16_t>(INT16_BIT);
}
uint16_t sh::ByteBuf::readUnsignedShortLE()
{
return d->readTLE<int16_t>(INT16_BIT);
}
int32_t sh::ByteBuf::readInt()
{
return d->readT<int32_t>(INT32_BIT);
}
int32_t sh::ByteBuf::readIntLE()
{
return d->readTLE<int32_t>(INT32_BIT);
}
uint32_t sh::ByteBuf::readUnsignedInt()
{
return d->readT<int32_t>(INT32_BIT);
}
uint32_t sh::ByteBuf::readUnsignedIntLE()
{
return d->readTLE<int32_t>(INT32_BIT);
}
int64_t sh::ByteBuf::readLong()
{
return d->readT<int64_t>(INT64_BIT);
}
int64_t sh::ByteBuf::readLongLE()
{
return d->readTLE<int64_t>(INT64_BIT);
}
uint64_t sh::ByteBuf::readUnsignedLong()
{
return d->readT<int64_t>(INT64_BIT);
}
uint64_t sh::ByteBuf::readUnsignedLongLE()
{
return d->readTLE<int64_t>(INT64_BIT);
}
sh::ByteBuf sh::ByteBuf::readBytes(int32_t length)
{
std::string data = d->originData.substr(d->readerIndex, length);
d->readerIndex += (int32_t) data.length();
return sh::ByteBuf(data);
}
double sh::ByteBuf::readDouble()
{
double result = 0.00;
if (d->originData.length() - d->readerIndex < DOUBLE_BIT)
{
return 0.00;
}
char *p = (char *) &result;
for (; d->readerIndex < d->readerIndex + DOUBLE_BIT; d->readerIndex++)
{
*(p + d->readerIndex) = d->originData.at(d->readerIndex);
}
return result;
}
double sh::ByteBuf::readDoubleLE()
{
double result = 0.00;
if (d->originData.length() - d->readerIndex < DOUBLE_BIT)
{
return 0.00;
}
char *p = (char *) &result;
for (; d->readerIndex < d->readerIndex + DOUBLE_BIT; d->readerIndex++)
{
*(p + d->readerIndex) = d->originData.at(DOUBLE_BIT - d->readerIndex - 1);
}
return result;
}
sh::ByteBuf &sh::ByteBuf::skipBytes(int32_t length)
{
d->readerIndex += length;
if (d->readerIndex > d->originData.length())
{
d->readerIndex = (int32_t) d->originData.length();
}
return *this;
}
sh::ByteBuf &sh::ByteBuf::setChar(int32_t index, int8_t value)
{
d->setT(index, value);
return *this;
}
sh::ByteBuf &sh::ByteBuf::setUnsignedChar(int32_t index, uint8_t value)
{
d->setT(index, value);
return *this;
}
sh::ByteBuf &sh::ByteBuf::setShort(int32_t index, int16_t value)
{
d->setT(index, value);
return *this;
}
sh::ByteBuf &sh::ByteBuf::setShortLE(int32_t index, int16_t value)
{
d->setTLE(index, value);
return *this;
}
sh::ByteBuf &sh::ByteBuf::setUnsignedShort(int32_t index, uint16_t value)
{
d->setT(index, value);
return *this;
}
sh::ByteBuf &sh::ByteBuf::setUnsignedShortLE(int32_t index, uint16_t value)
{
d->setTLE(index, value);
return *this;
}
sh::ByteBuf &sh::ByteBuf::setInt(int32_t index, int32_t value)
{
d->setT(index, value);
return *this;
}
sh::ByteBuf &sh::ByteBuf::setIntLE(int32_t index, int32_t value)
{
d->setTLE(index, value);
return *this;
}
sh::ByteBuf &sh::ByteBuf::setUnsignedInt(int32_t index, uint32_t value)
{
d->setT(index, value);
return *this;
}
sh::ByteBuf &sh::ByteBuf::setUnsignedIntLE(int32_t index, uint32_t value)
{
d->setTLE(index, value);
return *this;
}
sh::ByteBuf &sh::ByteBuf::setLong(int32_t index, int64_t value)
{
d->setT(index, value);
return *this;
}
sh::ByteBuf &sh::ByteBuf::setLongLE(int32_t index, int64_t value)
{
d->setTLE(index, value);
return *this;
}
sh::ByteBuf &sh::ByteBuf::setUnsignedLong(int32_t index, uint64_t value)
{
d->setT(index, value);
return *this;
}
sh::ByteBuf &sh::ByteBuf::setUnsignedLongLE(int32_t index, uint64_t value)
{
d->setTLE(index, value);
return *this;
}
sh::ByteBuf &sh::ByteBuf::setBytes(int32_t index, const ByteBuf &buf)
{
d->setData(index, buf.data());
return *this;
}
sh::ByteBuf &sh::ByteBuf::setBytes(int32_t index, const char *data, int32_t size)
{
d->setData(index, std::string(data, size));
return *this;
}
sh::ByteBuf &sh::ByteBuf::setZero(int32_t index, int32_t length)
{
d->setData(index, std::string(length, 0));
return *this;
}
sh::ByteBuf &sh::ByteBuf::writeChar(int8_t value)
{
d->writeT(value);
return *this;
}
sh::ByteBuf &sh::ByteBuf::writeUnsignedChar(uint8_t value)
{
d->writeT(value);
return *this;
}
sh::ByteBuf &sh::ByteBuf::writeShort(int16_t value)
{
d->writeT(value);
return *this;
}
sh::ByteBuf &sh::ByteBuf::writeShortLE(int16_t value)
{
d->writeTLE(value);
return *this;
}
sh::ByteBuf &sh::ByteBuf::writeUnsignedShort(uint16_t value)
{
d->writeT(value);
return *this;
}
sh::ByteBuf &sh::ByteBuf::writeUnsignedShortLE(uint16_t value)
{
d->writeTLE(value);
return *this;
}
sh::ByteBuf &sh::ByteBuf::writeInt(int32_t value)
{
d->writeT(value);
return *this;
}
sh::ByteBuf &sh::ByteBuf::writeIntLE(int32_t value)
{
d->writeTLE(value);
return *this;
}
sh::ByteBuf &sh::ByteBuf::writeUnsignedInt(uint32_t value)
{
d->writeT(value);
return *this;
}
sh::ByteBuf &sh::ByteBuf::writeUnsignedIntLE(uint32_t value)
{
d->writeTLE(value);
return *this;
}
sh::ByteBuf &sh::ByteBuf::writeLong(int64_t value)
{
d->writeT(value);
return *this;
}
sh::ByteBuf &sh::ByteBuf::writeLongLE(int64_t value)
{
d->writeTLE(value);
return *this;
}
sh::ByteBuf &sh::ByteBuf::writeUnsignedLong(uint64_t value)
{
d->writeT(value);
return *this;
}
sh::ByteBuf &sh::ByteBuf::writeUnsignedLongLE(uint64_t value)
{
d->writeTLE(value);
return *this;
}
sh::ByteBuf &sh::ByteBuf::writeBytes(const ByteBuf &buf)
{
d->writeData(buf.data());
return *this;
}
sh::ByteBuf &sh::ByteBuf::writeBytes(const char *data, int32_t size)
{
d->writeData(std::string(data, size));
return *this;
}
sh::ByteBuf &sh::ByteBuf::writeZero(int32_t length)
{
d->writeData(std::string(length, 0));
return *this;
}
char sh::ByteBuf::toHexLower(uint32_t value) noexcept
{
return "0123456789abcdef"[value & 0xF];
}
char sh::ByteBuf::toHexUpper(uint32_t value) noexcept
{
return "0123456789ABCDEF"[value & 0xF];
}
int32_t sh::ByteBuf::fromHex(uint32_t c) noexcept
{
return ((c >= '0') && (c <= '9')) ? int32_t(c - '0') :
((c >= 'A') && (c <= 'F')) ? int32_t(c - 'A' + 10) :
((c >= 'a') && (c <= 'f')) ? int32_t(c - 'a' + 10) :
/* otherwise */ -1;
}
sh::ByteBuf sh::ByteBuf::fromHex(const std::string &hexEncoded) noexcept
{
sh::ByteBuf data;
char ch = 0x00;
for (int32_t index = 0; index < hexEncoded.length() - 1; index++)
{
ch |= (char) fromHex(hexEncoded.at(index++)) << 4;
ch |= (char) fromHex(hexEncoded.at(index));
data.writeChar(ch);
ch = 0x00;
}
return data;
}
