tiennm99/zfoo
1
0
Fork 0
mirror of https://github.com/tiennm99/zfoo.git synced 2026-05-20 10:25:19 +00:00
Code Issues Packages Projects Releases Wiki Activity

ref[protocol]: cpp protocol

Browse Source
This commit is contained in:
godotg
2024-07-15 16:47:13 +08:00
parent bff769df89
commit 49b80da60e
3 changed files with 67 additions and 66 deletions
Download Patch File Download Diff File Expand all files Collapse all files
protocol/src/main/java/com/zfoo/protocol/serializer/cpp/CodeGenerateCpp.java
+1 -1
View File
@@ -297,7 +297,7 @@ public class CodeGenerateCpp implements ICodeGenerate {
var fieldRegistrations = registration.getFieldRegistrations();
var cppBuilder = new StringBuilder();
if (registration.isCompatible()) {
cppBuilder.append("auto beforeWriteIndex = buffer.getWriterOffset();").append(LS);
cppBuilder.append("auto beforeWriteIndex = buffer.getWriteOffset();").append(LS);
cppBuilder.append(StringUtils.format("buffer.writeInt({});", registration.getPredictionLength())).append(LS);
} else {
cppBuilder.append("buffer.writeInt(-1);").append(LS);
protocol/src/main/resources/cpp/ByteBuffer.h
+64 -63
View File
@@ -55,20 +55,20 @@ namespace zfoo {
class ByteBuffer {
private:
int8_t *m_buffer;
int32_t m_max_capacity;
int32_t m_writerOffset;
int32_t m_readerOffset;
int8_t *buffer;
int32_t max_capacity;
int32_t writeOffset;
int32_t readerOffset;
public:
ByteBuffer(int32_t capacity = DEFAULT_BUFFER_SIZE) : m_max_capacity(capacity) {
m_buffer = (int8_t *) calloc(m_max_capacity, sizeof(int8_t));
ByteBuffer(int32_t capacity = DEFAULT_BUFFER_SIZE) : max_capacity(capacity) {
buffer = (int8_t *) calloc(max_capacity, sizeof(int8_t));
clear();
}
~ByteBuffer() {
free(m_buffer);
m_buffer = nullptr;
free(buffer);
buffer = nullptr;
}
@@ -77,19 +77,19 @@ namespace zfoo {
ByteBuffer &operator=(const ByteBuffer &buffer) = delete;
void adjustPadding(int32_t predictionLength, int32_t beforeWriteIndex) {
int32_t currentWriteIndex = getWriterOffset();
int32_t currentWriteIndex = getWriteOffset();
int32_t predictionCount = writeIntCount(predictionLength);
int32_t length = currentWriteIndex - beforeWriteIndex - predictionCount;
int32_t lengthCount = writeIntCount(length);
int32_t padding = lengthCount - predictionCount;
if (padding == 0) {
setWriterOffset(beforeWriteIndex);
setWriteOffset(beforeWriteIndex);
writeInt(length);
setWriterOffset(currentWriteIndex);
setWriteOffset(currentWriteIndex);
} else {
int8_t *targetPtr = (int8_t *) calloc(length, sizeof(int8_t));
memcpy(targetPtr, &m_buffer[currentWriteIndex - length], length);
setWriterOffset(beforeWriteIndex);
memcpy(targetPtr, &buffer[currentWriteIndex - length], length);
setWriteOffset(beforeWriteIndex);
writeInt(length);
writeBytes(targetPtr, length);
free(targetPtr);
@@ -97,108 +97,108 @@ namespace zfoo {
}
bool compatibleRead(int32_t beforeReadIndex, int32_t length) {
return length != -1 && getReaderOffset() < length + beforeReadIndex;
return length != -1 && getReadOffset() < length + beforeReadIndex;
}
void clear() {
m_writerOffset = 0;
m_readerOffset = 0;
writeOffset = 0;
readerOffset = 0;
}
int8_t *getBuffer() {
return m_buffer;
return buffer;
}
int32_t getWriterOffset() const {
return m_writerOffset;
int32_t getWriteOffset() const {
return writeOffset;
}
int32_t getReaderOffset() const {
return m_readerOffset;
int32_t getReadOffset() const {
return readerOffset;
}
void setWriterOffset(int32_t writeIndex) {
if (writeIndex > m_max_capacity) {
void setWriteOffset(int32_t writeIndex) {
if (writeIndex > max_capacity) {
string errorMessage =
"writeIndex[" + std::to_string(writeIndex) + "] out of bounds exception: readerIndex: " +
std::to_string(m_readerOffset) +
", writerIndex: " + std::to_string(m_writerOffset) +
"(expected: 0 <= readerIndex <= writerIndex <= capacity:" + std::to_string(m_max_capacity);
std::to_string(readerOffset) +
", writerIndex: " + std::to_string(writeOffset) +
"(expected: 0 <= readerIndex <= writerIndex <= capacity:" + std::to_string(max_capacity);
throw errorMessage;
}
m_writerOffset = writeIndex;
writeOffset = writeIndex;
}
void setReaderOffset(int32_t readerIndex) {
if (readerIndex > m_writerOffset) {
void setReadOffset(int32_t readerIndex) {
if (readerIndex > writeOffset) {
string errorMessage =
"readIndex[" + std::to_string(readerIndex) + "] out of bounds exception: readerIndex: " +
std::to_string(m_readerOffset) +
", writerIndex: " + std::to_string(m_writerOffset) +
"(expected: 0 <= readerIndex <= writerIndex <= capacity:" + std::to_string(m_max_capacity);
std::to_string(readerOffset) +
", writerIndex: " + std::to_string(writeOffset) +
"(expected: 0 <= readerIndex <= writerIndex <= capacity:" + std::to_string(max_capacity);
throw errorMessage;
}
m_readerOffset = readerIndex;
readerOffset = readerIndex;
}
inline int32_t getCapacity() const {
return m_max_capacity - m_writerOffset;
return max_capacity - writeOffset;
}
inline void ensureCapacity(const int32_t &capacity) {
while (capacity - getCapacity() > 0) {
int32_t newSize = m_max_capacity * 2;
int8_t *pBuf = (int8_t *) realloc(m_buffer, newSize);
int32_t newSize = max_capacity * 2;
int8_t *pBuf = (int8_t *) realloc(buffer, newSize);
if (!pBuf) {
string errorMessage = "relloc failed!";
throw errorMessage;
}
m_buffer = pBuf;
m_max_capacity = newSize;
buffer = pBuf;
max_capacity = newSize;
}
}
inline bool isReadable() {
return m_writerOffset > m_readerOffset;
return writeOffset > readerOffset;
}
inline void writeBool(const bool &value) {
ensureCapacity(1);
int8_t v = value ? 1 : 0;
m_buffer[m_writerOffset++] = v;
buffer[writeOffset++] = v;
}
inline bool readBool() {
int8_t value = m_buffer[m_readerOffset++];
int8_t value = buffer[readerOffset++];
return value == 1;
}
inline void writeByte(const int8_t &value) {
ensureCapacity(1);
m_buffer[m_writerOffset++] = value;
buffer[writeOffset++] = value;
}
inline int8_t readByte() {
return m_buffer[m_readerOffset++];
return buffer[readerOffset++];
}
inline void setByte(const int32_t &index, const int8_t &value) {
m_buffer[index] = value;
buffer[index] = value;
}
inline int8_t getByte(const int32_t &index) {
return m_buffer[index];
return buffer[index];
}
inline void writeBytes(const int8_t *buffer, const int32_t &length) {
inline void writeBytes(const int8_t *buf, const int32_t &length) {
ensureCapacity(length);
memcpy(&m_buffer[m_writerOffset], buffer, length);
m_writerOffset += length;
memcpy(&buffer[writeOffset], buf, length);
writeOffset += length;
}
inline int8_t *readBytes(const int32_t &length) {
int8_t *bytes = &m_buffer[m_readerOffset];
m_readerOffset += length;
int8_t *bytes = &buffer[readerOffset];
readerOffset += length;
return bytes;
}
@@ -222,14 +222,14 @@ namespace zfoo {
return;
}
int32_t writeIndex = m_writerOffset;
int32_t writeIndex = writeOffset;
ensureCapacity(5);
setByte(writeIndex++, (int8_t) (value | 0x80));
uint32_t b = value >> 14;
if (b == 0) {
setByte(writeIndex++, (int8_t) a);
setWriterOffset(writeIndex);
setWriteOffset(writeIndex);
return;
}
@@ -237,7 +237,7 @@ namespace zfoo {
a = value >> 21;
if (a == 0) {
setByte(writeIndex++, (int8_t) b);
setWriterOffset(writeIndex);
setWriteOffset(writeIndex);
return;
}
@@ -245,13 +245,13 @@ namespace zfoo {
b = value >> 28;
if (b == 0) {
setByte(writeIndex++, (int8_t) a);
setWriterOffset(writeIndex);
setWriteOffset(writeIndex);
return;
}
setByte(writeIndex++, (int8_t) (a | 0x80));
setByte(writeIndex++, (int8_t) b);
setWriterOffset(writeIndex);
setWriteOffset(writeIndex);
}
inline int32_t writeIntCount(const int32_t &intValue) {
@@ -272,7 +272,7 @@ namespace zfoo {
}
inline int32_t readInt() {
int32_t readIndex = m_readerOffset;
int32_t readIndex = readerOffset;
int32_t b = getByte(readIndex++);
uint32_t value = b;
@@ -291,7 +291,7 @@ namespace zfoo {
}
}
}
setReaderOffset(readIndex);
setReadOffset(readIndex);
value = ((value >> 1) ^ -((int32_t) value & 1));
return (int32_t) value;
}
@@ -348,7 +348,7 @@ namespace zfoo {
}
inline int64_t readLong() {
int32_t readIndex = m_readerOffset;
int32_t readIndex = readerOffset;
int64_t b = getByte(readIndex++);
uint64_t value = b;
@@ -385,7 +385,7 @@ namespace zfoo {
}
}
setReaderOffset(readIndex);
setReadOffset(readIndex);
value = ((value >> 1) ^ -((int64_t) value & 1));
return (int64_t) value;
}
@@ -475,6 +475,7 @@ namespace zfoo {
}
inline list<bool> readBoolList() {
int32_t length = readInt();
list<bool> list;
for (auto i = 0; i < length; i++) {
@@ -1324,17 +1325,17 @@ namespace zfoo {
if (IS_LITTLE_ENDIAN) {
swap_bytes<sizeof(T)>(reinterpret_cast<int8_t *>(&value));
}
memcpy(&m_buffer[m_writerOffset], (int8_t *) &value, sizeof(T));
m_writerOffset += sizeof(T);
memcpy(&buffer[writeOffset], (int8_t *) &value, sizeof(T));
writeOffset += sizeof(T);
}
template<class T>
inline T read() {
T value = *((T *) &m_buffer[m_readerOffset]);
T value = *((T *) &buffer[readerOffset]);
if (IS_LITTLE_ENDIAN) {
swap_bytes<sizeof(T)>(reinterpret_cast<int8_t *>(&value));
}
m_readerOffset += sizeof(T);
readerOffset += sizeof(T);
return value;
}
protocol/src/main/resources/cpp/ProtocolRegistrationTemplate.h
+2 -2
View File
@@ -19,10 +19,10 @@ public:
if (length == 0) {
return packet;
}
auto beforeReadIndex = buffer.getReaderOffset();
auto beforeReadIndex = buffer.getReadOffset();
${protocol_read_deserialization}
if (length > 0) {
buffer.setReaderOffset(beforeReadIndex + length);
buffer.setReadOffset(beforeReadIndex + length);
}
return packet;
}