Buffer.cpp

Go to the documentation of this file.

 
 #include "Buffer.h"
 #include <cstring>
 #include <iostream>
 #include <iomanip>
 
 namespace swt {
 Buffer::Buffer() : mClear(false) {
     // Empty buffer initialization
 }
 
 Buffer::Buffer(const Buffer& other) : mClear(false) {
     setTo(other);
 }
 
 Buffer::~Buffer() {
     clear();
 }
 
 Buffer& Buffer::operator=(const Buffer& other) {
     if (this != &other) {
         setTo(other);
     }
     return *this;
 }
 
 // ========== SIZE AND INITIALIZATION METHODS ==========
 
 void Buffer::setSize(int32_t len) {
     if (len < 0) len = 0;  // Safety check
     mBuf.assign(len, 0);   // Resize and fill with zeros
 }
 
 // ========== DATA COPYING METHODS ==========
 
 void Buffer::setTo(const Buffer& buffer) {
     mBuf = buffer.mBuf;
 }
 
 void Buffer::setTo(uint8_t* buf, int32_t len) {
     if (buf && len > 0) {
         mBuf.assign(buf, buf + len);
     } else {
         mBuf.clear();  // Clear buffer if invalid input
     }
 }
 
 void Buffer::setTo(char* buf, int32_t len) {
     setTo(reinterpret_cast<uint8_t*>(buf), len);
 }
 
 void Buffer::append(uint8_t* buf, int32_t len) {
     if (buf && len > 0) {
         mBuf.insert(mBuf.end(), buf, buf + len);
     }
 }
 
 // ========== DATA ACCESS METHODS ==========
 
 uint8_t* Buffer::data() {
     return mBuf.empty() ? nullptr : mBuf.data();
 }
 
 uint32_t Buffer::size() const {
     return static_cast<uint32_t>(mBuf.size());
 }
 
 bool Buffer::empty() {
     return mBuf.empty();
 }
 
 // ========== BUFFER MANAGEMENT METHODS ==========
 
 void Buffer::clear() {
     mBuf.clear();
     mClear = true;
 }
 
 // ========== DEBUG AND UTILITY METHODS ==========
 
 void Buffer::dump() {
     if (!mBuf.empty()) {
         dump(mBuf.data(), static_cast<int32_t>(mBuf.size()));
     } else {
         std::cout << "Buffer dump: (empty buffer)" << std::endl;
     }
 }
 
 void Buffer::dump(uint8_t* s, int32_t len) {
     if (!s || len <= 0) {
         std::cout << "Buffer dump: (null or empty data)" << std::endl;
         return;
     }
     
     std::cout << "Buffer dump (" << len << " bytes): ";
     
     // Save current format flags
     auto flags = std::cout.flags();
     
     // Set hex format with uppercase and proper width
     std::cout << std::hex << std::uppercase << std::setfill('0');
     
     for (int32_t i = 0; i < len; ++i) {
         std::cout << std::setw(2) << static_cast<unsigned int>(s[i]);
         if (i < len - 1) std::cout << " ";  // Space between bytes
     }
     
     // Restore original format flags
     std::cout.flags(flags);
     std::cout << std::endl;
 }
 
 // ========== INTERNAL METHODS ==========
 
 void Buffer::_assign(uint32_t size) {
     mBuf.resize(size);
 }
 
 void Buffer::_release() {
     clear();
 }
 
} // namespace swt