Adapted Callbacks interface and Handlers

4 files changed, 133 insertions, 90 deletions

diff --git a/src/core/parser/stack/Callbacks.cpp b/src/core/parser/stack/Callbacks.cpp
index 6ebc549..44b31c6 100644
--- a/src/core/parser/stack/Callbacks.cpp
+++ b/src/core/parser/stack/Callbacks.cpp
@@ -19,5 +19,15 @@
 #include "Callbacks.hpp"
 
 namespace ousia {
+namespace parser_stack {
+
+/* Class ParserCallbacks */
+
+ParserCallbacks::~ParserCallbacks()
+{
+	// Do nothing here
+}
+
+}
 }
 
diff --git a/src/core/parser/stack/Callbacks.hpp b/src/core/parser/stack/Callbacks.hpp
index 9c61000..d7b2547 100644
--- a/src/core/parser/stack/Callbacks.hpp
+++ b/src/core/parser/stack/Callbacks.hpp
@@ -30,66 +30,78 @@
 #define _OUSIA_PARSER_STACK_CALLBACKS_HPP_
 
 #include <string>
+#include <vector>
 
 #include <core/common/Whitespace.hpp>
+#include <core/common/Token.hpp>
 
 namespace ousia {
+
+// Forward declarations
+class Variant;
+
 namespace parser_stack {
 
 /**
- * Interface defining a set of callback functions that act as a basis for the
- * StateStackCallbacks and the ParserCallbacks.
+ * Interface between the Stack class and the underlying parser used for
+ * registering and unregistering tokens.
  */
-class Callbacks {
+class ParserCallbacks {
 public:
 	/**
 	 * Virtual descructor.
 	 */
-	virtual ~Callbacks() {};
-
-	/**
-	 * Sets the whitespace mode that specifies how string data should be
-	 * processed.
-	 *
-	 * @param whitespaceMode specifies one of the three WhitespaceMode constants
-	 * PRESERVE, TRIM or COLLAPSE.
-	 */
-	virtual void setWhitespaceMode(WhitespaceMode whitespaceMode) = 0;
+	virtual ~ParserCallbacks();
 
 	/**
 	 * Registers the given token as token that should be reported to the handler
 	 * using the "token" function.
 	 *
 	 * @param token is the token string that should be reported.
+	 * @return the token id with which the token will be reported. Should return
+	 * Tokens::Empty if the given token could not be registered.
 	 */
-	virtual void registerToken(const std::string &token) = 0;
+	virtual TokenId registerToken(const std::string &token) = 0;
 
 	/**
 	 * Unregisters the given token, it will no longer be reported to the handler
 	 * using the "token" function.
 	 *
-	 * @param token is the token string that should be unregistered.
+	 * @param id is the token id of the token that should be unregistered.
 	 */
-	virtual void unregisterToken(const std::string &token) = 0;
+	virtual void unregisterToken(TokenId id) = 0;
 };
 
 /**
- * Interface defining the callback functions that can be passed from a
- * StateStack to the underlying parser.
+ * Interface defining a set of callback functions that act as a basis for the
+ * StateStackCallbacks and the ParserCallbacks.
  */
-class ParserCallbacks : public Callbacks {
+class HandlerCallbacks: public ParserCallbacks {
+public:
 	/**
-	 * Checks whether the given token is supported by the parser. The parser
-	 * returns true, if the token is supported, false if this token cannot be
-	 * registered. Note that parsers that do not support the registration of
-	 * tokens at all should always return "true".
+	 * Reads a string variant form the current input stream. This function must
+	 * be called from the data() method.
 	 *
-	 * @param token is the token that should be checked for support.
-	 * @return true if the token is generally supported (or the parser does not
-	 * support registering tokens at all), false if the token is not supported,
-	 * because e.g. it is a reserved token or it interferes with other tokens.
+	 * @return a string variant containing the current text data. The return
+	 * value depends on the currently set whitespace mode and the tokens that
+	 * were enabled using the enableTokens callback method.
+	 */
+	Variant readData();
+
+	/**
+	 * Pushes a list of TokenSyntaxDescriptor instances onto the internal stack.
+	 * The tokens described in the token list are the tokens that are currently
+	 * enabled.
+	 *
+	 * @param tokens is a list of TokenSyntaxDescriptor instances that should be
+	 * stored on the stack.
+	 */
+	void pushTokens(const std::vector<TokenSyntaxDescriptor> &tokens);
+
+	/**
+	 * Removes the previously pushed list of tokens from the stack.
 	 */
-	virtual bool supportsToken(const std::string &token) = 0;
+	void popTokens();
 };
 
 }
diff --git a/src/core/parser/stack/Handler.cpp b/src/core/parser/stack/Handler.cpp
index 3d413e8..734976a 100644
--- a/src/core/parser/stack/Handler.cpp
+++ b/src/core/parser/stack/Handler.cpp
@@ -18,6 +18,7 @@
 
 #include <core/common/Exceptions.hpp>
 #include <core/common/Logger.hpp>
+#include <core/common/Variant.hpp>
 #include <core/parser/utils/TokenizedData.hpp>
 #include <core/parser/ParserContext.hpp>
 
@@ -30,11 +31,11 @@ namespace parser_stack {
 
 /* Class HandlerData */
 
-HandlerData::HandlerData(ParserContext &ctx, /*Callbacks &callbacks,*/
+HandlerData::HandlerData(ParserContext &ctx, HandlerCallbacks &callbacks,
                          const std::string &name, const State &state,
                          const SourceLocation &location)
     : ctx(ctx),
-      /*callbacks(callbacks),*/
+      callbacks(callbacks),
       name(name),
       state(state),
       location(location)
@@ -68,19 +69,29 @@ const SourceLocation &Handler::location() const { return handlerData.location; }
 
 const std::string &Handler::name() const { return handlerData.name; }
 
-void Handler::setWhitespaceMode(WhitespaceMode whitespaceMode)
+Variant Handler::readData()
 {
-	/*handlerData.callbacks.setWhitespaceMode(whitespaceMode);*/
+	return handlerData.callbacks.readData();
 }
 
-void Handler::registerToken(const std::string &token)
+void Handler::pushTokens(const std::vector<TokenSyntaxDescriptor> &tokens)
 {
-	/*handlerData.callbacks.registerToken(token);*/
+	handlerData.callbacks.pushTokens(tokens);
 }
 
-void Handler::unregisterToken(const std::string &token)
+void Handler::popTokens()
 {
-	/*handlerData.callbacks.unregisterToken(token);*/
+	handlerData.callbacks.popTokens();
+}
+
+TokenId Handler::registerToken(const std::string &token)
+{
+	return handlerData.callbacks.registerToken(token);
+}
+
+void Handler::unregisterToken(TokenId id)
+{
+	handlerData.callbacks.unregisterToken(id);
 }
 
 const std::string &Handler::getName() const { return name(); }
@@ -131,7 +142,7 @@ bool EmptyHandler::annotationEnd(const Variant &className,
 	return true;
 }
 
-bool EmptyHandler::data(TokenizedData &data)
+bool EmptyHandler::data()
 {
 	// Support any data
 	return true;
@@ -185,13 +196,10 @@ bool StaticHandler::annotationEnd(const Variant &className,
 	return false;
 }
 
-bool StaticHandler::data(TokenizedData &data)
+bool StaticHandler::data()
 {
-	if (data.text(WhitespaceMode::TRIM) != nullptr) {
-		logger().error("Did not expect any data here", data);
-		return false;
-	}
-	return true;
+	logger().error("Did not expect any data here", readData());
+	return false;
 }
 
 /* Class StaticFieldHandler */
@@ -231,19 +239,15 @@ void StaticFieldHandler::end()
 	}
 }
 
-bool StaticFieldHandler::data(TokenizedData &data)
+bool StaticFieldHandler::data()
 {
-	Variant text = data.text(WhitespaceMode::TRIM);
-	if (text == nullptr) {
-		// Providing no data here is ok as long as the "doHandle" callback
-		// function has already been called
-		return handled;
-	}
+	// Fetch the actual text data
+	Variant stringData = readData();
 
 	// Call the doHandle function if this has not been done before
 	if (!handled) {
 		handled = true;
-		doHandle(text, args);
+		doHandle(stringData, args);
 		return true;
 	}
 
@@ -251,7 +255,7 @@ bool StaticFieldHandler::data(TokenizedData &data)
 	logger().error(
 	    std::string("Found data, but the corresponding argument \"") + argName +
 	        std::string("\" was already specified"),
-	    text);
+	    stringData);
 
 	// Print the location at which the attribute was originally specified
 	auto it = args.find(argName);
diff --git a/src/core/parser/stack/Handler.hpp b/src/core/parser/stack/Handler.hpp
index 929466d..848d395 100644
--- a/src/core/parser/stack/Handler.hpp
+++ b/src/core/parser/stack/Handler.hpp
@@ -32,6 +32,7 @@ class ParserScope;
 class ParserContext;
 class Logger;
 class TokenizedData;
+class Variant;
 
 namespace parser_stack {
 
@@ -52,11 +53,11 @@ public:
 	ParserContext &ctx;
 
 	/**
-	 * Reference at an instance of the Callbacks class, used for
-	 * modifying the behaviour of the parser (like registering tokens, setting
-	 * the data type or changing the whitespace handling mode).
+	 * Reference at a class implementing the HandlerCallbacks interface, used
+	 * for modifying the behaviour of the parser (like registering tokens,
+	 * setting the data type or changing the whitespace handling mode).
 	 */
-	//	Callbacks &callbacks;
+	HandlerCallbacks &callbacks;
 
 	/**
 	 * Contains the name of the command that is being handled.
@@ -83,9 +84,9 @@ public:
 	 * @param state is the state this handler was called for.
 	 * @param location is the location at which the handler is created.
 	 */
-	HandlerData(ParserContext &ctx,
-	            /*Callbacks &callbacks,*/ const std::string &name,
-	            const State &state, const SourceLocation &location);
+	HandlerData(ParserContext &ctx, HandlerCallbacks &callbacks,
+	            const std::string &name, const State &state,
+	            const SourceLocation &location);
 };
 
 /**
@@ -160,6 +161,17 @@ protected:
 	const std::string &name() const;
 
 	/**
+	 * Calls the corresponding method in the HandlerCallbacks instance. Reads a
+	 * string variant form the current input stream. This function must be
+	 * called from the data() method.
+	 *
+	 * @return a string variant containing the current text data. The return
+	 * value depends on the currently set whitespace mode and the tokens that
+	 * were enabled using the enableTokens callback method.
+	 */
+	Variant readData();
+
+	/**
 	 * Calls the corresponding function in the Callbacks instance. Sets the
 	 * whitespace mode that specifies how string data should be processed. The
 	 * calls to this function are placed on a stack by the underlying Stack
@@ -170,7 +182,7 @@ protected:
 	 * @param whitespaceMode specifies one of the three WhitespaceMode constants
 	 * PRESERVE, TRIM or COLLAPSE.
 	 */
-	void pushWhitespaceMode(WhitespaceMode whitespaceMode);
+	//	void pushWhitespaceMode(WhitespaceMode whitespaceMode);
 
 	/**
 	 * Pops a previously pushed whitespace mode. Calls to this function should
@@ -178,38 +190,45 @@ protected:
 	 * can only undo pushs that were performed by the pushWhitespaceMode()
 	 * method of the same handler.
 	 */
-	void popWhitespaceMode();
+	//	void popWhitespaceMode();
 
 	/**
-	 * Calls the corresponding function in the Callbacks instance. Sets the
-	 * whitespace mode that specifies how string data should be processed. The
-	 * calls to this function are placed on a stack by the underlying Stack
-	 * class. This function should be called from the "fieldStart" callback and
-	 * the "start" callback. If no whitespace mode is pushed in the "start"
-	 * method the whitespace mode "TRIM" is implicitly assumed.
+	 * Pushes a list of TokenSyntaxDescriptor instances onto the internal stack.
+	 * The tokens described in the token list are the tokens that are currently
+	 * enabled.
 	 *
-	 * @param tokens is a list of tokens that should be reported to this handler
-	 * instance via the "token" method.
+	 * @param tokens is a list of TokenSyntaxDescriptor instances that should be
+	 * stored on the stack.
 	 */
-	void pushTokens(const std::vector<std::string> &tokens);
+	void pushTokens(const std::vector<TokenSyntaxDescriptor> &tokens);
 
 	/**
-	 * Pops a previously pushed whitespace mode. Calls to this function should
-	 * occur in the "end" callback and the "fieldEnd" callback. This function
-	 * can only undo pushs that were performed by the pushWhitespaceMode()
-	 * method of the same handler.
+	 * Calls the corresponding function in the HandlerCallbacks instance.
+	 * Removes the previously pushed list of tokens from the stack.
 	 */
-	void popWhitespaceMode();
+	void popTokens();
 
+	/**
+	 * Calls the corresponding function in the HandlerCallbacks instance. This
+	 * method registers the given tokens as tokens that are generally available,
+	 * tokens must be explicitly enabled using the "pushTokens" and "popTokens"
+	 * method. Tokens that have not been registered are not guaranteed to be
+	 * reported (except for special tokens, these do not have to be registerd).
+	 *
+	 * @param token is the token string that should be made available.
+	 * @return the TokenId that will be used to refer to the token.
+	 */
+	TokenId registerToken(const std::string &token);
 
 	/**
-	 * Calls the corresponding function in the Callbacks instance. This method
-	 * registers the given tokens as tokens that are generally available, tokens
-	 * must be explicitly enabled using the "pushTokens" and "popTokens" method.
-	 * Tokens that have not been registered are not guaranteed to be reported,
-	 * even though they are 
+	 * Calls the corresponding function in the HandlerCallbacks instance. This
+	 * method unregisters the given token. Note that for a token to be no longer
+	 * reported, this function has to be called as many times as registerToken()
+	 * for the corresponding token.
+	 *
+	 * @param id is the id of the Token that should be unregistered.
 	 */
-	void registerTokens(const std::vector<std::string> &tokens);
+	void unregisterToken(TokenId id);
 
 public:
 	/**
@@ -321,13 +340,12 @@ public:
 	/**
 	 * Called whenever raw data (int the form of a string) is available for the
 	 * Handler instance. Should return true if the data could be handled, false
-	 * otherwise.
+	 * otherwise. The actual data variant must be retrieved using the "text()"
+	 * callback.
 	 *
-	 * @param data is an instance of TokenizedData containing the segmented
-	 * character data and its location.
 	 * @return true if the data could be handled, false otherwise.
 	 */
-	virtual bool data(TokenizedData &data) = 0;
+	virtual bool data() = 0;
 };
 
 /**
@@ -357,7 +375,7 @@ public:
 	                     Variant::mapType &args) override;
 	bool annotationEnd(const Variant &className,
 	                   const Variant &elementName) override;
-	bool data(TokenizedData &data) override;
+	bool data() override;
 
 	/**
 	 * Creates an instance of the EmptyHandler class.
@@ -383,7 +401,7 @@ public:
 	                     Variant::mapType &args) override;
 	bool annotationEnd(const Variant &className,
 	                   const Variant &elementName) override;
-	bool data(TokenizedData &data) override;
+	bool data() override;
 };
 
 /**
@@ -430,13 +448,12 @@ protected:
 	 * @param fieldData is the captured field data.
 	 * @param args are the arguments that were given in the "start" function.
 	 */
-	virtual void doHandle(const Variant &fieldData,
-	                      Variant::mapType &args) = 0;
+	virtual void doHandle(const Variant &fieldData, Variant::mapType &args) = 0;
 
 public:
 	bool start(Variant::mapType &args) override;
 	void end() override;
-	bool data(TokenizedData &data) override;
+	bool data() override;
 };
 }
 }