feat: use policy-based error handling in interpolators

Author: fpelliccioni

include/boost/math/interpolators/cubic_hermite.hpp

@@ -8,19 +8,33 @@
 #define BOOST_MATH_INTERPOLATORS_CUBIC_HERMITE_HPP
 #include <memory>
 #include <boost/math/interpolators/detail/cubic_hermite_detail.hpp>
+#include <boost/math/policies/error_handling.hpp>
 
 namespace boost {
 namespace math {
 namespace interpolators {
 
-template<class RandomAccessContainer>
+template<class RandomAccessContainer, class Policy = policies::policy<>>
 class cubic_hermite {
 public:
     using Real = typename RandomAccessContainer::value_type;
 
-    cubic_hermite(RandomAccessContainer && x, RandomAccessContainer && y, RandomAccessContainer && dydx) 
-    : impl_(std::make_shared<detail::cubic_hermite_detail<RandomAccessContainer>>(std::move(x), std::move(y), std::move(dydx)))
-    {}
+    static 
+    std::pair<std::unique_ptr<cubic_hermite>, std::string>
+    create(RandomAccessContainer&& x, RandomAccessContainer&& y, RandomAccessContainer&& dydx)
+    {
+        auto const ret = detail::cubic_hermite_detail<RandomAccessContainer, Policy>::create(
+            std::move(x), std::move(y), std::move(dydx)
+        );
+        const auto& impl = ret.first;
+        const auto& error_msg = ret.second;
+
+        if ( ! impl) {
+            return {nullptr, error_msg};
+        }
+
+        return {std::unique_ptr<cubic_hermite>(new cubic_hermite(impl)), ""};
+    }
 
     inline Real operator()(Real x) const {
         return impl_->operator()(x);
@@ -52,17 +66,33 @@ class cubic_hermite {
     }
 
 private:
+    cubic_hermite(std::shared_ptr<detail::cubic_hermite_detail<RandomAccessContainer>> impl)
+        : impl_(impl)
+    {}
+
     std::shared_ptr<detail::cubic_hermite_detail<RandomAccessContainer>> impl_;
 };
 
-template<class RandomAccessContainer>
+template<class RandomAccessContainer, class Policy = policies::policy<>>
 class cardinal_cubic_hermite {
 public:
     using Real = typename RandomAccessContainer::value_type;
 
-    cardinal_cubic_hermite(RandomAccessContainer && y, RandomAccessContainer && dydx, Real x0, Real dx) 
-    : impl_(std::make_shared<detail::cardinal_cubic_hermite_detail<RandomAccessContainer>>(std::move(y), std::move(dydx), x0, dx))
-    {}
+    static 
+    std::pair<std::unique_ptr<cardinal_cubic_hermite>, std::string>
+    create(RandomAccessContainer && y, RandomAccessContainer && dydx, Real x0, Real dx) {
+        auto const ret = detail::cardinal_cubic_hermite_detail<RandomAccessContainer, Policy>::create(
+            std::move(y), std::move(dydx), x0, dx
+        );
+        const auto& impl = ret.first;
+        const auto& error_msg = ret.second;
+
+        if ( ! impl) {
+            return {nullptr, error_msg};
+        }
+
+        return {std::unique_ptr<cardinal_cubic_hermite>(new cardinal_cubic_hermite(impl)), ""};
+    }
 
     inline Real operator()(Real x) const
     {
@@ -91,19 +121,34 @@ class cardinal_cubic_hermite {
     }
 
 private:
+    cardinal_cubic_hermite(std::shared_ptr<detail::cardinal_cubic_hermite_detail<RandomAccessContainer>> impl)
+        : impl_(impl)
+    {}
+
     std::shared_ptr<detail::cardinal_cubic_hermite_detail<RandomAccessContainer>> impl_;
 };
 
-
-template<class RandomAccessContainer>
+template<class RandomAccessContainer, class Policy = policies::policy<>>
 class cardinal_cubic_hermite_aos {
 public:
     using Point = typename RandomAccessContainer::value_type;
     using Real = typename Point::value_type;
 
-    cardinal_cubic_hermite_aos(RandomAccessContainer && data, Real x0, Real dx) 
-    : impl_(std::make_shared<detail::cardinal_cubic_hermite_detail_aos<RandomAccessContainer>>(std::move(data), x0, dx))
-    {}
+    static 
+    std::pair<std::unique_ptr<cardinal_cubic_hermite_aos>, std::string>
+    create(RandomAccessContainer && data, Real x0, Real dx) {
+        auto const ret = detail::cardinal_cubic_hermite_detail_aos<RandomAccessContainer>::create(
+            std::move(data), x0, dx
+        );
+        const auto& impl = ret.first;
+        const auto& error_msg = ret.second;
+
+        if ( ! impl) {
+            return {nullptr, error_msg};
+        }
+
+        return {std::unique_ptr<cardinal_cubic_hermite_aos>(new cardinal_cubic_hermite_aos(impl)), ""};
+    }
 
     inline Real operator()(Real x) const
     {
@@ -132,6 +177,10 @@ class cardinal_cubic_hermite_aos {
     }
 
 private:
+    cardinal_cubic_hermite_aos(std::shared_ptr<detail::cardinal_cubic_hermite_detail_aos<RandomAccessContainer>> impl)
+        : impl_(impl)
+    {}
+
     std::shared_ptr<detail::cardinal_cubic_hermite_detail_aos<RandomAccessContainer>> impl_;
 };