Improvment of the Token cass

Author: Avi SZYCHTER

include/Token.h

@@ -3,46 +3,100 @@
 
 #include <string>
 
-class Token {
-public:
+struct Token {
+  /**
+   * @brief The different kinds of tokens
+   * The positive and negative numbers represent different types
+   * of tokens but a grammar rule that accepts any kind of number
+   * can use the Number type
+   */
   enum Type {
-      Literal,
+      StringLiteral,
       Separator,
+      PositiveNumber,
+      NegativeNumber,
       Number,
       Identifier,
-      Sign,
+      ArithmeticSign,
       Eof
   };
 
-  Token() = default;
-  Token(Type type, const std::string& image) :
-   type_(type), image_(image) {}
+  /**
+   * @brief Constructs an EOF token.
+   */
+  Token();
+
+  /**
+   * @brief Construct a new token with the given type and image
+   */
+  Token(Type type, const std::string& image = "");
+  
   Token(const Token&) = default;
   Token& operator=(const Token&) = default;
+  Token(Token&&) = default;
+  Token& operator=(Token&&) = default;
 
-  Type type() const {
-    return type_;
-  }
-
-  const std::string& image() const {
-    return image_;
-  }
+  /**
+   * @brief Equality comparison with another token
+   * @see operator== with string and Token::Type
+   */
+  bool operator==(const Token&) const;
+  
+  /**
+   * @return true if the token's image is equal to other
+   * @param other String to compare
+   */
+  bool operator==(const std::string&) const;
+  
+  /**
+   * If the token's type is Number or if other is Number,
+   * then it also matches PositiveNumber and NegativeNumber
+   *  
+   * @return true if the token's type is equal to other
+   * @param other Type to compare
+   */
+  bool operator==(Token::Type) const;
 
-  unsigned long long toUInt() const {
-    return std::stoul(image_);
-  }
+  /**
+   * @see operator==
+   */
+  bool operator!=(const Token&) const;
 
-  long long toInt() const {
-    return std::stol(image_);
-  }
+  /**
+   * @see operator==
+   */
+  bool operator!=(const std::string&) const;
+  
+  /**
+   * @see operator==
+   */
+  bool operator!=(Token::Type) const;
 
-  double toDouble() const {
-    return std::stod(image_);
-  }
+  /**
+   * Using the standard library's functionnalities, parses the 
+   * image to an unsigned integer
+   */
+  unsigned long long toUInt() const;
+  
+  /**
+   * Same as above but outputs a signed integer
+   */
+  long long toInt() const;
+  
+  /**
+   * Same as above but outputs a floating-point number
+   */
+  double toDouble() const;
+  
+  /**
+   * @brief The token's type
+   */
+  Type type;
 
-private:
-  Type type_;
-  std::string image_;
+  /**
+   * @brief The token's image, ie. the string that represents it
+   */
+  std::string image;
 };
 
 #endif

src/parsing/Tokenizer.cpp

@@ -28,6 +28,59 @@ bool isEOF(char c) {
   return c == '\0';
 }
 
+// I decided to move the implementation of of the Token class
+// from Token.h to Tokenizer.cpp
+//    IMPLEMENTATION: Token class
+Token::Token()
+  : type(Token::Eof), image() {}
+
+Token::Token(Token::Type t, const std::string& i)
+  : type(t), image(i) { }
+
+bool Token::operator==(const std::string& other) const {
+  return image == other;
+}
+
+bool Token::operator==(Token::Type other) const {
+  if(type == Number) {
+    return other == Number || other == PositiveNumber || other == NegativeNumber;
+  }
+  else if(other == Number) {
+    return type == Number || type == PositiveNumber || type == NegativeNumber;
+  }
+
+  return type == other;
+}
+
+bool Token::operator==(const Token& other) const {
+  return (*this == other.image) && (*this == other.type);
+}
+
+bool Token::operator!=(const std::string& other) const {
+  return !(*this == other);
+}
+
+bool Token::operator!=(Token::Type other) const {
+  return !(*this == other);
+}
+
+bool Token::operator!=(const Token& other) const {
+  return !(*this == other);
+}
+
+unsigned long long Token::toUInt() const {
+  return std::stoul(image);
+}
+
+long long Token::toInt() const {
+  return std::stol(image);
+}
+
+double Token::toDouble() const {
+  return std::stod(image);
+}
+//    END OF IMPLEMENTATION Token class
+
 Token Tokenizer::getCurrentToken() const {
   return currentToken;
 }
@@ -80,13 +133,13 @@ Token Tokenizer::getNextToken() {
     currentChar = getNextChar();
   }
   else if (currentChar == '+') {
-    currentToken = Token(Token::Sign, std::string(1, currentChar));
+    currentToken = Token(Token::ArithmeticSign, std::string(1, currentChar));
     currentChar = getNextChar();
   }
   else if (currentChar == '-') {
     currentChar = getNextChar();
     if (!isDigit(currentChar))
-      currentToken = Token(Token::Sign, "-");
+      currentToken = Token(Token::ArithmeticSign, "-");
     else { // Negative number
       std::string literal = "-";
       while (isDigit(currentChar) || currentChar == '.') {
@@ -113,7 +166,7 @@ Token Tokenizer::getNextToken() {
       std::cout << "Error in literal parsing: reached EOF before literal end" << std::endl;
     }
 
-    currentToken = Token(Token::Literal, literal);
+    currentToken = Token(Token::StringLiteral, literal);
   }
   else if (isDigit(currentChar)) {
     std::string literal = std::string(1, currentChar);
@@ -172,8 +225,8 @@ void Tokenizer::skipLine() {
 void Tokenizer::skipUntil(const std::string& token) {
   unsigned long long initLine = lineCount();
 
-  while(currentToken.image() != token &&
-        currentToken.type() != Token::Eof) {
+  while(currentToken.image != token &&
+        currentToken.type != Token::Eof) {
     getNextToken();
   }