Provide alternative output for Preprocessor::Process (Issue #7)

Author: bnoazx005

source/tcppLibrary.hpp

@@ -22,11 +22,26 @@
 	not be applied to this library, at least for now. There is a list of unimplemented features placed
 	below
 
+	##Configuration
+
+	There are list of available options presented below. To enable some option just use #define directive before inclusion library's header file.
+	Do not forget to provide this definitions in header files to provide access to specific types in case you need to use them.
+
+	\code
+		#define TCPP_SOME_EXAMPLE_CONFIG
+		//... other configs
+		#define TCPP_IMPLEMENTATION
+		#include "tcppLibrary.hpp
+	\endcode
+
+	* TCPP_OUTPUT_TOKENS_EXTENSION_ENABLED: The config determines which approach is used to provide processed output for a user.
+	Originally Preprocessor::Process returns output data as a std::string's instance. **TokensOutputStream** is returned with Preprocessor::Process
+	in case of TCPP_OUTPUT_TOKENS_EXTENSION_ENABLED is defined
+
 	\todo Implement support of char literals
 	\todo Improve existing performance for massive input files
 	\todo Add support of integral literals like L, u, etc
 	\todo Implement built-in directives like #pragma, #error and others
-	\todo Provide support of variadic macros
 */
 
 #pragma once
@@ -180,9 +195,37 @@ namespace tcpp
 	} TToken, *TTokenPtr;
 
 
-	using TTokensSequence = std::vector<TToken>;
+	using TTokensSequence          = std::vector<TToken>;
+	using TTokensSequenceIter      = TTokensSequence::iterator;
+	using TTokensSequenceConstIter = TTokensSequence::const_iterator;
 
 
+#ifdef TCPP_OUTPUT_TOKENS_EXTENSION_ENABLED
+	
+	class TokensOutputStream
+	{
+		public:
+			explicit TokensOutputStream(TTokensSequence tokens) TCPP_NOEXCEPT;
+
+			// Methods to provide support of iterating over the sequence using for loop
+			TTokensSequenceIter begin() TCPP_NOEXCEPT;
+			TTokensSequenceIter end() TCPP_NOEXCEPT;
+			TTokensSequenceConstIter begin() const TCPP_NOEXCEPT;
+			TTokensSequenceConstIter end() const TCPP_NOEXCEPT;
+			
+			const TToken& GetNextToken() TCPP_NOEXCEPT;
+			const TToken& PeekNextToken(size_t offset = 1) TCPP_NOEXCEPT;
+			bool HasNextToken() const TCPP_NOEXCEPT;
+		
+			const TTokensSequence& GetSequence() const TCPP_NOEXCEPT;
+		private:
+			TTokensSequence mTokens{};
+		private:
+			TTokensSequenceIter mCurrIt{};
+	};
+
+#endif
+
 	/*!
 		class Lexer
 
@@ -340,6 +383,14 @@ namespace tcpp
 			} TIfStackEntry, *TIfStackEntryPtr;
 
 			using TIfStack = std::stack<TIfStackEntry>;
+
+			using TPreprocessResult = 
+#ifdef TCPP_OUTPUT_TOKENS_EXTENSION_ENABLED
+			TokensOutputStream;
+#else
+			TTokensSequence;
+#endif
+
 		public:
 			Preprocessor() TCPP_NOEXCEPT = delete;
 			Preprocessor(const Preprocessor&) TCPP_NOEXCEPT = delete;
@@ -348,8 +399,8 @@ namespace tcpp
 
 			bool AddCustomDirectiveHandler(const std::string& directive, const TDirectiveHandler& handler) TCPP_NOEXCEPT;
 
-			TTokensSequence Process() TCPP_NOEXCEPT;
-			static std::string ToString(const TTokensSequence& tokens) TCPP_NOEXCEPT;
+			TPreprocessResult Process() TCPP_NOEXCEPT;
+			static std::string ToString(const TPreprocessResult& tokens) TCPP_NOEXCEPT;
 
 			Preprocessor& operator= (const Preprocessor&) TCPP_NOEXCEPT = delete;
 
@@ -1157,7 +1208,7 @@ namespace tcpp
 	}
 
 
-	TTokensSequence Preprocessor::Process() TCPP_NOEXCEPT
+	Preprocessor::TPreprocessResult Preprocessor::Process() TCPP_NOEXCEPT
 	{
 		TCPP_ASSERT(mpLexer);
 
@@ -1304,10 +1355,14 @@ namespace tcpp
 			}
 		}
 
+#ifdef TCPP_OUTPUT_TOKENS_EXTENSION_ENABLED
+		return TokensOutputStream{ processedTokens };
+#else
 		return processedTokens;
+#endif
 	}
 
-	std::string Preprocessor::ToString(const TTokensSequence& tokens) TCPP_NOEXCEPT
+	std::string Preprocessor::ToString(const TPreprocessResult& tokens) TCPP_NOEXCEPT
 	{
 		std::string output = EMPTY_STR_VALUE;
 
@@ -2211,5 +2266,66 @@ namespace tcpp
 		return !mConditionalBlocksStack.empty() && (mConditionalBlocksStack.top().mShouldBeSkipped || !mConditionalBlocksStack.top().mIsParentBlockActive);
 	}
 
+
+#ifdef TCPP_OUTPUT_TOKENS_EXTENSION_ENABLED
+
+	TokensOutputStream::TokensOutputStream(TTokensSequence tokens) TCPP_NOEXCEPT
+		: mTokens(std::move(tokens)), mCurrIt(mTokens.begin())
+	{
+	}
+
+	TTokensSequenceIter TokensOutputStream::begin() TCPP_NOEXCEPT
+	{
+		return mTokens.begin();
+	}
+
+	TTokensSequenceIter TokensOutputStream::end() TCPP_NOEXCEPT
+	{
+		return mTokens.end();
+	}
+
+	TTokensSequenceConstIter TokensOutputStream::begin() const TCPP_NOEXCEPT
+	{
+		return mTokens.cbegin();
+	}
+
+	TTokensSequenceConstIter TokensOutputStream::end() const TCPP_NOEXCEPT
+	{
+		return mTokens.cend();
+	}
+
+	const TToken& TokensOutputStream::GetNextToken() TCPP_NOEXCEPT
+	{
+		if (mCurrIt == mTokens.end())
+		{
+			return mTokens.back();
+		}
+
+		return *mCurrIt++;
+	}
+
+	const TToken& TokensOutputStream::PeekNextToken(size_t offset) TCPP_NOEXCEPT
+	{
+		TTokensSequenceIter peekIt = mCurrIt + offset;
+		if (peekIt == mTokens.end())
+		{
+			return mTokens.back();
+		}
+
+		return *peekIt;
+	}
+
+	bool TokensOutputStream::HasNextToken() const TCPP_NOEXCEPT
+	{
+		return mCurrIt != mTokens.end();
+	}
+
+	const TTokensSequence& TokensOutputStream::GetSequence() const TCPP_NOEXCEPT
+	{
+		return mTokens;
+	}
+
+#endif
+
 #endif
 }

tests/CMakeLists.txt

@@ -27,11 +27,14 @@ set(SOURCES
 	"${CMAKE_CURRENT_SOURCE_DIR}/coreTests.cpp"
 	"${CMAKE_CURRENT_SOURCE_DIR}/lexerTests.cpp"
 	"${CMAKE_CURRENT_SOURCE_DIR}/stringInputStreamTests.cpp"
+	"${CMAKE_CURRENT_SOURCE_DIR}/tokensOutputStreamTests.cpp"
 	"${CMAKE_CURRENT_SOURCE_DIR}/main.cpp")
 
 source_group("includes" FILES ${HEADERS})
 source_group("sources" FILES ${SOURCES})
 
+add_definitions(-DTCPP_OUTPUT_TOKENS_EXTENSION_ENABLED)
+
 if (MSVC) 	#cl.exe compiler's options
 
 	#Debug compiler's options
@@ -42,7 +45,6 @@ if (MSVC) 	#cl.exe compiler's options
 	#Release compiler's options
 	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /std:c++14 /permissive- /GS /GL /analyze- /W3 /Gy /Zc:wchar_t /Zi /O2 /sdl /Zc:inline")
 	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /fp:precise /D _WINDLL /D _MBCS /errorReport:prompt /WX- /Zc:forScope /Gd /Oy- /Oi /MD /EHsc /nologo /diagnostics:classic")
-
 endif(MSVC)
 
 

tests/coreTests.cpp

@@ -32,7 +32,7 @@ TEST_CASE("Preprocessor Tests")
 		Lexer lexer(std::make_unique<StringInputStream>(inputSource));
 
 		Preprocessor preprocessor(lexer, { errorCallback });
-		REQUIRE(!preprocessor.Process().empty());
+		REQUIRE(!Preprocessor::ToString(preprocessor.Process()).empty());
 	}
 
 	SECTION("TestProcess_PassSourceWithSimpleMacro_ReturnsSourceWithExpandedMacro")

tests/tokensOutputStreamTests.cpp

@@ -0,0 +1,64 @@
+#include <catch2/catch.hpp>
+#include "tcppLibrary.hpp"
+#include <string>
+
+using namespace tcpp;
+
+
+TEST_CASE("TokensOutputStream Tests")
+{
+	const TTokensSequence tokens
+	{
+		TToken { E_TOKEN_TYPE::COMMENTARY },
+		TToken { E_TOKEN_TYPE::OPEN_BRACKET },
+		TToken { E_TOKEN_TYPE::CLOSE_BRACKET },
+		TToken { E_TOKEN_TYPE::END },
+	};
+
+	TokensOutputStream stream{ tokens };
+
+	SECTION("TestBeginEnd_IterateThroughUsingRangeBasedFor_AllElementsVisited")
+	{
+		int i = 0;
+
+		for (const TToken& currToken : stream)
+		{
+			REQUIRE(currToken.mType == tokens[i++].mType);
+		}
+	}	
+	
+	SECTION("TestGetNextToken_IterateThroughSequence_AllElementsVisited")
+	{
+		int i = 0;
+
+		while (stream.HasNextToken())
+		{
+			REQUIRE(stream.GetNextToken().mType == tokens[i++].mType);
+		}
+	}
+
+	SECTION("TestGetNextToken_TryToGetNextTokenWhenNoItemsRemain_ReturnsLastElement")
+	{
+		int i = 0;
+
+		while (stream.HasNextToken())
+		{
+			REQUIRE(stream.GetNextToken().mType == tokens[i++].mType);
+		}
+
+		REQUIRE(!stream.HasNextToken());
+
+		const TToken& outboundsToken = stream.GetNextToken();
+		REQUIRE(outboundsToken.mType == E_TOKEN_TYPE::END);
+	}
+
+	SECTION("TestPeekNextToken_TryToIterateThroughAllElements_AllElementsVisited")
+	{
+		size_t i = 0;
+
+		for (const TToken& expectedToken : tokens)
+		{
+			REQUIRE(expectedToken.mType == stream.PeekNextToken(i++).mType);
+		}
+	}
+}