Implement per-instance error handling

.github/workflows/build-and-test.yml

@@ -24,17 +24,18 @@ jobs:
             config: Debug
             static_lib: OFF
             coverage: ON
-          - os: ubuntu-18.04
+          - os: ubuntu-20.04
             config: Release
             static_lib: ON
             coverage: OFF
+      fail-fast: false
     defaults:
       run:
         shell: bash
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
       - name: Set Project Name
         run: echo "REPOSITORY_NAME=$(echo '${{ github.repository }}' | awk -F '/' '{print $2}')" >> $GITHUB_ENV
       - name: Create Build Directory

.gitmodules

@@ -1,3 +1,6 @@
 [submodule "vendor/googletest"]
 	path = vendor/googletest
 	url = https://github.com/google/googletest.git
+[submodule "vendor/courierr"]
+	path = vendor/courierr
+	url = https://github.com/bigladder/courierr.git

CMakeLists.txt

@@ -29,7 +29,6 @@ if (${PROJECT_NAME}_BUILD_TESTING)
   endif()
 endif()
 
-
 add_subdirectory(src)
 add_subdirectory(vendor)
 

cmake/compiler-flags.cmake

@@ -2,6 +2,6 @@ if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
   if (UNIX)
     add_definitions("-fPIC")
   endif()
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -Wall -Wextra")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra")
 endif()
 

src/CMakeLists.txt

@@ -8,7 +8,6 @@ set(library_sources
   gridpoint.h
   gridpoint.cpp
   error.h
-  error.cpp
 )
 
 option( ${PROJECT_NAME}_STATIC_LIB "Make ${PROJECT_NAME} a static library" ON )
@@ -21,6 +20,8 @@ else()
   add_library(${PROJECT_NAME} SHARED ${library_sources})
 endif()
 
+target_link_libraries(${PROJECT_NAME} PUBLIC courierr fmt)
+
 target_compile_options(btwxt PRIVATE
   $<$<CXX_COMPILER_ID:MSVC>:/W4>
   $<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>,$<CXX_COMPILER_ID:GNU>>:

src/btwxt.cpp

@@ -11,32 +11,40 @@
 
 namespace Btwxt {
 
-RegularGridInterpolator::RegularGridInterpolator() = default;
-
-RegularGridInterpolator::RegularGridInterpolator(GriddedData &grid_data_in)
-    : grid_data(grid_data_in), grid_point(grid_data) {}
+RegularGridInterpolator::RegularGridInterpolator(const std::vector<std::vector<double>> &grid, std::shared_ptr<Courierr::Courierr> messenger)
+    : grid_data(grid, messenger), grid_point(grid_data, messenger), btwxt_logger(messenger) {}
 
 RegularGridInterpolator::RegularGridInterpolator(const std::vector<std::vector<double>> &grid,
-                                                 const std::vector<std::vector<double>> &values)
-    : grid_data(grid, values), grid_point(grid_data) {}
+                                                 const std::vector<std::vector<double>> &values, std::shared_ptr<Courierr::Courierr> messenger)
+    : grid_data(grid, values, messenger)
+    , grid_point(grid_data, messenger)
+    , btwxt_logger(messenger)
+{
+}
 
-RegularGridInterpolator::RegularGridInterpolator(const RegularGridInterpolator &source) {
+RegularGridInterpolator::RegularGridInterpolator(const RegularGridInterpolator &source)
+    : grid_data(source.grid_data), grid_point(source.grid_point), btwxt_logger(source.btwxt_logger) {
   *this = source;
 }
 
-double RegularGridInterpolator::get_value_at_target(std::vector<double> target,
+std::size_t RegularGridInterpolator::add_value_table(const std::vector<double> &value_vector) {
+  return grid_data.add_value_table(value_vector);
+}
+
+double RegularGridInterpolator::get_value_at_target(const std::vector<double>& target,
                                                     std::size_t table_index) {
   set_new_target(target);
-  std::vector<double> result = grid_point.get_results();
-  return result[table_index];
+  auto results = grid_point.get_results();
+  return results[table_index];
 }
 
 double RegularGridInterpolator::get_value_at_target(std::size_t table_index) {
-  std::vector<double> result = grid_point.get_results();
-  return result[table_index];
+  auto results = grid_point.get_results();
+  return results[table_index];
 }
 
-std::vector<double> RegularGridInterpolator::get_values_at_target(const std::vector<double> &target) {
+std::vector<double>
+RegularGridInterpolator::get_values_at_target(const std::vector<double> &target) {
   set_new_target(target);
   return grid_point.get_results();
 }
@@ -45,22 +53,26 @@ std::vector<double> RegularGridInterpolator::get_values_at_target() {
   return grid_point.get_results();
 }
 
-double RegularGridInterpolator::normalize_values_at_target(std::size_t table_index, const std::vector<double> &target, const double scalar) {
+double RegularGridInterpolator::normalize_values_at_target(std::size_t table_index,
+                                                           const std::vector<double> &target,
+                                                           const double scalar) {
   set_new_target(target);
   return normalize_values_at_target(table_index, scalar);
 }
 
-double RegularGridInterpolator::normalize_values_at_target(std::size_t table_index, const double scalar) {
+double RegularGridInterpolator::normalize_values_at_target(std::size_t table_index,
+                                                           const double scalar) {
   return grid_point.normalize_grid_values_at_target(table_index, scalar);
 }
 
-void RegularGridInterpolator::normalize_values_at_target(const std::vector<double> &target, const double scalar) {
+void RegularGridInterpolator::normalize_values_at_target(const std::vector<double> &target,
+                                                         const double scalar) {
   set_new_target(target);
   normalize_values_at_target(scalar);
 }
 
 void RegularGridInterpolator::normalize_values_at_target(const double scalar) {
-  grid_point.normalize_grid_values_at_target(scalar);
+  return grid_point.normalize_grid_values_at_target(scalar);
 }
 
 void RegularGridInterpolator::set_new_target(const std::vector<double> &target) {
@@ -71,16 +83,25 @@ std::vector<double> RegularGridInterpolator::get_current_target() {
   return grid_point.get_current_target();
 }
 
-void RegularGridInterpolator::clear_current_target() { grid_point = GridPoint(grid_data); }
+void RegularGridInterpolator::clear_current_target() {
+  grid_point = GridPoint(grid_data, btwxt_logger);
+}
 
-std::size_t RegularGridInterpolator::get_ndims() { return grid_data.get_ndims(); }
+std::size_t RegularGridInterpolator::get_ndims() const { return grid_data.get_ndims(); }
 
-std::vector<std::vector<short>> &RegularGridInterpolator::get_hypercube() {
-  return grid_point.get_hypercube();
-}
+std::size_t RegularGridInterpolator::get_num_tables() const { return grid_data.get_num_tables(); }
 
 std::pair<double, double> RegularGridInterpolator::get_axis_limits(int dim) {
   return grid_data.get_extrap_limits(dim);
 }
 
+void RegularGridInterpolator::set_logger(std::shared_ptr<Courierr::Courierr> logger, bool set_gridaxes)
+{
+  btwxt_logger = logger;
+  grid_point.set_logger(logger);
+  if (set_gridaxes) {
+    grid_data.set_logger(logger);
+  }
+}
+
 } // namespace Btwxt

src/btwxt.h

@@ -5,36 +5,31 @@
 #define GRIDINTERP_H_
 
 // Standard
+#include <functional>
 #include <vector>
+#include <memory>
+
+#include <courierr/courierr.h>
 
 // btwxt
+#include "error.h"
 #include "griddeddata.h"
 #include "gridpoint.h"
 
 namespace Btwxt {
 
-enum class MsgLevel { MSG_DEBUG, MSG_INFO, MSG_WARN, MSG_ERR };
-extern int LOG_LEVEL;
-
-typedef void (*BtwxtCallbackFunction)(const MsgLevel messageType, const std::string message,
-                                      void *contextPtr);
-
-extern BtwxtCallbackFunction btwxtCallbackFunction;
-extern void *messageCallbackContextPtr;
-
-void setMessageCallback(BtwxtCallbackFunction callbackFunction, void *contextPtr);
-
 // this will be the public-facing class.
 class RegularGridInterpolator {
 public:
-  // GridSpace, GridAxis, AllValueTables, ValueTable are instantiated in RGI constructor.
+  RegularGridInterpolator() = default;
 
-  RegularGridInterpolator();
+  RegularGridInterpolator(GriddedData &grid_data_in, std::shared_ptr<Courierr::Courierr> messenger)
+            : grid_data(grid_data_in), grid_point(grid_data, messenger), btwxt_logger(messenger) {}
 
-  explicit RegularGridInterpolator(GriddedData &grid_data);
+  RegularGridInterpolator(const std::vector<std::vector<double>> &grid, std::shared_ptr<Courierr::Courierr> messenger);
 
   RegularGridInterpolator(const std::vector<std::vector<double>> &grid,
-                          const std::vector<std::vector<double>> &values);
+                          const std::vector<std::vector<double>> &values, std::shared_ptr<Courierr::Courierr> messenger);
 
   RegularGridInterpolator(const RegularGridInterpolator &source);
 
@@ -45,19 +40,34 @@ class RegularGridInterpolator {
 
     grid_data = source.grid_data;
     grid_point = source.grid_point;
+    btwxt_logger = source.btwxt_logger;
     if (source.grid_point.grid_data != nullptr) {
       this->grid_point.grid_data = &this->grid_data;
     }
     return *this;
   }
 
+//  RegularGridInterpolator(RegularGridInterpolator&& source) = delete;
+//
+//  RegularGridInterpolator& operator=(RegularGridInterpolator&& source) {
+//    if (this == &source) {
+//      return *this;
+//    }
+//    grid_data = std::move(source.grid_data);
+//    grid_point = std::move(source.grid_point);
+//    if (source.grid_point.grid_data != nullptr) {
+//      this->grid_point.grid_data = &this->grid_data;
+//    }
+//    callback_function_ = std::move(source.callback_function_); // what happens to the function pointer in members?
+//    caller_context_ = source.caller_context_;
+//    return *this;
+//  }
+
   // Add value table to GriddedData
-  std::size_t add_value_table(std::vector<double> &value_vector) {
-    return grid_data.add_value_table(value_vector);
-  }
+  std::size_t add_value_table(const std::vector<double> &value_vector);
 
   // GridPoint gets instantiated inside calculate_value_at_target
-  double get_value_at_target(std::vector<double> target, std::size_t table_index);
+  double get_value_at_target(const std::vector<double>& target, std::size_t table_index);
 
   double operator()(std::vector<double> target, std::size_t table_index) {
     return get_value_at_target(std::move(target), table_index);
@@ -71,8 +81,8 @@ class RegularGridInterpolator {
 
   std::vector<double> get_values_at_target(const std::vector<double> &target);
 
-  std::vector<double> operator()(const std::vector<double> &target) {
-    return get_values_at_target(target);
+  std::vector<double> operator()(std::vector<double> target) {
+    return get_values_at_target(std::move(target));
   }
 
   std::vector<double> operator()() { return get_values_at_target(); }
@@ -85,25 +95,43 @@ class RegularGridInterpolator {
 
   double normalize_values_at_target(std::size_t table_index, const double scalar = 1.0);
 
-  double normalize_values_at_target(std::size_t table_index, const std::vector<double> &target, const double scalar = 1.0);
+  double normalize_values_at_target(std::size_t table_index, const std::vector<double> &target,
+                                    const double scalar = 1.0);
 
   std::vector<double> get_current_target();
 
   void clear_current_target();
 
-  std::size_t get_ndims();
+  std::size_t get_ndims() const;
+
+  std::size_t get_num_tables() const;
 
   void set_axis_interp_method(std::size_t dim, Method method) {
     grid_data.set_axis_interp_method(dim, method);
   }
 
-  std::vector<std::vector<short>>& get_hypercube();
+  void set_axis_extrap_method(const std::size_t &dim, Method method) {
+    grid_data.set_axis_extrap_method(dim, method);
+  }
+
+  void set_axis_extrap_limits(const std::size_t &dim,
+                              const std::pair<double, double> &extrap_limits) {
+    grid_data.set_axis_extrap_limits(dim, extrap_limits);
+  }
 
   std::pair<double, double> get_axis_limits(int dim);
 
+  void set_logger(std::shared_ptr<Courierr::Courierr> logger, bool set_gridaxes = false);
+
+  Courierr::Courierr& get_logger() { return *btwxt_logger; };
+
 private:
+  friend class TwoDFixtureWithLoggingContext;
+  friend class TwoDFixtureWithLoggingContext_set_message_context_Test;
+
   GriddedData grid_data;
   GridPoint grid_point;
+  std::shared_ptr<Courierr::Courierr> btwxt_logger;
 };
 
 } // namespace Btwxt