Simplified Parser interface.

include/plasp/utils/Parser.h

@@ -27,15 +27,20 @@ class Parser
 		size_t row() const;
 		size_t column() const;
 
+		CharacterType currentCharacter() const;
+
 		template<typename Type>
 		Type parse();
 
-		template<class CharacterCondition>
+		template<class WhiteSpacePredicate, class CharacterPredicate>
-		void parseUntil(std::vector<std::string> &container, CharacterCondition characterCondition);
+		std::string parseIdentifier(WhiteSpacePredicate whiteSpacePredicate, CharacterPredicate characterPredicate);
 
 		template<typename Type>
 		void expect(const Type &expectedValue);
 
+		template<class WhiteSpacePredicate>
+		void skipWhiteSpace(WhiteSpacePredicate whiteSpacePredicate);
+
 		void skipWhiteSpace();
 		void skipLine();
 
@@ -63,12 +68,10 @@ class Parser
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-template<class CharacterCondition>
+template<class WhiteSpacePredicate, class CharacterPredicate>
-void Parser::parseUntil(std::vector<std::string> &container, CharacterCondition characterCondition)
+std::string Parser::parseIdentifier(WhiteSpacePredicate whiteSpacePredicate, CharacterPredicate characterPredicate)
 {
-	while (true)
+	skipWhiteSpace(whiteSpacePredicate);
-	{
-		skipWhiteSpace();
 
 	std::string value;
 
@@ -76,21 +79,23 @@ void Parser::parseUntil(std::vector<std::string> &container, CharacterCondition
 	{
 		const auto character = *m_position;
 
-			if (characterCondition(character))
+		if (!characterPredicate(character))
-			{
+			return value;
-				container.emplace_back(std::move(value));
-				return;
-			}
-
-			if (std::isspace(character))
-				break;
 
 		value.push_back(character);
 		advance();
 	}
-
-		container.emplace_back(std::move(value));
 }
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+template<class WhiteSpacePredicate>
+void Parser::skipWhiteSpace(WhiteSpacePredicate whiteSpacePredicate)
+{
+	checkStream();
+
+	while (whiteSpacePredicate(*m_position))
+		advance();
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////

src/plasp/sas/Predicate.cpp

@@ -28,10 +28,21 @@ Predicate Predicate::fromSAS(utils::Parser &parser)
 
 		predicate.m_name = parser.parse<std::string>();
 
-		parser.parseUntil(predicate.m_arguments, [](const auto character)
+		while (true)
 		{
-				return character == '\n';
+			// Parse arguments until reaching newline
+			parser.skipWhiteSpace(
+				[&](const auto character)
+				{
+					return character != '\n' && std::isspace(character);
 				});
+
+			if (parser.currentCharacter() == '\n')
+				break;
+
+			const auto value = parser.parse<std::string>();
+			predicate.m_arguments.emplace_back(std::move(value));
+		}
 	}
 	catch (const std::exception &e)
 	{

src/plasp/utils/Parser.cpp

@@ -54,6 +54,15 @@ size_t Parser::column() const
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+Parser::CharacterType Parser::currentCharacter() const
+{
+	checkStream();
+
+	return *m_position;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 void Parser::checkStream() const
 {
 	if (m_position == EndOfFile)
@@ -100,10 +109,11 @@ bool Parser::advanceIf(CharacterType expectedCharacter)
 
 void Parser::skipWhiteSpace()
 {
-	checkStream();
+	return skipWhiteSpace(
-
+		[](const auto character)
-	while (std::isspace(*m_position))
+		{
-		advance();
+			return std::isspace(character);
+		});
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////