Merge branch 'master' into feature/better-clargs

* Resolves some conflicts.

miniapp/io.cpp

@@ -13,10 +13,13 @@
 #include "io.hpp"
 
 // Let TCLAP understand value arguments that are of an optional type.
-template <typename V>
-struct TCLAP::ArgTraits<nest::mc::util::optional<V>> {
-    using ValueCategory = ValueLike;
-};
+
+namespace TCLAP {
+    template <typename V>
+    struct ArgTraits<nest::mc::util::optional<V>> {
+        using ValueCategory = ValueLike;
+    };
+}
 
 namespace nest {
 namespace mc {

src/util/nop.hpp

+#pragma once
+
+/*
+ * Provide object that implicitly converts to
+ * a std::function object that does nothing but return a
+ * default-constructed type or void.
+ */
+
+#include <functional>
+
+namespace nest {
+namespace mc {
+namespace util {
+
+static struct nop_function_t {
+    template <typename R, typename... Args>
+    operator std::function<R (Args...)>() const {
+        return [](Args...) { return R{}; };
+    }
+
+    template <typename... Args>
+    operator std::function<void (Args...)>() const {
+        return [](Args...) { };
+    }
+} nop_function;
+
+} // namespace util
+} // namespace mc
+} // namespace nest

tests/unit/CMakeLists.txt

@@ -21,6 +21,7 @@ set(TEST_SOURCES
     test_mask_stream.cpp
     test_matrix.cpp
     test_mechanisms.cpp
+    test_nop.cpp
     test_optional.cpp
     test_parameters.cpp
     test_point.cpp

tests/unit/test_nop.cpp

+#include "gtest.h"
+#include "util/nop.hpp"
+
+using namespace nest::mc::util;
+
+TEST(nop,void_fn) {
+    std::function<void ()> f{nop_function};
+
+    EXPECT_TRUE(f);
+    f(); // should do nothing
+
+    bool flag = false;
+    f = [&]() { flag = true; };
+    f();
+    EXPECT_TRUE(flag);
+
+    flag = false;
+    f = nop_function;
+    f();
+    EXPECT_FALSE(flag);
+
+    // with some arguments
+    std::function<void (int, int)> g{nop_function};
+    EXPECT_TRUE(g);
+    g(2, 3); // should do nothing
+
+    int sum = 0;
+    g = [&](int a, int b) { sum = a+b; };
+    g(2, 3);
+    EXPECT_EQ(5, sum);
+
+    sum = 0;
+    g = nop_function;
+    g(2, 3);
+    EXPECT_EQ(0, sum);
+}
+
+struct check_default {
+    int value = 100;
+
+    check_default() = default;
+    explicit check_default(int n): value(n) {}
+};
+
+TEST(nop,default_return_fn) {
+    std::function<check_default ()> f{nop_function};
+
+    EXPECT_TRUE(f);
+    auto result = f();
+    EXPECT_EQ(result.value, 100);
+
+    f = []() { return check_default(17); };
+    result = f();
+    EXPECT_EQ(result.value, 17);
+
+    f = nop_function;
+    result = f();
+    EXPECT_EQ(result.value, 100);
+
+    std::function<check_default (double, double)> g{nop_function};
+
+    EXPECT_TRUE(g);
+    result = g(1.4, 1.5);
+    EXPECT_EQ(result.value, 100);
+
+    g = [](double x, double y) { return check_default{(int)(x*y)}; };
+    result = g(1.4, 1.5);
+    EXPECT_EQ(result.value, 2);
+
+    g = nop_function;
+    result = g(1.4, 1.5);
+    EXPECT_EQ(result.value, 100);
+
+}
+