PropertyAst.hpp

Go to the documentation of this file.

// @formatter:off
//
// Balau core C++ library
//
// Copyright (C) 2017 Bora Software (contact@borasoftware.com)
//
// Licensed under the Boost Software License - Version 1.0 - August 17th, 2003.
// See the LICENSE file for the full license text.
//


#ifndef COM_BORA_SOFTWARE__BALAU_LANG_PROPERTY_LANG__PROPERTY_AST
#define COM_BORA_SOFTWARE__BALAU_LANG_PROPERTY_LANG__PROPERTY_AST

#include <Balau/Exception/BalauException.hpp>
#include <Balau/Lang/Property/Lang/PropertyToken.hpp>
#include <Balau/Lang/Property/Util/PropertyVisitor.hpp>
#include <Balau/Lang/Common/CodeSpan.hpp>
#include <Balau/Type/Character.hpp>

#include <memory>
#include <string>
#include <vector>

namespace Balau::Lang::Property::AST {

class PropertyNode { // Abstract
    public: virtual ~PropertyNode() = default;

    public: const CodeSpan & getCodeSpan() const {
        return codeSpan;
    }

    public: virtual bool operator == (const PropertyNode & rhs) const {
        return codeSpan == rhs.codeSpan;
    }

    public: bool operator != (const PropertyNode & rhs) const {
        return ! operator == (rhs);
    }

    public: virtual void visit(Payload & payload, PropertyVisitor & visitor) const = 0;

    public: static std::string normalise(std::string_view input) {
        // The output string will be at most the same length as the input string.
        std::string output = std::string(input);
        int inOffset = 0;
        int outOffset = 0;
        char32_t c;

        while (inOffset < (int) input.length()) {
            c = Character::getNextUtf8Safe(input, inOffset);

            if (c == U'\\') {
                if (inOffset == (int) input.length()) {
                    break; // Last character is a backslash.
                }

                c = Character::getNextUtf8Safe(input, inOffset);

                switch (c) {
                    case U'\r':
                    case U'\n': {
                        skipLineContinuation(input, inOffset, output, outOffset);
                        break;
                    }

                    default: {
                        Character::setUtf8AndAdvanceOffset(output, outOffset, c);
                        break;
                    }
                }

            } else {
                Character::setUtf8AndAdvanceOffset(output, outOffset, c);
            }
        }

        output.erase((size_t) outOffset);
        return output;
    }


    public: PropertyNode(const PropertyNode & copy) = delete;
    public: PropertyNode & operator = (const PropertyNode & copy) = delete;

    protected: CodeSpan codeSpan;

    protected: explicit PropertyNode(const CodeSpan & codeSpan_)
        : codeSpan(codeSpan_) {}

    protected: PropertyNode(PropertyNode && rhs) noexcept
        : codeSpan(rhs.codeSpan) {}

    private: static void skipLineContinuation(const std::string_view & input,
                                              int & inOffset,
                                              std::string & output,
                                              int & outOffset) {
        if (inOffset == (int) input.length()) {
            return; // Last character pair is an escaped CR or LF.
        }

        char32_t c = Character::getNextUtf8Safe(input, inOffset);

        if (c == U'\r' || c == U'\n') {
            if (inOffset == (int) input.length()) {
                return; // Last character triplet is an escaped CRLF or LFCR.
            }

            c = Character::getNextUtf8Safe(input, inOffset);
        }

        while (Character::isBlank(c)) {
            if (inOffset == (int) input.length()) {
                return; // End of string.
            }

            c = Character::getNextUtf8Safe(input, inOffset);
        }

        Character::setUtf8AndAdvanceOffset(output, outOffset, c);
    }
};

class Properties final : public PropertyNode {
    public: Properties(const CodeSpan & codeSpan_,
                       std::string && text_,
                       std::vector<std::unique_ptr<PropertyNode>> && nodes_)
        : PropertyNode(codeSpan_)
        , text(std::move(text_))
        , nodes(std::move(nodes_)) {}

    public: const std::string & getText() const {
        return text;
    }

    public: const std::vector<std::unique_ptr<PropertyNode>> & getNodes() const {
        return nodes;
    }

    public: bool operator == (const PropertyNode & rhs) const override {
        auto * o = dynamic_cast<const Properties *>(&rhs);

        bool ret;
        if (o == nullptr) {
            ret = false;
        } else {
            ret = text == o->text
                && PropertyNode::operator == (rhs);
        }

        return ret;
    }

    public: void visit(Payload & payload, PropertyVisitor & visitor) const override {
        visitor.visit(payload, *this);
    }

    private: std::string text;
    private: std::vector<std::unique_ptr<PropertyNode>> nodes;
};

class ValueProperty final : public PropertyNode {
    public: ValueProperty(const CodeSpan & codeSpan_, std::string_view name_, std::string_view value_)
        : PropertyNode(codeSpan_)
        , name(name_)
        , value(value_) {}

    public: ValueProperty(ValueProperty && rhs) noexcept
        : PropertyNode(std::move(rhs))
        , name(rhs.name)
        , value(rhs.value) {}

    public: std::string_view getName() const {
        return name;
    }

    public: std::string_view getValue() const {
        return value;
    }

    public: bool operator == (const PropertyNode & rhs) const override {
        auto * o = dynamic_cast<const ValueProperty *>(&rhs);

        bool ret;
        if (o == nullptr) {
            ret = false;
        } else {
            ret = name == o->name
                && value == o->value
                && PropertyNode::operator == (rhs);
        }

        return ret;
    }

    public: void visit(Payload & payload, PropertyVisitor & visitor) const override {
        visitor.visit(payload, *this);
    }


    public: ValueProperty() = delete;
    public: ValueProperty(const ValueProperty & copy) = delete;
    public: ValueProperty & operator = (const ValueProperty & copy) = delete;

    private: std::string_view name;
    private: std::string_view value;
};

class CompositeProperty final : public PropertyNode {
    public: CompositeProperty(const CodeSpan & codeSpan_,
                              std::string_view name_,
                              std::vector<std::unique_ptr<PropertyNode>> && nodes_)
        : PropertyNode(codeSpan_)
        , name(name_)
        , nodes(std::move(nodes_)) {}

    public: CompositeProperty(CompositeProperty && rhs) noexcept
        : PropertyNode(std::move(rhs))
        , name(rhs.name)
        , nodes(std::move(rhs.nodes)) {}

    public: std::string_view getName() const {
        return name;
    }

    public: const std::vector<std::unique_ptr<PropertyNode>> & getNodes() const {
        return nodes;
    }

    public: bool operator == (const PropertyNode & rhs) const override {
        auto * o = dynamic_cast<const CompositeProperty *>(&rhs);

        bool ret;
        if (o == nullptr) {
            ret = false;
        } else {
            ret = name == o->name
                && nodes == o->nodes
                && PropertyNode::operator == (rhs);
        }

        return ret;
    }

    public: void visit(Payload & payload, PropertyVisitor & visitor) const override {
        visitor.visit(payload, *this);
    }


    public: CompositeProperty() = delete;
    public: CompositeProperty(const CompositeProperty & copy) = delete;
    public: CompositeProperty & operator = (const CompositeProperty & copy) = delete;

    private: std::string_view name;
    private: std::vector<std::unique_ptr<PropertyNode>> nodes;
};

class IncludePropertyNode final : public PropertyNode {
    public: IncludePropertyNode(const CodeSpan & codeSpan_, std::string_view text_)
        : PropertyNode(codeSpan_)
        , text(text_) {}

    public: IncludePropertyNode(IncludePropertyNode && rhs) noexcept
        : PropertyNode(std::move(rhs))
        , text(rhs.text) {}

    public: std::string_view getText() const {
        return text;
    }

    public: bool operator == (const PropertyNode & rhs) const override {
        auto * o = dynamic_cast<const IncludePropertyNode *>(&rhs);

        bool ret;
        if (o == nullptr) {
            ret = false;
        } else {
            ret = text == o->text
                && PropertyNode::operator == (rhs);
        }

        return ret;
    }

    public: void visit(Payload & payload, PropertyVisitor & visitor) const override {
        visitor.visit(payload, *this);
    }


    public: IncludePropertyNode() = delete;
    public: IncludePropertyNode(const IncludePropertyNode & copy) = delete;
    public: IncludePropertyNode & operator = (const IncludePropertyNode & copy) = delete;

    private: std::string_view text;
};

class CommentPropertyNode final : public PropertyNode {
    public: CommentPropertyNode(const CodeSpan & codeSpan_, std::string_view text_)
        : PropertyNode(codeSpan_)
        , text(text_) {}

    public: CommentPropertyNode(CommentPropertyNode && rhs) noexcept
        : PropertyNode(std::move(rhs))
        , text(rhs.text) {}

    public: std::string_view getText() const {
        return text;
    }

    public: bool operator == (const PropertyNode & rhs) const override {
        auto * o = dynamic_cast<const CommentPropertyNode *>(&rhs);

        bool ret;
        if (o == nullptr) {
            ret = false;
        } else {
            ret = text == o->text
                && PropertyNode::operator == (rhs);
        }

        return ret;
    }

    public: void visit(Payload & payload, PropertyVisitor & visitor) const override {
        visitor.visit(payload, *this);
    }


    public: CommentPropertyNode() = delete;
    public: CommentPropertyNode(const CommentPropertyNode & copy) = delete;
    public: CommentPropertyNode & operator = (const CommentPropertyNode & copy) = delete;

    private: std::string_view text;
};

class EmptyLinePropertyNode final : public PropertyNode {
    public: explicit EmptyLinePropertyNode(const CodeSpan & codeSpan_)
        : PropertyNode(codeSpan_) {}

    public: EmptyLinePropertyNode(EmptyLinePropertyNode && rhs) noexcept
        : PropertyNode(std::move(rhs)) {}

    public: bool operator == (const PropertyNode & rhs) const override {
        auto * o = dynamic_cast<const EmptyLinePropertyNode *>(&rhs);

        bool ret;
        if (o == nullptr) {
            ret = false;
        } else {
            ret = PropertyNode::operator == (rhs);
        }

        return ret;
    }

    public: void visit(Payload & payload, PropertyVisitor & visitor) const override {
        visitor.visit(payload, *this);
    }


    public: EmptyLinePropertyNode() = delete;
    public: EmptyLinePropertyNode(const EmptyLinePropertyNode & copy) = delete;
    public: EmptyLinePropertyNode & operator = (const EmptyLinePropertyNode & copy) = delete;
};

} // namespace Balau::Lang::Property::AST

#endif // COM_BORA_SOFTWARE__BALAU_LANG_PROPERTY_LANG__PROPERTY_AST