TokenString.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 "Token.hpp"
 
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
#include <ostream>
 
namespace CeresEngine::ShaderCompiler {
 
    void assertReachedEnd(bool reachedEnd);
    void assertCurrentTokenType(const Token::Types type, const Token::Types expectedType);
 
    template<typename TokenType, typename TokenOfInterestFunctor> class BasicTokenString {
    public:
        using ValueType = TokenType;
        using Container = Vector<TokenType>;
 
        class ConstIterator {
        public:
            ConstIterator() = default;
 
            ConstIterator(const ConstIterator&) = default;
            ConstIterator& operator=(const ConstIterator&) = default;
 
            ConstIterator(const typename Container::const_iterator& it, const typename Container::const_iterator& itEnd) : mIt{it}, mItEnd{itEnd} {
                nextTokenOfInterest();
            }
 
            ConstIterator& operator++() {
                if(mIt != mItEnd) {
                    ++mIt;
                    nextTokenOfInterest();
                }
                return *this;
            }
 
            ConstIterator operator++(int) {
                ConstIterator tmp = *this;
                operator++();
                return tmp;
            }
 
            [[nodiscard]] bool reachedEnd() const { return (mIt == mItEnd); }
 
            ValueType acceptIt() {
                assertReachedEnd(reachedEnd());
                return *((*this)++);
            }
 
            ValueType accept(const Token::Types type) {
                assertReachedEnd(reachedEnd());
                assertCurrentTokenType((*mIt)->getType(), type);
                return acceptIt();
            }
 
            const ValueType& operator*() { return *mIt; }
 
            typename Container::const_iterator operator->() { return mIt; }
 
        private:
            void nextTokenOfInterest() {
                while(mIt != mItEnd && !TokenOfInterestFunctor::isOfInterest(*mIt)) {
                    ++mIt;
                }
            }
 
            typename Container::const_iterator mIt, mItEnd;
        };
 
        BasicTokenString() = default;
        BasicTokenString(const BasicTokenString&) = default;
        BasicTokenString& operator=(const BasicTokenString&) = default;
 
        BasicTokenString(const TokenType& token) { pushBack(token); }
 
        [[nodiscard]] ConstIterator begin() const { return ConstIterator(mTokens.begin(), mTokens.end()); }
 
        [[nodiscard]] ConstIterator end() const { return ConstIterator(mTokens.end(), mTokens.end()); }
 
        void pushBack(const TokenType& token) { mTokens.push_back(token); }
 
        void pushBack(const BasicTokenString& tokenString) { mTokens.insert(mTokens.end(), tokenString.mTokens.begin(), tokenString.mTokens.end()); }
 
        void popFront() { mTokens.erase(mTokens.begin()); }
 
        void popBack() { mTokens.pop_back(); }
 
        [[nodiscard]] const ValueType& front() const { return mTokens.front(); }
 
        [[nodiscard]] const ValueType& back() const { return mTokens.back(); }
 
        [[nodiscard]] bool empty() const { return mTokens.empty(); }
 
        [[nodiscard]] const Container& getTokens() const { return mTokens; }
 
        Container& getTokens() { return mTokens; }
 
        // Removes all tokens that are not of interest for the specified token string from the front.
        void trimFront() {
            while(!empty() && !TokenOfInterestFunctor::isOfInterest(front())) {
                popFront();
            }
        }
 
        // Removes all tokens that are not of interest for the specified token string from the back.
        void trimBack() {
            while(!empty() && !TokenOfInterestFunctor::isOfInterest(back())) {
                popBack();
            }
        }
 
    private:
        Container mTokens;
    };
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename TokenType, typename TokenOfInterestFunctor>
    bool operator==(const BasicTokenString<TokenType, TokenOfInterestFunctor>& lhs, const BasicTokenString<TokenType, TokenOfInterestFunctor>& rhs) {
        auto lhsIt = lhs.begin();
        auto rhsIt = rhs.begin();
 
        for(; (!lhsIt.reachedEnd() && !rhsIt.reachedEnd()); ++lhsIt, ++rhsIt) {
            auto lhstoken = lhsIt->get();
            auto rhstoken = rhsIt->get();
 
            if(lhstoken->getType() != rhstoken->getType()) {
                return false;
            }
 
            if(lhstoken->getSpelling() != rhstoken->getSpelling()) {
                return false;
            }
        }
 
        return (lhsIt.reachedEnd() && rhsIt.reachedEnd());
    }
 
    template<typename TokenType, typename TokenOfInterestFunctor>
    bool operator!=(const BasicTokenString<TokenType, TokenOfInterestFunctor>& lhs, const BasicTokenString<TokenType, TokenOfInterestFunctor>& rhs) {
        return !(lhs == rhs);
    }
 
    template<typename TokenType, typename TokenOfInterestFunctor>
    std::ostream& operator<<(std::ostream& lhs, const BasicTokenString<TokenType, TokenOfInterestFunctor>& rhs) {
        for(const auto& token : rhs.getTokens()) {
            lhs << token->getSpelling();
        }
        return lhs;
    }
 
    struct DefaultTokenOfInterestFunctor {
        static bool isOfInterest(const TokenPtr& token);
    };
 
    using TokenPtrString = BasicTokenString<TokenPtr, DefaultTokenOfInterestFunctor>;
 
} // namespace CeresEngine::ShaderCompiler