CodeWriter.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/Foundation/Function.hpp"
#include "CeresEngine/Foundation/Container/InitializerList.hpp"
#include "CeresEngine/Foundation/Container/List.hpp"
#include "CeresEngine/Foundation/Container/Stack.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
#include <ostream>
 
namespace CeresEngine {
 
    class IndentHandler {
    private:
        String mIndent;
        String mIndentFull;
        Stack<String::size_type> mIndentStack;
 
    public:
        IndentHandler(const String& initialIndent = "  ");
        virtual ~IndentHandler();
 
        void setIndent(const String& indent);
 
        void incrementIndent();
 
        void decrementIndent();
 
        [[nodiscard]] const String& getFullIndent() const;
    };
 
    class ScopedIndent {
    private:
        IndentHandler& mHandler;
 
    public:
        inline ScopedIndent(IndentHandler& handler) : mHandler{handler} { mHandler.incrementIndent(); }
        inline ~ScopedIndent() { mHandler.decrementIndent(); }
    };
 
    // Output code writer.
    class CodeWriter : public IndentHandler {
    public:
        struct Options {
            bool enableNewLine = true;
            bool enableIndent = true;
            bool parseNewLines = true;
        };
 
        using WriterFunctor = FunctionView<void() const>;
 
    private:
        struct AlignedLine {
            String indent;
            Vector<String> parts;
 
            void tab();
            void offsets(Vector<std::size_t>& offsets) const;
 
            AlignedLine& operator<<(const StringView& text);
        };
 
        struct AlignedLineQueue {
            List<AlignedLine> lines;
 
            AlignedLine& current();
        };
 
        struct ScopeState {
            bool scopeCanContinue = false;
            bool scopeUsedBraces = false;
            bool beginLineQueued = false;
            bool endLineQueued = false;
        };
 
        struct ScopeOptions {
            bool compact;
            bool endWithSemicolon;
            bool useBraces;
        };
 
        struct SeparatedList {
            String separator;
            bool isItemPending = false;
        };
 
        std::ostream* mStream = nullptr;
 
        Stack<Options> mOptionsStack;
        bool mOpenLine = true;
 
        UInt32 mLineAlignmentLevel = 0;
        AlignedLineQueue mQueuedAlignedLines;
 
        ScopeState mScopeState;
        Stack<ScopeOptions> mScopeOptionStack;
 
        Stack<SeparatedList> mSeparatedLists;
 
    public:
        // Write new line for each scope.
        bool newLineOpenScope = false;
 
    public:
        CodeWriter();
        explicit CodeWriter(std::ostream& stream);
 
    public:
        void setOutputStream(std::ostream& stream);
 
        void pushOptions(const Options& options);
        void popOptions();
 
        void beginSeparatedList(String separator = ", ");
 
        void endSeparatedList();
 
        void separator();
 
        void beginAlignedLines();
        void endAlignedLines();
 
        void alignLine();
 
        void beginLine();
 
        void endLine();
 
        void write(const StringView& text);
 
        template<typename... Args> inline void write(const StringView& text1, const StringView& text2, const Args&... rest) {
            write(text1);
            write(text2);
            ((void)write(StringView(rest)), ...);
        }
 
        void writeLine(const StringView& text);
 
        void writeJoined(String separator, const InitializerList<WriterFunctor>& functors);
 
        void beginScope(bool compact = false, bool endWithSemicolon = false, bool useBraces = true);
 
        void endScope();
 
        void continueScope();
 
        [[nodiscard]] inline bool isOpenLine() const { return mOpenLine; }
 
    private:
        void writeSeparatorIfPending();
 
        [[nodiscard]] const Options& getCurrentOptions() const;
 
        void flushSeparatedLines(AlignedLineQueue& lineQueue);
 
        // Returns the output stream.
        [[nodiscard]] inline std::ostream& getOutputStream() { return (*mStream); }
    };
 
} // namespace CeresEngine