summaryrefslogtreecommitdiff
path: root/src/utils
diff options
context:
space:
mode:
authorFlorent Le Coz <louiz@louiz.org>2013-11-02 03:19:24 +0100
committerFlorent Le Coz <louiz@louiz.org>2013-11-02 03:19:24 +0100
commit7869ef2ace9a487abb0b489ca432b0a8878c5083 (patch)
treefbb112c8f49266b1bee8303b169b512871d1bd84 /src/utils
downloadbiboumi-7869ef2ace9a487abb0b489ca432b0a8878c5083.tar.gz
biboumi-7869ef2ace9a487abb0b489ca432b0a8878c5083.tar.bz2
biboumi-7869ef2ace9a487abb0b489ca432b0a8878c5083.tar.xz
biboumi-7869ef2ace9a487abb0b489ca432b0a8878c5083.zip
First step of the connection skeleton
Basic connect, socket creating, polling, recving, etc.
Diffstat (limited to 'src/utils')
-rw-r--r--src/utils/scopeguard.hpp89
1 files changed, 89 insertions, 0 deletions
diff --git a/src/utils/scopeguard.hpp b/src/utils/scopeguard.hpp
new file mode 100644
index 0000000..df78831
--- /dev/null
+++ b/src/utils/scopeguard.hpp
@@ -0,0 +1,89 @@
+#ifndef SCOPEGUARD_HPP
+#define SCOPEGUARD_HPP
+
+#include <functional>
+#include <vector>
+
+/**
+ * A class to be used to make sure some functions are called when the scope
+ * is left, because they will be called in the ScopeGuard's destructor. It
+ * can for example be used to delete some pointer whenever any exception is
+ * called. Example:
+
+ * {
+ * ScopeGuard scope;
+ * int* number = new int(2);
+ * scope.add_callback([number]() { delete number; });
+ * // Do some other stuff with the number. But these stuff might throw an exception:
+ * throw std::runtime_error("Some error not caught here, but in our caller");
+ * return true;
+ * }
+
+ * In this example, our pointer will always be deleted, even when the
+ * exception is thrown. If we want the functions to be called only when the
+ * scope is left because of an unexpected exception, we can use
+ * ScopeGuard::disable();
+ */
+
+namespace utils
+{
+
+class ScopeGuard
+{
+public:
+ /**
+ * The constructor can take a callback. But additional callbacks can be
+ * added later with add_callback()
+ */
+ explicit ScopeGuard(std::function<void()>&& func):
+ enabled(true)
+ {
+ this->add_callback(std::move(func));
+ }
+ /**
+ * default constructor, the scope guard is enabled but empty, use
+ * add_callback()
+ */
+ explicit ScopeGuard():
+ enabled(true)
+ {
+ }
+ /**
+ * Call all callbacks in the desctructor, unless it has been disabled.
+ */
+ ~ScopeGuard()
+ {
+ if (this->enabled)
+ for (auto& func: this->callbacks)
+ func();
+ }
+ /**
+ * Add a callback to be called in our destructor, one scope guard can be
+ * used for more than one task, if needed.
+ */
+ void add_callback(std::function<void()>&& func)
+ {
+ this->callbacks.emplace_back(std::move(func));
+ }
+ /**
+ * Disable that scope guard, nothing will be done when the scope is
+ * exited.
+ */
+ void disable()
+ {
+ this->enabled = false;
+ }
+
+private:
+ bool enabled;
+ std::vector<std::function<void()>> callbacks;
+
+ ScopeGuard(const ScopeGuard&) = delete;
+ ScopeGuard& operator=(ScopeGuard&&) = delete;
+ ScopeGuard(ScopeGuard&&) = delete;
+ ScopeGuard& operator=(const ScopeGuard&) = delete;
+};
+
+}
+
+#endif