Squashed 'OpenVPN Adapter/Vendors/openvpn/' changes from da99df6..4095565

4095565 OpenVPN 3 client: added tun abstraction layer.
4bfaafc AsioTimer: use expires_after() method when possible.
782e8eb Apple: moved some source files.
f89da96 OpenVPN 3 client: added single-thread mode:
233dfde OpenVPN 3 client: fixed state->session typos.
d689b6d Added new Apple Core Foundation wrappers:
3838a62 i/o layer: added OPENVPN_IO_REQUIRES_STOP compile flag.
138ec96 asiopolysock.hpp: don't call SockOpt::set_cloexec(fd) if fd is undefined (i.e. fd == -1).
10eb723 Apple CF wrapper: renamed OWN/BORROW.
962fe87 Apple CF wrapper: simplify cf.hpp dependency profile.
4fcc99c Objective C++: fix symbol conflicts.
8f63cbb tunwrapasio.hpp: make generic with respect to i/o layer.
67e0013 AsioTimer: added expires_after() method.
fc7eaaf Apple CF wrappers: moved CFRunLoop/CFRunLoopSource wrapper to applecrypto/cf, where all other CF wrappers currently reside.
1215912 Revamped Function (our own functor object) to be more flexible.
10fa276 process.hpp: added compile option to avoid async pipe usage.
9e09451 gwv4.hpp: added missing includes
916856d build script: updated Objective-C support when OBJC=1.

git-subtree-dir: OpenVPN Adapter/Vendors/openvpn
git-subtree-split: 4095565b4de2c7d738e728cae989f632100a8ce8

openvpn/common/function.hpp

@@ -24,36 +24,72 @@
 #ifndef OPENVPN_COMMON_FUNCTION_H
 #define OPENVPN_COMMON_FUNCTION_H
 
+#include <cstddef>  // for std::size_t
+#include <utility>  // for std::move
 #include <new>
-#include <utility>
 
 namespace openvpn {
-  template <typename F>
+  // F -- function type (usually a lambda expression)
+  // N (default=3) -- max size of functor in void* machine words before we overflow to dynamic allocation
+  // INTERN_ONLY (default=false) -- if true, throw a static assertion if functor cannot be stored internally
+  template <typename F, std::size_t N=3, bool INTERN_ONLY=false>
   class Function;
 
-  template <typename R, typename ... A>
-  class Function<R(A...)>
+  template <typename R, typename ... A, std::size_t N, bool INTERN_ONLY>
+  class Function<R(A...), N, INTERN_ONLY>
   {
   public:
-    static constexpr size_t N = 3; // max size of functor in machine words
+    Function() noexcept
+    {
+      methods = nullptr;
+    }
 
     template <typename T>
     Function(T&& functor) noexcept
     {
-      static_assert(sizeof(Intern<T>) <= sizeof(data), "Functor too large");
-      setup_methods<T>();
-      new (data) Intern<T>(std::move(functor));
+      construct(std::move(functor));
     }
 
-    Function(Function&& f) noexcept
+    Function(Function&& other) noexcept
     {
-      methods = f.methods;
-      methods->move(data, f.data);
+      methods = other.methods;
+      other.methods = nullptr;
+      if (methods)
+	methods->move(data, other.data);
+    }
+
+    Function& operator=(Function&& other) noexcept
+    {
+      if (methods)
+	methods->destruct(data);
+      methods = other.methods;
+      other.methods = nullptr;
+      if (methods)
+	methods->move(data, other.data);
+      return *this;
     }
 
     ~Function()
     {
-      methods->destruct(data);
+      if (methods)
+	methods->destruct(data);
+    }
+
+    template <typename T>
+    void reset(T&& functor) noexcept
+    {
+      if (methods)
+	methods->destruct(data);
+      construct(std::move(functor));
+    }
+
+    void reset() noexcept
+    {
+      if (methods)
+	{
+	  methods->destruct(data);
+	  methods = nullptr;
+	}
     }
 
     R operator()(A... args)
@@ -61,7 +97,33 @@ namespace openvpn {
       return methods->invoke(data, args...);
     }
 
+    explicit operator bool() const noexcept
+    {
+      return methods != nullptr;
+    }
+
   private:
+    template <typename T>
+    void construct(T&& functor) noexcept
+    {
+      constexpr bool is_intern = (sizeof(Intern<T>) <= sizeof(data));
+      static_assert(!INTERN_ONLY || is_intern, "Function: Intern<T> doesn't fit in data[] and INTERN_ONLY=true");
+      static_assert(sizeof(Extern<T>) <= sizeof(data), "Function: Extern<T> doesn't fit in data[]");
+
+      if (is_intern)
+	{
+	  // store functor internally (in data)
+	  setup_methods_intern<T>();
+	  new (data) Intern<T>(std::move(functor));
+	}
+      else
+	{
+	  // store functor externally (using new)
+	  setup_methods_extern<T>();
+	  new (data) Extern<T>(std::move(functor));
+	}
+    }
+
     struct Methods
     {
       R (*invoke)(void *, A...);
@@ -70,7 +132,7 @@ namespace openvpn {
     };
 
     template <typename T>
-    void setup_methods()
+    void setup_methods_intern()
     {
       static const struct Methods m = {
 	&Intern<T>::invoke,
@@ -80,15 +142,22 @@ namespace openvpn {
       methods = &m;
     }
 
+    template <typename T>
+    void setup_methods_extern()
+    {
+      static const struct Methods m = {
+	&Extern<T>::invoke,
+	&Extern<T>::move,
+	&Extern<T>::destruct,
+      };
+      methods = &m;
+    }
+
+    // store functor internally (in data)
     template <typename T>
     class Intern
     {
     public:
-      Intern(Intern&& obj) noexcept
-        : functor_(std::move(obj.functor_))
-      {
-      }
-
       Intern(T&& functor) noexcept
         : functor_(std::move(functor))
       {
@@ -116,6 +185,40 @@ namespace openvpn {
       T functor_;
     };
 
+    // store functor externally (using new)
+    template <typename T>
+    class Extern
+    {
+    public:
+      Extern(T&& functor) noexcept
+        : functor_(new T(std::move(functor)))
+      {
+      }
+
+      static R invoke(void *ptr, A... args)
+      {
+	Extern* self = reinterpret_cast<Extern<T>*>(ptr);
+	return (*self->functor_)(args...);
+      }
+
+      static void move(void *dest, void *src)
+      {
+	Extern* d = reinterpret_cast<Extern<T>*>(dest);
+	Extern* s = reinterpret_cast<Extern<T>*>(src);
+	d->functor_ = s->functor_;
+	// no need to set s->functor_=nullptr because parent will not destruct src after move
+      }
+
+      static void destruct(void *ptr)
+      {
+	Extern* self = reinterpret_cast<Extern<T>*>(ptr);
+	delete self->functor_;
+      }
+
+    private:
+      T* functor_;
+    };
+
     const Methods* methods;
     void* data[N];
   };