src/Builder.cpp - main - thomas-king/IntegerParser

src/Builder.cpp
137 строк3 KB
AceRodstin
Refactor parser.
02 янв 2023, 17:39
02 янв 2023, 17:39e53dbcf
//
//  Builder.cpp
//  IntegerParser
//
//  Created by Ace Rodstin on 30 Dec 2022.
//

#include "../include/Builder.h"

using namespace Integer;

void Builder::configure(string literal) {
    buffer = stringstream { literal };
    define_head();
    define_base();
}

void Builder::define_head() {
    string literal = buffer.str();
    auto head = literal.substr(0, 2);

    if (literals_head.contains(head)) {
        this->head = head;
    }
}

void Builder::define_base() {
    if (head.has_value()) {
        base = literals_head.at(head.value());
    } else {
        base = Base::decimal;
    }
}

Literal Builder::build() {
    auto list = create_literal();
    return { base, move(list) };
}

unique_ptr<Builder::Node> Builder::create_literal() {
    if (base == Base::decimal) {
        char character = buffer.get();
        auto node = create_digit(character);
        
        buffer.peek();

        if (!buffer.eof()) {
            node->next = create_literal_characters();
        }

        return node;
    } else {
        auto node = create_head();

        char character = buffer.get();
        auto tail = create_digit(character);
        node->push_back(tail);
        
        buffer.peek();

        if (!buffer.eof()) {
            auto end = create_literal_characters();
            node->push_back(end);
        }

        return node;
    }
}

unique_ptr<Builder::Node> Builder::create_head() {
    char character = buffer.get();
    auto node = make_unique<Node>(nullptr, character);

    if (buffer.tellg() < head.value().size()) {
        // Recursion
        node->next = create_head();
    }

    return node;
}

unique_ptr<Builder::Node> Builder::create_literal_characters() {
    char character = buffer.get();
    auto node = create_literal_character(character);

    buffer.peek();
    
    if (!buffer.eof()) {
        // Recursion
        node->next = create_literal_characters();
    }

    return node;
}

unique_ptr<Builder::Node> Builder::create_literal_character(char character) {
    if (character == '_') {
        return make_unique<Node>(nullptr, character);
    } else {
        return create_digit(character);
    }
}

unique_ptr<Builder::Node> Builder::create_digit(char character) {
    auto allowed = allowed_characters();

    if (allowed.contains(character)) {
        return make_unique<Node>(nullptr, character);
    } else {
        string reason = "Not allowed character: ";
        reason.push_back(character);
        throw invalid_argument(reason);
    }
}

CharacterSet Builder::allowed_characters() {
    switch (base) {
        case Base::decimal:
            return { 
                { '0', '9' }
            };
        case Base::hexadecimal:
            return { 
                { '0', '9' },
                { 'A', 'F' },
                { 'a', 'f' },
            };
        case Base::octal:
            return { 
                { '0', '7' }
            };
        case Base::binary:
            return { 
                { '0', '1' }
            };
    }
}