Parser.cpp

#include <jsonifier/Parser.hpp>
#include <jsonifier/Document_Impl.hpp>
#include <jsonifier/Jsonifier_Impl.hpp>
 
namespace Jsonifier {
 
    JsonifierResult<Document> Parser::parseJson(std::string_view string) noexcept {
        if (string.size() == 0) {
            return ErrorCode::No_String_Error;
        }
        this->stringView = ( char* )string.data();
        this->stringLengthRaw = string.size();
        if (this->allocatedSpace < round(5 * this->stringLengthRaw / 3 + 256, 256)) {
            if (this->allocate() != ErrorCode::Success) {
                return ErrorCode::Mem_Alloc_Error;
            }
        }
        this->generateJsonIndices();
        return std::forward<Document>(JsonIterator{ this });
    }
 
    JsonifierResult<Document> Parser::parseJson(const char* string, size_t stringLength) noexcept {
        if (stringLength == 0) {
            return ErrorCode::No_String_Error;
        }
        this->stringView = ( char* )string;
        this->stringLengthRaw = stringLength;
        if (this->allocatedSpace < round(5 * this->stringLengthRaw / 3 + 256, 256)) {
            if (this->allocate() != ErrorCode::Success) {
                return ErrorCode::Mem_Alloc_Error;
            }
        }
        this->generateJsonIndices();
        return std::forward<Document>(JsonIterator{ this });
    }
 
    JsonifierResult<Document> Parser::parseJson(const std::string& string) noexcept {
        if (string.size() == 0) {
            return ErrorCode::No_String_Error;
        }
        this->stringView = ( char* )string.data();
        this->stringLengthRaw = string.size();
        if (this->allocatedSpace < round(5 * this->stringLengthRaw / 3 + 256, 256)) {
            if (this->allocate() != ErrorCode::Success) {
                return ErrorCode::Mem_Alloc_Error;
            }
        }
        this->generateJsonIndices();
        return std::forward<Document>(JsonIterator{ this });
    }
 
    char* Parser::getStringView() noexcept {
        return this->stringView;
    }
 
    uint8_t* Parser::getStringBuffer() noexcept {
        return this->stringBuffer;
    }
 
    uint32_t* Parser::getStructuralIndices() noexcept {
        return this->structuralIndices.operator uint32_t*();
    }
 
    size_t Parser::maxDepth() noexcept {
        return 512;
    }
 
    size_t Parser::getTapeLength() noexcept {
        return this->tapeLength;
    }
 
    uint64_t Parser::round(int64_t a, int64_t n) noexcept {
        return (((a) + (( n )-1)) & ~(( n )-1));
    }
 
    ErrorCode Parser::allocate() noexcept {
        if (this->stringLengthRaw == 0) {
            return ErrorCode::No_String_Error;
        }
        this->stringBuffer.reset(round(5 * this->stringLengthRaw / 3 + 256, 256));
        this->structuralIndices.reset(round(this->stringLengthRaw + 3, 256));
        this->allocatedSpace = round(5 * this->stringLengthRaw / 3 + 256, 256);
        if (!(this->stringBuffer && this->structuralIndices)) {
            this->stringBuffer.reset(0);
            return ErrorCode::Mem_Alloc_Error;
        }
 
        return ErrorCode::Success;
    }
 
    ErrorCode Parser::generateJsonIndices() {
        StopWatch stopWatch{ std::chrono::nanoseconds{ 1 } };
        if (this->stringView) {
            StringBlockReader<256> stringReader{};
            stringReader.addNewString(( uint8_t* )this->stringView, this->stringLengthRaw);
            SimdStringSection section{ this->getStructuralIndices() };
            this->tapeLength = 0;
            size_t currentIndexIntoTape{};
            while (stringReader.hasFullBlock()) {
                section.submitDataForProcessing(stringReader.fullBlock());
                section.generateStructurals();
                stringReader.advance();
            }
            uint8_t block[256];
            stringReader.getRemainder(block);
            section.submitDataForProcessing(block);
            section.generateStructurals();
            currentIndexIntoTape += section.getTapeLength();
            this->tapeLength = currentIndexIntoTape;
        }
        return Success;
    }
 
}