1 files changed, 307 insertions, 0 deletions
diff --git a/code/Field.cpp b/code/Field.cpp
new file mode 100644
index 0000000..c95c32d
--- /dev/null
+++ b/code/Field.cpp
@@ -0,0 +1,307 @@
+#include <cmath>
+#include "Field.hpp"
+
+Field::Field() {
+}
+
+Field::Field(const Field &other) : m_dataLength(other.m_dataLength), m_type(other.m_type) {
+
+    m_data = new byte[m_dataLength];
+    std::copy(other.m_data,other.m_data+m_dataLength,m_data);
+}
+
+void Field::swap(Field &other) {
+    std::swap(other.m_dataLength, m_dataLength);
+    std::swap(other.m_data, m_data);
+    std::swap(other.m_type, m_type);
+}
+
+Field &Field::operator=(Field other) {
+    other.swap(*this);
+    return *this;
+}
+
+Field::~Field() {
+    Clear();
+}
+
+size_t Field::GetLength() {
+    if (m_data != nullptr && m_dataLength == 0)
+        throw 102;
+    return m_dataLength;
+}
+
+void Field::Clear() {
+    m_dataLength = 0;
+    delete[] m_data;
+    m_data = nullptr;
+}
+
+void Field::CopyToBuff(byte *ptr) {
+    if (m_dataLength > 0)
+        std::copy(m_data,m_data+m_dataLength,ptr);
+}
+
+void Field::SetRaw(byte *ptr, size_t len, FieldType type) {
+    Clear();
+    m_dataLength = len;
+    m_type = type;
+    m_data = new byte[m_dataLength];
+    std::copy(ptr,ptr+m_dataLength,m_data);
+}
+
+int Field::GetVarInt() {
+
+    size_t readed;
+    return VarIntRead(m_data, readed);
+
+}
+
+void Field::SetVarInt(int value) {
+    Clear();
+    m_type = VarInt;
+    m_data = new byte[5];
+    m_dataLength = VarIntWrite(value, m_data);
+}
+
+int Field::GetInt() {
+    int value = *(reinterpret_cast<int *>(m_data));
+    endswap(&value);
+    return value;
+}
+
+void Field::SetInt(int value) {
+    Clear();
+    m_type = Int;
+    m_data = new byte[4];
+    m_dataLength = 4;
+    int *p = reinterpret_cast<int *>(m_data);
+    *p = value;
+    endswap(p);
+}
+
+bool Field::GetBool() {
+    return *m_data != 0x00;
+}
+
+void Field::SetBool(bool value) {
+    Clear();
+    m_type = Boolean;
+    m_data = new byte[1];
+    m_dataLength = 1;
+    *m_data = value ? 0x01 : 0x00;
+}
+
+unsigned short Field::GetUShort() {
+    unsigned short *p = reinterpret_cast<unsigned short *>(m_data);
+    unsigned short t = *p;
+    endswap(&t);
+    return t;
+}
+
+void Field::SetUShort(unsigned short value) {
+    Clear();
+    m_type = UnsignedShort;
+    m_dataLength = 2;
+    m_data = new byte[2];
+    unsigned short *p = reinterpret_cast<unsigned short *>(m_data);
+    *p = value;
+    endswap(p);
+}
+
+std::string Field::GetString() {
+    Field fLen;
+    byte *ptr = m_data;
+    size_t l;
+    int val = VarIntRead(ptr, l);
+    ptr += l;
+    std::string s((char *) ptr, val);
+    return s;
+}
+
+void Field::SetString(std::string value) {
+    Clear();
+    m_type = String;
+    Field fLen;
+    fLen.SetVarInt(value.size());
+    m_dataLength = value.size() + fLen.GetLength();
+    m_data = new byte[m_dataLength];
+    byte *p = m_data;
+    fLen.CopyToBuff(p);
+    p += fLen.GetLength();
+    std::copy(value.begin(),value.end(),p);
+}
+
+long long Field::GetLong() {
+    long long t = *reinterpret_cast<long long *>(m_data);
+    endswap(&t);
+    return t;
+}
+
+void Field::SetLong(long long value) {
+    Clear();
+    m_type = Long;
+    m_dataLength = 8;
+    m_data = new byte[m_dataLength];
+    long long *p = reinterpret_cast<long long *>(m_data);
+    *p = value;
+    endswap(p);
+}
+
+FieldType Field::GetType() {
+    return m_type;
+}
+
+byte Field::GetUByte() {
+    byte t = *reinterpret_cast<byte *>(m_data);
+    endswap(&t);
+    return t;
+}
+
+void Field::SetUByte(byte value) {
+    Clear();
+    m_type = UnsignedByte;
+    endswap(&value);
+    m_dataLength = 1;
+    m_data = new byte[m_dataLength];
+    byte *p = reinterpret_cast<byte *>(m_data);
+    *p = value;
+}
+
+sbyte Field::GetByte() {
+    sbyte t = *reinterpret_cast<sbyte *>(m_data);
+    endswap(&t);
+    return t;
+}
+
+void Field::SetByte(sbyte value) {
+    Clear();
+    m_type = Byte8_t;
+    endswap(&value);
+    m_dataLength = 1;
+    m_data = new byte[m_dataLength];
+    sbyte *p = reinterpret_cast<sbyte *>(m_data);
+    *p = value;
+}
+
+float Field::GetFloat() {
+    float t = *reinterpret_cast<float *>(m_data);
+    endswap(&t);
+    return t;
+}
+
+void Field::SetFloat(float value) {
+    Clear();
+    m_type = Float;
+    endswap(&value);
+    m_dataLength = 4;
+    m_data = new byte[m_dataLength];
+    float *p = reinterpret_cast<float *>(m_data);
+    *p = value;
+}
+
+PositionI Field::GetPosition() {
+    unsigned long long t = *reinterpret_cast<unsigned long long *>(m_data);
+    endswap(&t);
+    int x = t >> 38;
+    int y = (t >> 26) & 0xFFF;
+    int z = t << 38 >> 38;
+    if (x >= pow(2, 25)) {
+        x -= pow(2, 26);
+    }
+    if (y >= pow(2, 11)) {
+        y -= pow(2, 12);
+    }
+    if (z >= pow(2, 25)) {
+        z -= pow(2, 26);
+    }
+    PositionI val;
+    val.SetX(x);
+    val.setZ(z);
+    val.SetY(y);
+    return val;
+}
+
+void Field::SetPosition(PositionI value) {
+    Clear();
+    m_type = Position;
+    m_dataLength = 8;
+    m_data = new byte[m_dataLength];
+    unsigned long long *t = reinterpret_cast<unsigned long long *>(m_data);
+    unsigned long long x = ((unsigned long long) value.GetX()) << 38;
+    unsigned long long y = ((unsigned long long) value.GetY()) << 26;
+    unsigned long long z = value.GetZ();
+    endswap(&x);
+    endswap(&z);
+    endswap(&y);
+    *t = x | y | z;
+}
+
+double Field::GetDouble() {
+    double t = *reinterpret_cast<double *>(m_data);
+    endswap(&t);
+    return t;
+}
+
+void Field::SetDouble(double value) {
+    Clear();
+    m_type = Double;
+    endswap(&value);
+    m_dataLength = 8;
+    m_data = new byte[m_dataLength];
+    double *p = reinterpret_cast<double *>(m_data);
+    *p = value;
+}
+
+size_t Field::GetFieldLength(FieldType type) {
+    switch (type) {
+        case Unknown:
+            return 0;
+        case Boolean:
+            return 1;
+        case Byte8_t:
+            return 1;
+        case UnsignedByte:
+            return 1;
+        case Short:
+            return 2;
+        case UnsignedShort:
+            return 2;
+        case Int:
+            return 4;
+        case Long:
+            return 8;
+        case Float:
+            return 4;
+        case Double:
+            return 8;
+        case Position:
+            return 8;
+        case Angle:
+            return 4;
+        case Uuid:
+            return 16;
+        default:
+            return 0;
+    }
+}
+
+std::vector<Field> Field::GetArray() {
+    /*std::vector<Field> vec;
+    if (m_type<20){
+        size_t fieldLen=GetFieldLength(m_type);
+        byte* ptr = m_data;
+        for (int i=0;i<m_dataLength/fieldLen;i++){
+            Field f;
+            f.SetRaw(ptr,fieldLen,m_type);
+            vec.push_back(f);
+            ptr+=fieldLen;
+        }
+        return vec;
+    }*/
+    return m_childs;
+}
+
+void Field::Attach(Field field) {
+    m_childs.push_back(field);
+}