API tools faq
paste
Advertisement
Guest User

ByteBuffer.cpp

a guest
Jul 29th, 2017
30
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 10.66 KB | None | 0 0
raw download clone embed print report
  1. #include "ByteBuffer.h"
  2.  
  3. ByteBuffer::ByteBuffer(bool littleEndian) {
  4.     setLittleEndian(littleEndian);
  5. }
  6.  
  7. ByteBuffer::ByteBuffer(const char *data, size_t length) {
  8.     for (size_t i = 0; length > i; i++) {
  9.         vec.push_back(data[i]);
  10.     }
  11. }
  12.  
  13. ByteBuffer::ByteBuffer(const char *data, size_t length, bool littleEndian) {
  14.     for (size_t i = 0; length > i; i++) {
  15.         vec.push_back(data[i]);
  16.     }
  17.  
  18.     setLittleEndian(littleEndian);
  19. }
  20.  
  21. void ByteBuffer::setUint8(size_t index, uint8_t val) {
  22.     if (vec.size() < (index + 1)) {
  23.         vec.resize(vec.size() + (index + 1 - vec.size()));
  24.     }
  25.  
  26.     vec[index] = val;
  27. }
  28.  
  29. void ByteBuffer::putUint8(uint8_t val) {
  30.     vec.push_back(val);
  31. }
  32.  
  33. uint8_t ByteBuffer::getUint8() {
  34.     return (uint8_t) vec[readIndex++];
  35. }
  36.  
  37. uint8_t ByteBuffer::getUint8(size_t index) {
  38.     readIndex = index;
  39.     return (uint8_t) vec[readIndex++];
  40. }
  41.  
  42. void ByteBuffer::setInt8(size_t index, int8_t val) {
  43.     return setUint8(index, (uint8_t) val);
  44. }
  45.  
  46. void ByteBuffer::putInt8(int8_t val) {
  47.     vec.push_back(val);
  48. }
  49.  
  50. int8_t ByteBuffer::getInt8() {
  51.     return vec[readIndex++];
  52. }
  53.  
  54. int8_t ByteBuffer::getInt8(size_t index) {
  55.     readIndex = index;
  56.     return vec[readIndex++];
  57. }
  58.  
  59. void ByteBuffer::setUint16(size_t index, uint16_t val) {
  60.     if (vec.size() < (index + 2)) {
  61.         vec.resize(vec.size() + (index + 2 - vec.size()));
  62.     }
  63.  
  64.     union {
  65.         uint16_t value;
  66.         char ch[2];
  67.     };
  68.  
  69.     value = val;
  70.  
  71.     if (dontSwap) {
  72.         vec[index++] = ch[0];
  73.         vec[index] = ch[1];
  74.     } else {
  75.         vec[index++] = ch[1];
  76.         vec[index] = ch[0];
  77.     }
  78. }
  79.  
  80. void ByteBuffer::putUint16(uint16_t val) {
  81.     union {
  82.         uint16_t value;
  83.         char ch[2];
  84.     };
  85.  
  86.     value = val;
  87.  
  88.     if (dontSwap) {
  89.         vec.push_back(ch[0]);
  90.         vec.push_back(ch[1]);
  91.     } else {
  92.         vec.push_back(ch[1]);
  93.         vec.push_back(ch[0]);
  94.     }
  95. }
  96.  
  97. uint16_t ByteBuffer::getUint16() {
  98.     union {
  99.         uint16_t value;
  100.         char ch[2];
  101.     };
  102.  
  103.     if (dontSwap) {
  104.         ch[0] = vec[readIndex++];
  105.         ch[1] = vec[readIndex++];
  106.     } else {
  107.         ch[1] = vec[readIndex++];
  108.         ch[0] = vec[readIndex++];
  109.     }
  110.  
  111.     return value;
  112. }
  113.  
  114. uint16_t ByteBuffer::getUint16(size_t index) {
  115.     readIndex = index;
  116.     return getUint16();
  117. }
  118.  
  119. void ByteBuffer::setInt16(size_t index, int16_t val) {
  120.     return setUint16(index, (uint16_t) val);
  121. }
  122.  
  123. void ByteBuffer::putInt16(int16_t val) {
  124.     return putUint16((uint16_t) val);
  125. }
  126.  
  127. int16_t ByteBuffer::getInt16() {
  128.     return getUint16();
  129. }
  130.  
  131. int16_t ByteBuffer::getInt16(size_t index) {
  132.     readIndex = index;
  133.     return getUint16();
  134. }
  135.  
  136. void ByteBuffer::setUint32(size_t index, uint32_t val) {
  137.     if (vec.size() < (index + 4)) {
  138.         vec.resize(vec.size() + (index + 4 - vec.size()));
  139.     }
  140.  
  141.     union {
  142.         uint32_t value;
  143.         char ch[4];
  144.     };
  145.  
  146.     value = val;
  147.  
  148.     if (dontSwap) {
  149.         vec[index++] = ch[0];
  150.         vec[index++] = ch[1];
  151.         vec[index++] = ch[2];
  152.         vec[index] = ch[3];
  153.     } else {
  154.         vec[index++] = ch[3];
  155.         vec[index++] = ch[2];
  156.         vec[index++] = ch[1];
  157.         vec[index] = ch[0];
  158.     }
  159. }
  160.  
  161. void ByteBuffer::putUint32(uint32_t val) {
  162.     union {
  163.         uint32_t value;
  164.         char ch[4];
  165.     };
  166.  
  167.     value = val;
  168.  
  169.     if (dontSwap) {
  170.         vec.push_back(ch[0]);
  171.         vec.push_back(ch[1]);
  172.         vec.push_back(ch[2]);
  173.         vec.push_back(ch[3]);
  174.     } else {
  175.         vec.push_back(ch[3]);
  176.         vec.push_back(ch[2]);
  177.         vec.push_back(ch[1]);
  178.         vec.push_back(ch[0]);
  179.     }
  180. }
  181.  
  182. uint32_t ByteBuffer::getUint32() {
  183.     union {
  184.         uint32_t value;
  185.         char ch[4];
  186.     };
  187.  
  188.     if (dontSwap) {
  189.         ch[0] = vec[readIndex++];
  190.         ch[1] = vec[readIndex++];
  191.         ch[2] = vec[readIndex++];
  192.         ch[3] = vec[readIndex++];
  193.     } else {
  194.         ch[3] = vec[readIndex++];
  195.         ch[2] = vec[readIndex++];
  196.         ch[1] = vec[readIndex++];
  197.         ch[0] = vec[readIndex++];
  198.     }
  199.  
  200.     return value;
  201. }
  202.  
  203. uint32_t ByteBuffer::getUint32(size_t index) {
  204.     readIndex = index;
  205.     return getUint32();
  206. }
  207.  
  208. void ByteBuffer::setInt32(size_t index, int32_t val) {
  209.     return setUint32(index, (uint32_t) val);
  210. }
  211.  
  212. void ByteBuffer::putInt32(int32_t val) {
  213.     return putUint32((uint32_t) val);
  214. }
  215.  
  216. int32_t ByteBuffer::getInt32() {
  217.     return getUint32();
  218. }
  219.  
  220. int32_t ByteBuffer::getInt32(size_t index) {
  221.     readIndex = index;
  222.     return getUint32();
  223. }
  224.  
  225. void ByteBuffer::setFloat32(size_t index, float val) {
  226.     if (vec.size() < (index + 4)) {
  227.         vec.resize(vec.size() + (index + 4 - vec.size()));
  228.     }
  229.  
  230.     union {
  231.         float value;
  232.         char ch[4];
  233.     };
  234.  
  235.     value = val;
  236.  
  237.     if (dontSwap) {
  238.         vec[index++] = ch[0];
  239.         vec[index++] = ch[1];
  240.         vec[index++] = ch[2];
  241.         vec[index] = ch[3];
  242.     } else {
  243.         vec[index++] = ch[3];
  244.         vec[index++] = ch[2];
  245.         vec[index++] = ch[1];
  246.         vec[index] = ch[0];
  247.     }
  248. }
  249.  
  250. void ByteBuffer::putFloat32(float val) {
  251.     union {
  252.         float value;
  253.         char ch[4];
  254.     };
  255.  
  256.     value = val;
  257.  
  258.     if (dontSwap) {
  259.         vec.push_back(ch[0]);
  260.         vec.push_back(ch[1]);
  261.         vec.push_back(ch[2]);
  262.         vec.push_back(ch[3]);
  263.     } else {
  264.         vec.push_back(ch[3]);
  265.         vec.push_back(ch[2]);
  266.         vec.push_back(ch[1]);
  267.         vec.push_back(ch[0]);
  268.     }
  269. }
  270.  
  271. float ByteBuffer::getFloat32() {
  272.     union {
  273.         float value;
  274.         char ch[4];
  275.     };
  276.  
  277.     if (dontSwap) {
  278.         ch[0] = vec[readIndex++];
  279.         ch[1] = vec[readIndex++];
  280.         ch[2] = vec[readIndex++];
  281.         ch[3] = vec[readIndex++];
  282.     } else {
  283.         ch[3] = vec[readIndex++];
  284.         ch[2] = vec[readIndex++];
  285.         ch[1] = vec[readIndex++];
  286.         ch[0] = vec[readIndex++];
  287.     }
  288.  
  289.     return value;
  290. }
  291.  
  292. float ByteBuffer::getFloat32(size_t index) {
  293.     readIndex = index;
  294.     return getFloat32();
  295. }
  296.  
  297. void ByteBuffer::setFloat64(size_t index, double val) {
  298.     if (vec.size() < (index + 8)) {
  299.         vec.resize(vec.size() + (index + 8 - vec.size()));
  300.     }
  301.  
  302.     union {
  303.         double value;
  304.         char ch[8];
  305.     };
  306.  
  307.     value = val;
  308.  
  309.     if (dontSwap) {
  310.         vec[index++] = ch[0];
  311.         vec[index++] = ch[1];
  312.         vec[index++] = ch[2];
  313.         vec[index++] = ch[3];
  314.         vec[index++] = ch[4];
  315.         vec[index++] = ch[5];
  316.         vec[index++] = ch[6];
  317.         vec[index] = ch[7];
  318.     } else {
  319.         vec[index++] = ch[7];
  320.         vec[index++] = ch[6];
  321.         vec[index++] = ch[5];
  322.         vec[index++] = ch[4];
  323.         vec[index++] = ch[3];
  324.         vec[index++] = ch[2];
  325.         vec[index++] = ch[1];
  326.         vec[index] = ch[0];
  327.     }
  328. }
  329.  
  330. void ByteBuffer::putFloat64(double val) {
  331.     union {
  332.         double value;
  333.         char ch[8];
  334.     };
  335.  
  336.     value = val;
  337.  
  338.     if (dontSwap) {
  339.         vec.push_back(ch[0]);
  340.         vec.push_back(ch[1]);
  341.         vec.push_back(ch[2]);
  342.         vec.push_back(ch[3]);
  343.         vec.push_back(ch[4]);
  344.         vec.push_back(ch[5]);
  345.         vec.push_back(ch[6]);
  346.         vec.push_back(ch[7]);
  347.     } else {
  348.         vec.push_back(ch[7]);
  349.         vec.push_back(ch[6]);
  350.         vec.push_back(ch[5]);
  351.         vec.push_back(ch[4]);
  352.         vec.push_back(ch[3]);
  353.         vec.push_back(ch[2]);
  354.         vec.push_back(ch[1]);
  355.         vec.push_back(ch[0]);
  356.     }
  357. }
  358.  
  359. double ByteBuffer::getFloat64() {
  360.     union {
  361.         double value;
  362.         char ch[8];
  363.     };
  364.  
  365.     if (dontSwap) {
  366.         ch[0] = vec[readIndex++];
  367.         ch[1] = vec[readIndex++];
  368.         ch[2] = vec[readIndex++];
  369.         ch[3] = vec[readIndex++];
  370.         ch[4] = vec[readIndex++];
  371.         ch[5] = vec[readIndex++];
  372.         ch[6] = vec[readIndex++];
  373.         ch[7] = vec[readIndex++];
  374.     } else {
  375.         ch[7] = vec[readIndex++];
  376.         ch[6] = vec[readIndex++];
  377.         ch[5] = vec[readIndex++];
  378.         ch[4] = vec[readIndex++];
  379.         ch[3] = vec[readIndex++];
  380.         ch[2] = vec[readIndex++];
  381.         ch[1] = vec[readIndex++];
  382.         ch[0] = vec[readIndex++];
  383.     }
  384.  
  385.     return value;
  386. }
  387.  
  388. double ByteBuffer::getFloat64(size_t index) {
  389.     readIndex = index;
  390.     return getFloat64();
  391. }
  392.  
  393. void ByteBuffer::setUTF16(size_t index, std::u16string str) {
  394.     if (vec.size() < (index + (2 * str.length()) + 1)) {
  395.         vec.resize(vec.size() + (index + (2 * str.length()) + 1));
  396.     }
  397.  
  398.     for (char16_t ch : str) {
  399.         if (ch == 0) break;
  400.  
  401.         setUint16(index, ch);
  402.         index += 2;
  403.     }
  404.  
  405.     setUint16(index, 0);
  406. }
  407.  
  408. void ByteBuffer::putUTF16(std::u16string str) {
  409.     for (char16_t ch : str) {
  410.         putUint16(ch);
  411.     }
  412.  
  413.     putUint16(0);
  414. }
  415.  
  416. std::u16string ByteBuffer::getUTF16() {
  417.     std::u16string text = u"";
  418.  
  419.     while (readIndex < size()) {
  420.         char16_t ch = getUint16();
  421.         if (ch == 0) break;
  422.  
  423.         text += ch;
  424.     }
  425.  
  426.     return text;
  427. }
  428.  
  429. std::u16string ByteBuffer::getUTF16(size_t index) {
  430.     readIndex = index;
  431.     return getUTF16();
  432. }
  433.  
  434. void ByteBuffer::setUTF8(size_t index, std::string str) {
  435.     if (vec.size() < (index + (str.length()) + 1)) {
  436.         vec.resize(vec.size() + (index + (str.length()) + 1));
  437.     }
  438.  
  439.     for (char ch : str) {
  440.         if (ch == 0) break;
  441.  
  442.         vec[index++] = ch;
  443.     }
  444.  
  445.     vec[index] = 0;
  446. }
  447.  
  448. void ByteBuffer::putUTF8(std::string str) {
  449.     for (char ch : str) {
  450.         vec.push_back(ch);
  451.     }
  452.  
  453.     vec.push_back(0);
  454. }
  455.  
  456. std::string ByteBuffer::getUTF8() {
  457.     std::string text = "";
  458.  
  459.     while (readIndex < size()) {
  460.         char ch = getUint8();
  461.         if (ch == 0) break;
  462.  
  463.         text += ch;
  464.     }
  465.  
  466.     return text;
  467. }
  468.  
  469. std::string ByteBuffer::getUTF8(size_t index) {
  470.     readIndex = index;
  471.     return getUTF8();
  472. }
  473.  
  474. void ByteBuffer::setLittleEndian(bool le) {
  475. #if __BYTE_ORDER == __LITTLE_ENDIAN
  476.     dontSwap = le;
  477. #else
  478.     dontSwap = !le;
  479. #endif
  480. }
  481.  
  482. bool ByteBuffer::isLittleEndian() {
  483. #if __BYTE_ORDER == __LITTLE_ENDIAN
  484.     return dontSwap;
  485. #else
  486.     return !dontSwap;
  487. #endif
  488. }
  489.  
  490. void ByteBuffer::erase(size_t index, size_t count) {
  491.     vec.erase(vec.begin() + index, vec.begin() + index + count);
  492. }
  493.  
  494. std::vector<char> ByteBuffer::getVector() {
  495.     return vec;
  496. }
  497.  
  498. char* ByteBuffer::getData() {
  499.     return vec.data();
  500. }
  501.  
  502. size_t ByteBuffer::size() {
  503.     return vec.size();
  504. }
  505.  
  506. std::string ByteBuffer::toString() {
  507.     std::string str = "ByteBuffer[";
  508.     for (size_t i = 0; i < (vec.size() - 1); i++) {
  509.         str += std::to_string((unsigned char) vec[i]) + ", ";
  510.     }
  511.     str += std::to_string((unsigned char) vec[vec.size() - 1]) + "]";
  512.  
  513.     return str;
  514. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!