记录一下封装的ByteBuffer

MyByteBuffer.h

#include "cocos2d.h"
#include 
//////////////////////////////////////////////////////////////////////////
///  bytebuffer 
//////////////////////////////////////////////////////////////////////////
class MyByteBuffer
{
public:
    MyByteBuffer();
    ~MyByteBuffer();
    MyByteBuffer(const unsigned char* data, int dataLen);
public:
    // 获得缓冲区数据长度
    int getBufferDataLength();
    // 获得游标位置
    int getCursorPosition();
    void PushByte(char by);
    void PushByteArray(const unsigned char* data, int dataLen);
    void PushInt(int num);
    void PushLong(long Num);
    void PushString(const std::string& str);
    void PushPoint(cocos2d::Vec2& point);
    void PushFloat(float value);
    char PopByte();
    int PopInt();
    long PopLong();
    float PopFloat();
    const unsigned char* PopByteArray(int Length);
    std::string PopString();
    cocos2d::Vec2 PopPoint();
    unsigned char* ToByteArray();
private:
    /// 获取新的缓冲区
    unsigned char* initNewBuffer(int buffLen);
    /// 检测缓冲区是否足够
    void checkBuffSize(int addDataLen);
private:
    //固定长度的中间数组
    unsigned char* temp_byte_array;
    //当前数据长度
    int current_data_length;
    //当前游标位置
    int cursor_position;
    // 缓冲区大小
    int bufferSize;
};

MyByteBuffer.cpp

#include "MyByteBuffer.h"
#include 

const int BUFFER_BLOCK = 1024; // 缓冲块

MyByteBuffer::MyByteBuffer()
{
    this->temp_byte_array = initNewBuffer(BUFFER_BLOCK);
    this->current_data_length = 0;
    this->cursor_position = 0;
    this->bufferSize = BUFFER_BLOCK;
}

MyByteBuffer::MyByteBuffer(const unsigned char* data, int dataLen)
{
    this->temp_byte_array = initNewBuffer(BUFFER_BLOCK);
    this->current_data_length = 0;
    this->cursor_position = 0;
    this->bufferSize = BUFFER_BLOCK;

    PushByteArray(data, dataLen);
}

MyByteBuffer::~MyByteBuffer()
{
    delete[] this->temp_byte_array;
}

unsigned char* MyByteBuffer::initNewBuffer(int buffLen)
{
    unsigned char* buff = new unsigned char[buffLen];
    memset(buff, 0x00, buffLen);
    return buff;
}

void MyByteBuffer::checkBuffSize(int addDataLen)
{
    int needLen = current_data_length + addDataLen;
    int newBuffSize = this->bufferSize;
    if (needLen < newBuffSize)
    {
        // 数据存储区域足够
        return;
    }
    // 存储区不足，重新分配
    while (newBuffSize <= needLen)
    {
        newBuffSize += BUFFER_BLOCK;
    }
    unsigned char* tmparr = initNewBuffer(newBuffSize);
    this->bufferSize = newBuffSize;
    // 拷贝资源
    memcpy(tmparr, this->temp_byte_array, current_data_length);
    // 释放旧内存
    delete[] this->temp_byte_array;
    this->temp_byte_array = tmparr;
}

int MyByteBuffer::getBufferDataLength()
{
    return current_data_length;
}

int MyByteBuffer::getCursorPosition()
{
    return cursor_position;
}

void MyByteBuffer::PushByte(char by)
{
    checkBuffSize(1);
    temp_byte_array[current_data_length++] = by;
}

void MyByteBuffer::PushByteArray(const unsigned char* data, int dataLen)
{
    checkBuffSize(dataLen);
    //把自己CopyTo目标数组
    memcpy(temp_byte_array + current_data_length, data, dataLen);
    //调整长度
    current_data_length += dataLen;
}

void MyByteBuffer::PushInt(int Num)
{
    checkBuffSize(4);
    temp_byte_array[current_data_length++] = (char)(((Num & 0xff000000) >> 24) & 0xff);
    temp_byte_array[current_data_length++] = (char)(((Num & 0x00ff0000) >> 16) & 0xff);
    temp_byte_array[current_data_length++] = (char)(((Num & 0x0000ff00) >> 8) & 0xff);
    temp_byte_array[current_data_length++] = (char)((Num & 0x000000ff) & 0xff);
}

void MyByteBuffer::PushLong(long Num)
{
    checkBuffSize(4);
    temp_byte_array[current_data_length++] = (char)(((Num & 0xff000000) >> 24) & 0xff);
    temp_byte_array[current_data_length++] = (char)(((Num & 0x00ff0000) >> 16) & 0xff);
    temp_byte_array[current_data_length++] = (char)(((Num & 0x0000ff00) >> 8) & 0xff);
    temp_byte_array[current_data_length++] = (char)((Num & 0x000000ff) & 0xff);
}

/// 

/// 从ByteBuffer的当前位置弹出一个Byte,并提升一位
/// 
/// 1字节Byte
char MyByteBuffer::PopByte()
{
    char ret = temp_byte_array[cursor_position++];
    return ret;
}

/// 

/// 从ByteBuffer的当前位置弹出一个uint,并提升4位
/// 
/// 4字节UInt
int MyByteBuffer::PopInt()
{
    if (cursor_position + 3 >= current_data_length)
        return 0;
    int ret = (int)(temp_byte_array[cursor_position] << 24 | temp_byte_array[cursor_position + 1] << 16 | temp_byte_array[cursor_position + 2] << 8 | temp_byte_array[cursor_position + 3]);
    cursor_position += 4;
    return ret;
}

/// 

/// 从ByteBuffer的当前位置弹出一个long,并提升4位
/// 
/// 4字节Long
long MyByteBuffer::PopLong()
{
    if (cursor_position + 3 >= current_data_length)
        return 0;
    long ret = (long)(temp_byte_array[cursor_position] << 24 | temp_byte_array[cursor_position + 1] << 16 | temp_byte_array[cursor_position + 2] << 8 | temp_byte_array[cursor_position + 3]);
    cursor_position += 4;
    return ret;
}

/// 

/// 从ByteBuffer的当前位置弹出长度为Length的Byte数组,提升Length位
/// 
/// 数组长度
/// Length长度的byte数组
const unsigned char* MyByteBuffer::PopByteArray(int Length)
{
    //溢出
    if (cursor_position + Length > current_data_length)
    {
        return nullptr;
    }
    unsigned char* ret = temp_byte_array + cursor_position;
    cursor_position += Length;
    return ret;
}


/// 

/// 放入字符串
/// 
/// 
void MyByteBuffer::PushString(const std::string& str)
{
    PushInt(str.length());
    PushByteArray((const unsigned char*)str.c_str(), str.length());
}

/// 

/// 取出字符串
/// 
/// 
std::string MyByteBuffer::PopString()
{
    int strlen = PopInt();
    if (strlen <= 0)
    {
        return "";
    }
    const char* bytes = (const char*)PopByteArray(strlen);
    std::string ret = std::string(bytes, 0, strlen);
    return ret;
}

void MyByteBuffer::PushPoint(cocos2d::Vec2& point)
{
    PushInt(point.x);
    PushInt(point.y);
}

cocos2d::Vec2 MyByteBuffer::PopPoint()
{
    int x = PopInt();
    int y = PopInt();
    return cocos2d::Vec2(x, y);
}

union FloatBinUnion
{
    float floatvalue;
    unsigned char bitvalue[4];
    int intvalue;
};


void MyByteBuffer::PushFloat(float value)
{
    FloatBinUnion bin;
    bin.floatvalue = value;
    PushInt(bin.intvalue);
}

float MyByteBuffer::PopFloat()
{
    FloatBinUnion bin;
    bin.intvalue = PopInt();
    return bin.floatvalue;
}

unsigned char* MyByteBuffer::ToByteArray()
{
    //分配大小
    unsigned char* RETURN_ARRAY = new unsigned char[current_data_length];
    //调整指针
    memcpy(RETURN_ARRAY, temp_byte_array, current_data_length);
    return RETURN_ARRAY;
}