Wrap up move to C++14

- Minor constexpr additions
- More auto (could have been used in C++11)
- Trailing return types (could have been used in C++11)

Author: lefticus

.clang-tidy

@@ -6,7 +6,6 @@ Checks: "*,
         -fuchsia-*,
         -google-*,
         -llvm*,
-        -modernize-use-trailing-return-type,
         -zircon-*,
         -readability-else-after-return,
         -readability-static-accessed-through-instance,

src/infiz/infiz.cpp

@@ -7,7 +7,7 @@
 
 constexpr int max_line = 255;
 
-int main(int /*argc*/, char * /*args*/[])
+auto main(int /*argc*/, char * /*args*/[]) -> int
 {
   std::array<char, max_line> input{};
 

src/libinfiz/Evaluator.cpp

@@ -3,7 +3,7 @@
 #include <cstdlib>
 
 
-int precedence(Operators input) noexcept
+constexpr auto precedence(Operators input) noexcept -> int
 {
   switch (input) {
   case Operators::CLOSE_PAREN:
@@ -32,7 +32,7 @@ void evaluateStacks(Stack<RationalNumber> &numbers, Stack<Operators> &operators)
     operators.pop();
   }
 
-  while (!operators.empty() && cont && (operators.peek() != nullptr)) {
+  while (operators.peek() != nullptr && cont) {
 
     switch (*operators.peek()) {
     case Operators::OPEN_PAREN:
@@ -82,7 +82,7 @@ void evaluateStacks(Stack<RationalNumber> &numbers, Stack<Operators> &operators)
 }
 
 
-RationalNumber evaluateExpression(StringTokenizer &tokenizer)
+auto evaluateExpression(StringTokenizer &tokenizer) -> RationalNumber
 {
   Stack<Operators> operators;
   Stack<RationalNumber> numbers;

src/libinfiz/Evaluator.hpp

@@ -8,7 +8,7 @@
 enum struct Operators { PLUS_SIGN, CLOSE_PAREN, OPEN_PAREN, MINUS_SIGN, DIVIDE_SIGN, MULTIPLY_SIGN };
 
 
-RationalNumber evaluateExpression(StringTokenizer &tokenizer);
+auto evaluateExpression(StringTokenizer &tokenizer) -> RationalNumber;
 void evaluateStacks(Stack<RationalNumber> &numbers, Stack<Operators> &operators);
 
 #endif

src/libinfiz/RationalNumber.hpp

@@ -15,40 +15,40 @@ class RationalNumber
     : numerator(num), denominator(den)
   {}
 
-  constexpr RationalNumber operator/(const RationalNumber &rhs) const noexcept
+  constexpr auto operator/(const RationalNumber &rhs) const noexcept -> RationalNumber
   {
     return { numerator * rhs.getDenominator(), denominator * rhs.getNumerator() };
   }
 
-  constexpr RationalNumber operator*(const RationalNumber &rhs) const noexcept
+  constexpr auto operator*(const RationalNumber &rhs) const noexcept -> RationalNumber
   {
     return { numerator * rhs.getNumerator(), denominator * rhs.getDenominator() };
   }
 
-  constexpr RationalNumber operator+(const RationalNumber &rhs) const noexcept
+  constexpr auto operator+(const RationalNumber &rhs) const noexcept -> RationalNumber
   {
     return { numerator * rhs.getDenominator() + (rhs.getNumerator() * denominator),
       denominator * rhs.getDenominator() };
   }
 
-  constexpr RationalNumber operator-(const RationalNumber &rhs) const noexcept
+  constexpr auto operator-(const RationalNumber &rhs) const noexcept -> RationalNumber
   {
     return { numerator * rhs.getDenominator() - (rhs.getNumerator() * denominator),
       denominator * rhs.getDenominator() };
   }
 
-  constexpr int getDenominator() const noexcept { return denominator; }
+  constexpr auto getDenominator() const noexcept -> int { return denominator; }
 
-  constexpr RationalNumber operator-() const { return { numerator * -1, denominator }; }
+  constexpr auto operator-() const -> RationalNumber { return { numerator * -1, denominator }; }
 
-  constexpr int getNumerator() const noexcept { return numerator; }
+  constexpr auto getNumerator() const noexcept -> int { return numerator; }
 
-  constexpr float getFloat() const noexcept
+  constexpr auto getFloat() const noexcept -> float
   {
     return ((static_cast<float>(numerator)) / (static_cast<float>(denominator)));
   }
 
-  constexpr bool operator==(const RationalNumber &rhs) const noexcept {
+  constexpr auto operator==(const RationalNumber &rhs) const noexcept -> bool {
     return numerator == rhs.numerator && denominator == rhs.denominator;
   }
 

src/libinfiz/Stack.hpp

@@ -17,27 +17,26 @@ template<typename Contained> class Stack
 public:
   Stack() = default;
 
-  bool empty() const noexcept {
-    return data.empty();
-  }
+  auto empty() const noexcept -> bool { return data.empty(); }
 
-  Contained pop()
+  auto pop() -> Contained
   {
+    // TODO is an assert the best option here?
     assert(!data.empty());
     Contained toReturn = data.back();
     data.pop_back();
     return toReturn;
   }
 
-  template<typename ... Param>
-  Contained &emplace( Param && ... param) {
+  template<typename... Param> auto emplace(Param &&...param) -> Contained &
+  {
     data.emplace_back(std::forward<Param>(param)...);
     return data.back();
   }
 
   void push(const Contained &newElem) { data.push_back(newElem); }
 
-  const Contained *peek() const
+  auto peek() const -> const Contained *
   {
     if (data.empty()) {
       return nullptr;

src/libinfiz/StringTokenizer.cpp

@@ -8,23 +8,7 @@ StringTokenizer::StringTokenizer(std::string n_string) noexcept
   : string(std::move(n_string)), currentOffset(0), moreTokens(true)
 {}
 
-
-std::string StringTokenizer::nextToken()
-{
-  while (currentOffset < string.size() && isWhiteSpace(string[currentOffset])) { ++currentOffset; }
-
-  const auto endOfToken = findTokenEnd(currentOffset, string);
-
-  std::string toReturn = string.substr(currentOffset, endOfToken - currentOffset);
-  currentOffset = endOfToken;
-
-  moreTokens = currentOffset < string.size();
-
-  return toReturn;
-}
-
-
-std::size_t StringTokenizer::findTokenEnd(std::size_t start, const std::string &string)
+auto findTokenEnd(std::size_t start, const std::string &string) -> std::size_t
 {
   if (string.empty()) { return start; }
 
@@ -39,40 +23,15 @@ std::size_t StringTokenizer::findTokenEnd(std::size_t start, const std::string &
 }
 
 
-bool StringTokenizer::isOperator(char input) noexcept
+auto StringTokenizer::nextToken() -> std::string
 {
-  switch (input) {
-  case '+':
-  case '-':
-  case '/':
-  case '*':
-  case '(':
-  case ')':
-    return true;
-  default:
-    return false;
-  }
-}
+  while (currentOffset < string.size() && isWhiteSpace(string[currentOffset])) { ++currentOffset; }
 
+  const auto endOfToken = findTokenEnd(currentOffset, string);
+  auto returnValue = string.substr(currentOffset, endOfToken - currentOffset) ;
+  currentOffset = endOfToken;
+  moreTokens = endOfToken < string.size();
 
-bool StringTokenizer::isNumber(char input) noexcept
-{
-  switch (input) {
-  case '1':
-  case '2':
-  case '3':
-  case '4':
-  case '5':
-  case '6':
-  case '7':
-  case '8':
-  case '9':
-  case '0':
-    return true;
-  default:
-    return false;
-  }
+  return returnValue;
 }
 
-
-bool StringTokenizer::isWhiteSpace(char input) noexcept { return !isNumber(input) && !isOperator(input); }

src/libinfiz/StringTokenizer.hpp

@@ -15,19 +15,55 @@ class StringTokenizer
 public:
   explicit StringTokenizer(std::string n_string) noexcept;
 
-  bool hasMoreTokens() const noexcept { return moreTokens; }
+  auto hasMoreTokens() const noexcept -> bool { return moreTokens; }
 
-  std::string nextToken();
+  auto nextToken() -> std::string;
 
 private:
   std::string string;
   std::size_t currentOffset;
   bool moreTokens;
 
-  static bool isNumber(char input) noexcept;
-  static bool isOperator(char input) noexcept;
-  static bool isWhiteSpace(char input) noexcept;
-  static std::size_t findTokenEnd(std::size_t start, const std::string &);
 };
 
+
+constexpr auto isOperator(char input) noexcept -> bool
+{
+  switch (input) {
+  case '+':
+  case '-':
+  case '/':
+  case '*':
+  case '(':
+  case ')':
+    return true;
+  default:
+    return false;
+  }
+}
+
+
+constexpr auto isNumber(char input) noexcept -> bool
+{
+  switch (input) {
+  case '1':
+  case '2':
+  case '3':
+  case '4':
+  case '5':
+  case '6':
+  case '7':
+  case '8':
+  case '9':
+  case '0':
+    return true;
+  default:
+    return false;
+  }
+}
+
+
+constexpr auto isWhiteSpace(char input) noexcept -> bool { return !isNumber(input) && !isOperator(input); }
+
+
 #endif

test/tests.cpp

@@ -9,7 +9,7 @@
 #include "../src/libinfiz/Evaluator.hpp"
 
 
-RationalNumber evaluate(const std::string &input)
+auto evaluate(const std::string &input) -> RationalNumber
 {
   StringTokenizer tokenizer(input);
   return evaluateExpression(tokenizer);