path: root/code/Field.cpp

#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);
}