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

ref[protocol]: cpp protocol

Browse Source
This commit is contained in:
godotg committed 2024-07-15 16:47:13 +08:00
1 parent bff769df89
commit 49b80da60e
3 files changed
+67 -66
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

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 fieldRegistrations = registration.getFieldRegistrations();
var cppBuilder = new StringBuilder(); var cppBuilder = new StringBuilder();
if (registration.isCompatible()) { 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); cppBuilder.append(StringUtils.format("buffer.writeInt({});", registration.getPredictionLength())).append(LS);
} else { } else {
cppBuilder.append("buffer.writeInt(-1);").append(LS); 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 { class ByteBuffer {
private: private:
int8_t *m_buffer; int8_t *buffer;
int32_t m_max_capacity; int32_t max_capacity;
int32_t m_writerOffset; int32_t writeOffset;
int32_t m_readerOffset; int32_t readerOffset;
public: public:
ByteBuffer(int32_t capacity = DEFAULT_BUFFER_SIZE) : m_max_capacity(capacity) { ByteBuffer(int32_t capacity = DEFAULT_BUFFER_SIZE) : max_capacity(capacity) {
m_buffer = (int8_t *) calloc(m_max_capacity, sizeof(int8_t)); buffer = (int8_t *) calloc(max_capacity, sizeof(int8_t));
clear(); clear();
} }
~ByteBuffer() { ~ByteBuffer() {
free(m_buffer); free(buffer);
m_buffer = nullptr; buffer = nullptr;
} }
@@ -77,19 +77,19 @@ namespace zfoo {
ByteBuffer &operator=(const ByteBuffer &buffer) = delete; ByteBuffer &operator=(const ByteBuffer &buffer) = delete;
void adjustPadding(int32_t predictionLength, int32_t beforeWriteIndex) { void adjustPadding(int32_t predictionLength, int32_t beforeWriteIndex) {
int32_t currentWriteIndex = getWriterOffset(); int32_t currentWriteIndex = getWriteOffset();
int32_t predictionCount = writeIntCount(predictionLength); int32_t predictionCount = writeIntCount(predictionLength);
int32_t length = currentWriteIndex - beforeWriteIndex - predictionCount; int32_t length = currentWriteIndex - beforeWriteIndex - predictionCount;
int32_t lengthCount = writeIntCount(length); int32_t lengthCount = writeIntCount(length);
int32_t padding = lengthCount - predictionCount; int32_t padding = lengthCount - predictionCount;
if (padding == 0) { if (padding == 0) {
setWriterOffset(beforeWriteIndex); setWriteOffset(beforeWriteIndex);
writeInt(length); writeInt(length);
setWriterOffset(currentWriteIndex); setWriteOffset(currentWriteIndex);
} else { } else {
int8_t *targetPtr = (int8_t *) calloc(length, sizeof(int8_t)); int8_t *targetPtr = (int8_t *) calloc(length, sizeof(int8_t));
memcpy(targetPtr, &m_buffer[currentWriteIndex - length], length); memcpy(targetPtr, &buffer[currentWriteIndex - length], length);
setWriterOffset(beforeWriteIndex); setWriteOffset(beforeWriteIndex);
writeInt(length); writeInt(length);
writeBytes(targetPtr, length); writeBytes(targetPtr, length);
free(targetPtr); free(targetPtr);
@@ -97,108 +97,108 @@ namespace zfoo {
} }
bool compatibleRead(int32_t beforeReadIndex, int32_t length) { bool compatibleRead(int32_t beforeReadIndex, int32_t length) {
return length != -1 && getReaderOffset() < length + beforeReadIndex; return length != -1 && getReadOffset() < length + beforeReadIndex;
} }
void clear() { void clear() {
m_writerOffset = 0; writeOffset = 0;
m_readerOffset = 0; readerOffset = 0;
} }
int8_t *getBuffer() { int8_t *getBuffer() {
return m_buffer; return buffer;
} }
int32_t getWriterOffset() const { int32_t getWriteOffset() const {
return m_writerOffset; return writeOffset;
} }
int32_t getReaderOffset() const { int32_t getReadOffset() const {
return m_readerOffset; return readerOffset;
} }
void setWriterOffset(int32_t writeIndex) { void setWriteOffset(int32_t writeIndex) {
if (writeIndex > m_max_capacity) { if (writeIndex > max_capacity) {
string errorMessage = string errorMessage =
"writeIndex[" + std::to_string(writeIndex) + "] out of bounds exception: readerIndex: " + "writeIndex[" + std::to_string(writeIndex) + "] out of bounds exception: readerIndex: " +
std::to_string(m_readerOffset) + std::to_string(readerOffset) +
", writerIndex: " + std::to_string(m_writerOffset) + ", writerIndex: " + std::to_string(writeOffset) +
"(expected: 0 <= readerIndex <= writerIndex <= capacity:" + std::to_string(m_max_capacity); "(expected: 0 <= readerIndex <= writerIndex <= capacity:" + std::to_string(max_capacity);
throw errorMessage; throw errorMessage;
} }
m_writerOffset = writeIndex; writeOffset = writeIndex;
} }
void setReaderOffset(int32_t readerIndex) { void setReadOffset(int32_t readerIndex) {
if (readerIndex > m_writerOffset) { if (readerIndex > writeOffset) {
string errorMessage = string errorMessage =
"readIndex[" + std::to_string(readerIndex) + "] out of bounds exception: readerIndex: " + "readIndex[" + std::to_string(readerIndex) + "] out of bounds exception: readerIndex: " +
std::to_string(m_readerOffset) + std::to_string(readerOffset) +
", writerIndex: " + std::to_string(m_writerOffset) + ", writerIndex: " + std::to_string(writeOffset) +
"(expected: 0 <= readerIndex <= writerIndex <= capacity:" + std::to_string(m_max_capacity); "(expected: 0 <= readerIndex <= writerIndex <= capacity:" + std::to_string(max_capacity);
throw errorMessage; throw errorMessage;
} }
m_readerOffset = readerIndex; readerOffset = readerIndex;
} }
inline int32_t getCapacity() const { inline int32_t getCapacity() const {
return m_max_capacity - m_writerOffset; return max_capacity - writeOffset;
} }
inline void ensureCapacity(const int32_t &capacity) { inline void ensureCapacity(const int32_t &capacity) {
while (capacity - getCapacity() > 0) { while (capacity - getCapacity() > 0) {
int32_t newSize = m_max_capacity * 2; int32_t newSize = max_capacity * 2;
int8_t *pBuf = (int8_t *) realloc(m_buffer, newSize); int8_t *pBuf = (int8_t *) realloc(buffer, newSize);
if (!pBuf) { if (!pBuf) {
string errorMessage = "relloc failed!"; string errorMessage = "relloc failed!";
throw errorMessage; throw errorMessage;
} }
m_buffer = pBuf; buffer = pBuf;
m_max_capacity = newSize; max_capacity = newSize;
} }
} }
inline bool isReadable() { inline bool isReadable() {
return m_writerOffset > m_readerOffset; return writeOffset > readerOffset;
} }
inline void writeBool(const bool &value) { inline void writeBool(const bool &value) {
ensureCapacity(1); ensureCapacity(1);
int8_t v = value ? 1 : 0; int8_t v = value ? 1 : 0;
m_buffer[m_writerOffset++] = v; buffer[writeOffset++] = v;
} }
inline bool readBool() { inline bool readBool() {
int8_t value = m_buffer[m_readerOffset++]; int8_t value = buffer[readerOffset++];
return value == 1; return value == 1;
} }
inline void writeByte(const int8_t &value) { inline void writeByte(const int8_t &value) {
ensureCapacity(1); ensureCapacity(1);
m_buffer[m_writerOffset++] = value; buffer[writeOffset++] = value;
} }
inline int8_t readByte() { inline int8_t readByte() {
return m_buffer[m_readerOffset++]; return buffer[readerOffset++];
} }
inline void setByte(const int32_t &index, const int8_t &value) { 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) { 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); ensureCapacity(length);
memcpy(&m_buffer[m_writerOffset], buffer, length); memcpy(&buffer[writeOffset], buf, length);
m_writerOffset += length; writeOffset += length;
} }
inline int8_t *readBytes(const int32_t &length) { inline int8_t *readBytes(const int32_t &length) {
int8_t *bytes = &m_buffer[m_readerOffset]; int8_t *bytes = &buffer[readerOffset];
m_readerOffset += length; readerOffset += length;
return bytes; return bytes;
} }
@@ -222,14 +222,14 @@ namespace zfoo {
return; return;
} }
int32_t writeIndex = m_writerOffset; int32_t writeIndex = writeOffset;
ensureCapacity(5); ensureCapacity(5);
setByte(writeIndex++, (int8_t) (value | 0x80)); setByte(writeIndex++, (int8_t) (value | 0x80));
uint32_t b = value >> 14; uint32_t b = value >> 14;
if (b == 0) { if (b == 0) {
setByte(writeIndex++, (int8_t) a); setByte(writeIndex++, (int8_t) a);
setWriterOffset(writeIndex); setWriteOffset(writeIndex);
return; return;
} }
@@ -237,7 +237,7 @@ namespace zfoo {
a = value >> 21; a = value >> 21;
if (a == 0) { if (a == 0) {
setByte(writeIndex++, (int8_t) b); setByte(writeIndex++, (int8_t) b);
setWriterOffset(writeIndex); setWriteOffset(writeIndex);
return; return;
} }
@@ -245,13 +245,13 @@ namespace zfoo {
b = value >> 28; b = value >> 28;
if (b == 0) { if (b == 0) {
setByte(writeIndex++, (int8_t) a); setByte(writeIndex++, (int8_t) a);
setWriterOffset(writeIndex); setWriteOffset(writeIndex);
return; return;
} }
setByte(writeIndex++, (int8_t) (a | 0x80)); setByte(writeIndex++, (int8_t) (a | 0x80));
setByte(writeIndex++, (int8_t) b); setByte(writeIndex++, (int8_t) b);
setWriterOffset(writeIndex); setWriteOffset(writeIndex);
} }
inline int32_t writeIntCount(const int32_t &intValue) { inline int32_t writeIntCount(const int32_t &intValue) {
@@ -272,7 +272,7 @@ namespace zfoo {
} }
inline int32_t readInt() { inline int32_t readInt() {
int32_t readIndex = m_readerOffset; int32_t readIndex = readerOffset;
int32_t b = getByte(readIndex++); int32_t b = getByte(readIndex++);
uint32_t value = b; uint32_t value = b;
@@ -291,7 +291,7 @@ namespace zfoo {
} }
} }
} }
setReaderOffset(readIndex); setReadOffset(readIndex);
value = ((value >> 1) ^ -((int32_t) value & 1)); value = ((value >> 1) ^ -((int32_t) value & 1));
return (int32_t) value; return (int32_t) value;
} }
@@ -348,7 +348,7 @@ namespace zfoo {
} }
inline int64_t readLong() { inline int64_t readLong() {
int32_t readIndex = m_readerOffset; int32_t readIndex = readerOffset;
int64_t b = getByte(readIndex++); int64_t b = getByte(readIndex++);
uint64_t value = b; uint64_t value = b;
@@ -385,7 +385,7 @@ namespace zfoo {
} }
} }
setReaderOffset(readIndex); setReadOffset(readIndex);
value = ((value >> 1) ^ -((int64_t) value & 1)); value = ((value >> 1) ^ -((int64_t) value & 1));
return (int64_t) value; return (int64_t) value;
} }
@@ -475,6 +475,7 @@ namespace zfoo {
} }
inline list<bool> readBoolList() { inline list<bool> readBoolList() {
int32_t length = readInt(); int32_t length = readInt();
list<bool> list; list<bool> list;
for (auto i = 0; i < length; i++) { for (auto i = 0; i < length; i++) {
@@ -1324,17 +1325,17 @@ namespace zfoo {
if (IS_LITTLE_ENDIAN) { if (IS_LITTLE_ENDIAN) {
swap_bytes<sizeof(T)>(reinterpret_cast<int8_t *>(&value)); swap_bytes<sizeof(T)>(reinterpret_cast<int8_t *>(&value));
} }
memcpy(&m_buffer[m_writerOffset], (int8_t *) &value, sizeof(T)); memcpy(&buffer[writeOffset], (int8_t *) &value, sizeof(T));
m_writerOffset += sizeof(T); writeOffset += sizeof(T);
} }
template<class T> template<class T>
inline T read() { inline T read() {
T value = *((T *) &m_buffer[m_readerOffset]); T value = *((T *) &buffer[readerOffset]);
if (IS_LITTLE_ENDIAN) { if (IS_LITTLE_ENDIAN) {
swap_bytes<sizeof(T)>(reinterpret_cast<int8_t *>(&value)); swap_bytes<sizeof(T)>(reinterpret_cast<int8_t *>(&value));
} }
m_readerOffset += sizeof(T); readerOffset += sizeof(T);
return value; return value;
} }
protocol/src/main/resources/cpp/ProtocolRegistrationTemplate.h
+2 -2
View File
@@ -19,10 +19,10 @@ public:
if (length == 0) { if (length == 0) {
return packet; return packet;
} }
auto beforeReadIndex = buffer.getReaderOffset(); auto beforeReadIndex = buffer.getReadOffset();
${protocol_read_deserialization} ${protocol_read_deserialization}
if (length > 0) { if (length > 0) {
buffer.setReaderOffset(beforeReadIndex + length); buffer.setReadOffset(beforeReadIndex + length);
} }
return packet; return packet;
} }