Begin adding constexpr and noexcept specifiers

Author: toroidal-code

include/child.hpp

@@ -3,7 +3,12 @@
 #define CPPSPEC_CHILD_HPP
 #pragma once
 
+#ifndef CPPSPEC_DEBUG
+#define CPPSPEC_DEBUG false
+#endif
+
 #include <string>
+#include <memory>
 #include <iostream>
 #include <typeinfo>
 
@@ -41,7 +46,6 @@ class Child {
   // All instances of Child start out healthy.
   bool status = true;
 
-  // TODO: Change this to a std::unique_ptr
   Formatters::BaseFormatter *formatter = nullptr;
 
  public:
@@ -57,39 +61,55 @@ class Child {
   Child &operator=(const Child &) = default;
 
   // Custom constructors
-  explicit Child(Child &parent) : parent(&parent) {}
-  explicit Child(Child *parent) : parent(parent) {}
-  explicit Child(const Child *parent) : parent(const_cast<Child *>(parent)) {}
+  explicit Child(Child &parent) noexcept : parent(&parent) {}
+  explicit Child(Child *parent) noexcept : parent(parent) {}
+  explicit Child(const Child *parent) noexcept
+      : parent(const_cast<Child *>(parent)) {}
 
   /*--------- Parent helper functions -------------*/
 
   /** @brief Check to see if the Child has a parent. */
-  const bool has_parent() { return parent != nullptr; }
+  const bool has_parent() noexcept { return parent != nullptr; }
 
   // TODO: Look in to making these references instead of pointer returns
   /** @brief Get the Child's parent. */
-  Child *get_parent() { return parent; }
-  const Child *get_parent() const { return const_cast<Child *>(parent); }
+  constexpr Child *get_parent() noexcept { return parent; }
+  constexpr const Child *get_parent() const noexcept {
+    return const_cast<Child *>(parent);
+  }
+
   template <class C>
-  C get_parent_as();
+  constexpr C get_parent_as() noexcept {
+    return static_cast<C>(get_parent());
+  }
 
   /** @brief Set the Child's parent */
-  void set_parent(Child *parent) { this->parent = parent; }
+  constexpr void set_parent(Child *parent) noexcept { this->parent = parent; }
+  constexpr void set_parent(const Child *parent) noexcept {
+    this->parent = const_cast<Child *>(parent);
+  }
 
   /*--------- Formatter helper functions -----------*/
-  const bool has_formatter();  // Check to see if the tree has a printer
-  Formatters::BaseFormatter &get_formatter();  // Get the printer from the tree
-  void set_printer(Formatters::BaseFormatter &formatter) {
-    this->formatter = &formatter;
+  // Check to see if the tree has a printer
+  constexpr const bool has_formatter() noexcept;
+
+  // Get the printer from the tree
+  constexpr Formatters::BaseFormatter &get_formatter() noexcept;
+
+  constexpr void set_printer(const Formatters::BaseFormatter &formatter) {
+    this->formatter = &const_cast<Formatters::BaseFormatter &>(formatter);
   }
 
   /*--------- Primary member functions -------------*/
 
   /** @brief Get the status of the object (success/failure) */
-  const bool get_status() { return this->status; }
+  constexpr const bool get_status() noexcept { return this->status; }
+  constexpr const bool get_status() const noexcept { return this->status; }
+
+  constexpr void failed() noexcept;  // Report failure to the object.
 
-  void failed();          // Report failure to the object.
-  std::string padding();  // Calculate the padding for printing this object
+  // Calculate the padding for printing this object
+  std::string padding() noexcept;
 };
 
 /*>>>>>>>>>>>>>>>>>>>> Child IMPLEMENTATION <<<<<<<<<<<<<<<<<<<<<<<<<*/
@@ -100,7 +120,7 @@ class Child {
  * This is propogated up the parent/child tree, so that when a child object
  * fails, the parent object is immediately updated to reflect that as well.
  */
-inline void Child::failed() {
+constexpr inline void Child::failed() noexcept {
   this->status = false;
   // propogates the failure up the tree
   if (has_parent()) this->get_parent()->failed();
@@ -110,36 +130,19 @@ inline void Child::failed() {
  * @brief Generate padding (indentation) fore the current object.
  * @return A string of spaces for use in pretty-printing.
  */
-inline std::string Child::padding() {
+inline std::string Child::padding() noexcept {
   return has_parent() ? get_parent()->padding() + "  " : "";
 }
 
-template <class C>
-inline C Child::get_parent_as() {
-  // rejected branch should get optimized out at compile-time
-  if (CPPSPEC_DEBUG) {
-    if (C casted = dynamic_cast<C>(get_parent()))
-      return casted;
-    else
-      throw(std::bad_cast());
-  } else {
-    return static_cast<C>(get_parent());
-  }
-}
-
-inline const bool Child::has_formatter() {
+constexpr inline const bool Child::has_formatter() noexcept {
   if (this->formatter != nullptr) return true;
   if (!this->has_parent()) return false;  // base case;
   return parent->has_formatter();
 }
 
-inline Formatters::BaseFormatter &Child::get_formatter() {
-  if (this->formatter != nullptr) return *formatter;
-  if (!this->has_parent()) {
-    std::cout << "Couldn't get printer!" << std::endl;
-    // base case. This should never *ever* happen
-    throw "Couldn't get printer!";
-  }
+constexpr inline Formatters::BaseFormatter &Child::get_formatter() noexcept {
+  if (this->formatter) return *formatter;
+  if (!this->has_parent()) std::terminate();
   return parent->get_formatter();
 }
 

include/description.hpp

@@ -26,14 +26,14 @@ class Description : public Runnable {
   std::unordered_set<LetBase *> lets;
 
   Description() {}
-  explicit Description(std::string descr) : descr(descr) {}
+  explicit Description(std::string descr) noexcept : descr(descr) {}
   Description(Child &parent, std::string descr, block_t body)
       : Runnable(parent), body(body), descr(descr) {}
 
  public:
-
   // Constructor
-  Description(std::string descr, block_t body) : body(body), descr(descr) {}
+  Description(std::string descr, block_t body) noexcept : body(body),
+                                                          descr(descr) {}
 
   const bool has_subject = false;
   std::deque<rule_block_t> after_alls;
@@ -49,22 +49,13 @@ class Description : public Runnable {
   Result context(T subject, std::function<void(ClassDescription<T> &)> body);
 
   template <class T>
-  Result context(std::string descr, T subject, std::function<void(ClassDescription<T> &)> body);
+  Result context(std::string descr, T subject,
+                 std::function<void(ClassDescription<T> &)> body);
 
   template <class T, typename U>
   Result context(std::initializer_list<U> init_list,
                  std::function<void(ClassDescription<T> &)> body);
 
-  //  template <class T>
-  //  ClassDescription<T> subject(T subject);
-  //
-  //  template <class T>
-  //  ClassDescription<T> subject(T &subject);
-  //
-  //  template <class T>
-  //  ClassDescription<std::vector<T>> subject(std::initializer_list<T>
-  //  init_list);
-
   void before_each(rule_block_t block);
   void before_all(rule_block_t block);
   void after_each(rule_block_t block);

include/let.hpp

@@ -13,10 +13,11 @@ class LetBase {
   bool delivered;
 
  public:
-  LetBase() : delivered(false) {}
+  LetBase() noexcept : delivered(false) {}
   LetBase(const LetBase &copy) = default;
-  void reset() { delivered = false; }
-  bool has_result() { return delivered; }
+  constexpr void reset() noexcept { delivered = false; }
+  constexpr const bool has_result() noexcept { return this->delivered; }
+  constexpr const bool has_result() const noexcept { return this->delivered; }
 };
 
 template <typename T>
@@ -26,19 +27,23 @@ class Let : public LetBase {
 
   block_t body;
 
+  void exec();
+
  public:
-  explicit Let(block_t body) : LetBase(), body(body) {}
+  explicit Let(block_t body) noexcept : LetBase(), body(body) {}
 
   T *operator->() {
     value();
     return result.operator->();
   }
 
-  T &operator*() & { return value(); }
-  void exec();
+  constexpr T &operator*() & { return value(); }
+  constexpr const T &operator*() const & { return value(); }
+
   T &value()&;
 };
 
+/** @brief Executes the block of the let statment */
 template <typename T>
 void Let<T>::exec() {
   if (!delivered) {
@@ -47,6 +52,10 @@ void Let<T>::exec() {
   }
 }
 
+/**
+ * @brief Get the value contained in the Let
+ * @return a reference to the returned object of the let statement
+ */
 template <typename T>
 T &Let<T>::value() & {
   exec();

include/result.hpp

@@ -12,56 +12,58 @@ namespace CppSpec {
 class Result {
   const bool value;
   std::string message;
-  explicit Result(bool value, std::string message = "")
-      : value(value), message(message) {}
+  explicit Result(bool value, std::string message = "") noexcept
+      : value(value),
+        message(message) {}
 
  public:
   // Default destructor
   virtual ~Result() = default;
 
-  // Move constructor/operator
-  Result(Result &&) = default;
-  Result &operator=(Result &&) = default;
-
   // Copy constructor/operator
   Result(const Result &) = default;
   Result &operator=(const Result &) = default;
 
-  /*--------- Message helper functions -------------*/
-  const std::string get_message() { return message; }
-  const std::string get_message() const { return message; }
-  Result &set_message(std::string message);
+  // Move constructor/operator
+  Result(Result &&) = default;
+  Result &operator=(Result &&) = default;
 
   /*--------- Status helper functions --------------*/
-  const bool get_status() { return value; }
-  const bool get_status() const { return value; }
+  constexpr const bool get_status() noexcept { return value; }
+  constexpr const bool get_status() const noexcept { return value; }
 
-  operator bool() { return this->get_status(); }
+  constexpr operator bool() noexcept { return this->get_status(); }
+  constexpr operator bool() const noexcept { return this->get_status(); }
+
+  /*--------- Message helper functions -------------*/
+  const std::string get_message() noexcept { return message; }
+  const std::string get_message() const noexcept { return message; }
+  Result &set_message(std::string message) noexcept;
 
   /*--------- Explicit constructor functions -------*/
-  static Result success();
-  static Result failure();
-  static Result success_with(std::string success_message);
-  static Result failure_with(std::string failure_message);
+  static Result success() noexcept;
+  static Result failure() noexcept;
+  static Result success_with(std::string success_message) noexcept;
+  static Result failure_with(std::string failure_message) noexcept;
 
   /*-------------- Friend functions ----------------*/
 
   // Stream operator
   friend std::ostream &operator<<(std::ostream &os, const Result &res);
 };
 
-inline Result &Result::set_message(std::string message) {
+inline Result &Result::set_message(std::string message) noexcept {
   this->message = message;
   return *this;
 }
 
-inline Result Result::success() { return Result(true); }
-inline Result Result::success_with(std::string success_message) {
+inline Result Result::success() noexcept { return Result(true); }
+inline Result Result::success_with(std::string success_message) noexcept {
   return Result(true, success_message);
 }
 
-inline Result Result::failure() { return Result(false); }
-inline Result Result::failure_with(std::string failure_message) {
+inline Result Result::failure() noexcept { return Result(false); }
+inline Result Result::failure_with(std::string failure_message) noexcept {
   return Result(false, failure_message);
 }
 

include/runnable.hpp

@@ -15,10 +15,10 @@ namespace CppSpec {
  */
 class Runnable : public Child {
  public:
-  Runnable() {}
-  explicit Runnable(Child &parent) : Child(parent) {}
-  explicit Runnable(Child *parent) : Child(parent) {}
-  explicit Runnable(const Child *parent) : Child(parent) {}
+  Runnable() = default;
+  explicit Runnable(Child &parent) noexcept : Child(parent) {}
+  explicit Runnable(Child *parent) noexcept : Child(parent) {}
+  explicit Runnable(const Child *parent) noexcept : Child(parent) {}
   virtual Result run(Formatters::BaseFormatter &printer) = 0;
 };
 

include/runner.hpp

@@ -10,14 +10,17 @@
 
 namespace CppSpec {
 
+/**
+ * @brief A collection of Descriptions that are run in sequence
+ */
 class Runner {
   std::list<Description *> specs;
   Formatters::BaseFormatter &formatter;
 
  public:
   typedef std::function<void(Runner &)> spec_group;
-  explicit Runner(Formatters::BaseFormatter &formatter = Formatters::progress)
-      : formatter(formatter) {}
+  explicit Runner(Formatters::BaseFormatter &formatter =
+                      Formatters::progress) noexcept : formatter(formatter) {}
 
   template <typename T>
   Runner &add_spec(ClassDescription<T> &spec);
@@ -26,12 +29,24 @@ class Runner {
   Result exec();
 };
 
+/**
+ * @brief Add a describe_a suite to the list of suites to run
+ *
+ * @param spec the spec to be added
+ * @return a reference to the modified Runner
+ */
 template <typename T>
 Runner &Runner::add_spec(ClassDescription<T> &spec) {
   specs.push_back(&spec);
   return *this;
 }
 
+/**
+ * @brief Add a Description object
+ *
+ * @param spec the spec to be added
+ * @return a reference to the modified Runner
+ */
 inline Runner &Runner::add_spec(Description &spec) {
   specs.push_back(&spec);
   return *this;

spec/runner.cpp

@@ -5,7 +5,7 @@ extern std::function<void(CppSpec::Runner &)> expectation_spec_group,
     describe_a_spec_group, describe_spec_group;
 
 int main(void) {
-  CppSpec::Runner runner(CppSpec::Formatters::verbose);
+  CppSpec::Runner runner(CppSpec::Formatters::progress);
   expectation_spec_group(runner);
   be_between_spec_group(runner);
   be_within_spec_group(runner);
@@ -14,4 +14,4 @@ int main(void) {
   describe_spec_group(runner);
 
   return runner.exec() ? EXIT_SUCCESS : EXIT_FAILURE;
-}
+}