From 978b5028719b86964844e6a7a4a491a8a2499b12 Mon Sep 17 00:00:00 2001
From: Brendan Moran <brendan.moran@arm.com>
Date: Wed, 11 Nov 2015 15:19:37 +0000
Subject: [PATCH 1/3] Prototype Function Pointer Reduces instance count of
 passed arguments Requires C++11 Allows lambdas Uses virtual inheritance
 instead of member caller

---
 core-util/v2/FunctionPointer.hpp | 101 +++++++++++++++
 core-util/v2/impl/FP0.hpp        | 214 +++++++++++++++++++++++++++++++
 core-util/v2/impl/FP1.hpp        | 209 ++++++++++++++++++++++++++++++
 3 files changed, 524 insertions(+)
 create mode 100644 core-util/v2/FunctionPointer.hpp
 create mode 100644 core-util/v2/impl/FP0.hpp
 create mode 100644 core-util/v2/impl/FP1.hpp

diff --git a/core-util/v2/FunctionPointer.hpp b/core-util/v2/FunctionPointer.hpp
new file mode 100644
index 0000000..63edb89
--- /dev/null
+++ b/core-util/v2/FunctionPointer.hpp
@@ -0,0 +1,101 @@
+/* mbed Microcontroller Library
+ * Copyright (c) 2006-2015 ARM Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef __FUNCTIONPOINTER_HPP__
+#define __FUNCTIONPOINTER_HPP__
+
+#include <string.h>
+#include <stdint.h>
+#include <stddef.h>
+#include <stdarg.h>
+#include <new>
+#include <utility>
+#include <cstdio>
+
+namespace mbed {
+namespace util {
+
+template <typename FunctionType>
+class FunctionPointerInterface;
+
+class FunctionPointerStorage {
+public:
+    // Forward declaration of an unknown class
+    class UnknownClass;
+    // Forward declaration of an unknown member function to this an unknown class
+    // this kind of declaration is authorized by the standard (see 8.3.3/2 of C++ 03 standard).
+    // As a result, the compiler will allocate for UnknownFunctionMember_t the biggest size
+    // and biggest alignment possible for member function.
+    // This type can be used inside unions, it will help to provide the storage
+    // with the proper size and alignment guarantees
+    typedef void (UnknownClass::*UnknownFunctionMember_t)();
+
+    union {
+        void * _static_fp;
+        struct {
+            union {
+                char _member[sizeof(UnknownFunctionMember_t)];
+                UnknownFunctionMember_t _alignementAndSizeGuarantees;
+            };
+            void * _object;
+        } _method;
+        char _functor_storage[sizeof(UnknownFunctionMember_t) + sizeof(void *)];
+        void * _external_functor;
+    };
+};
+
+template <typename FunctionType>
+class FunctionPointerImpl : public FunctionPointerInterface<FunctionType> {
+public:
+    FunctionPointerStorage _fp;
+};
+
+template <typename FunctionType>
+class FPAlignmentAndSize;
+
+template<class T>
+T&& forward(typename std::remove_reference<T>::type& a) noexcept
+{
+    return static_cast<T&&>(a);
+}
+template<class T>
+T&& forward(typename std::remove_reference<T>::type&& a) noexcept
+{
+    return static_cast<T&&>(a);
+}
+
+template<typename FunctionType>
+class FunctionPointer;
+
+template<typename CallableType, size_t>
+class FunctionPointerBind;
+
+template<typename FunctionType>
+class StaticPointer;
+
+template<typename FunctionType, typename C>
+class MethodPointer;
+
+template<typename FunctionType, typename F>
+class FunctorPointer;
+
+
+
+#include "impl/FP0.hpp"
+#include "impl/FP1.hpp"
+} // namespace util
+} // namespace mbed
+
+#endif
diff --git a/core-util/v2/impl/FP0.hpp b/core-util/v2/impl/FP0.hpp
new file mode 100644
index 0000000..5819bee
--- /dev/null
+++ b/core-util/v2/impl/FP0.hpp
@@ -0,0 +1,214 @@
+/* mbed Microcontroller Library
+ * Copyright (c) 2006-2015 ARM Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef __FUNCTIONPOINTER_IMPL_FP0_HPP__
+#define __FUNCTIONPOINTER_IMPL_FP0_HPP__
+#ifndef __FUNCTIONPOINTER_HPP__
+#error FP0.hpp is an internal file that should only be called from inside FunctionPointer.hpp
+#endif
+
+template <typename R>
+class FunctionPointerInterface<R()>{
+public:
+    virtual operator bool() const = 0;
+    virtual bool operator ==(const FunctionPointerInterface &) const = 0;
+    virtual FunctionPointerInterface & operator =(const FunctionPointerInterface &) = 0;
+    virtual R call(void) const = 0;
+    virtual ~FunctionPointerInterface(){};
+    virtual void copy_to(void *) const = 0;
+};
+template <typename R>
+class FPAlignmentAndSize<R()> : public FunctionPointerImpl<R()> {
+    operator bool() const {return false;}
+    bool operator ==(const FunctionPointerInterface<R()> & rhs) const { return false;}
+    FunctionPointerInterface<R()> & operator =(const FunctionPointerInterface<R()> &) { return *this; }
+    R call (void) const { return R();}
+    ~FPAlignmentAndSize() {}
+    void copy_to(void *target) const {
+        new(target) FPAlignmentAndSize(*this);
+    }
+};
+
+template<typename R>
+class FunctionPointer<R()> : FunctionPointerInterface<R()> {
+public:
+    typedef struct arg_struct{
+    } ArgStruct;
+    typedef R(*static_fp)(void);
+
+    FunctionPointer(R (*fp)()) {
+        new(_storage) StaticPointer<R()>(fp);
+    }
+    template <typename C>
+    FunctionPointer(C *c, R (C::*member)()) {
+        new(_storage) MethodPointer<R(), C>(c, member);
+    }
+    template <typename F>
+    FunctionPointer(const F & f) {
+        new(_storage) FunctorPointer<R(), F>(f);
+    }
+    operator bool() const {
+        return *reinterpret_cast<FunctionPointerImpl<R()> *>(&_storage);
+    }
+    bool operator ==(const FunctionPointerInterface<R()> & rhs) const {
+        return *reinterpret_cast<FunctionPointerImpl<R()> *>(&_storage) == rhs;
+    }
+    FunctionPointerInterface<R()> & operator=(const FunctionPointerInterface<R()> & rhs) {
+        reinterpret_cast<FunctionPointerImpl<R()>*>(_storage)->~FunctionPointerImpl<R()>();
+        rhs.copy_to(_storage);
+        return *this;
+    }
+    void copy_to(void *storage) const {
+        reinterpret_cast<FunctionPointerImpl<R()>*>(_storage)->copy_to(storage);
+    }
+    inline R operator ()() const {
+        return call();
+    }
+    R call() const {
+        return reinterpret_cast<FunctionPointerImpl<R()>*>(_storage)->call();
+    }
+    ~FunctionPointer() {
+        reinterpret_cast<FunctionPointerImpl<R()>*>(_storage)->~FunctionPointerImpl<R()>();
+    }
+protected:
+    union {
+        char _storage[sizeof(FPAlignmentAndSize<R()>)];
+        FPAlignmentAndSize<R()> _alignementAndSizeGuarantees;
+    };
+};
+
+/** A class for storing and calling a pointer to a static or member void function without arguments
+ */
+template<typename R>
+class StaticPointer<R()> : public FunctionPointerImpl<R()>{
+public:
+    StaticPointer(R (*function)() = 0)
+    {
+        attach(function);
+    }
+    StaticPointer(const StaticPointer& fp) {
+        *this = fp;
+    }
+    void attach(R (*function)()) {
+        this->_fp._static_fp = (void*)function;
+    }
+    R call() const{
+        return reinterpret_cast<R (*)()>(this->_fp._static_fp)();
+    }
+    R (*get_function() const)() {
+        return this->_fp._static_fp;
+    }
+    operator bool() const {
+        return (this->_fp._static_fp != NULL);
+    }
+    bool operator==(const FunctionPointerInterface<R()> & rhs) const {
+        return (this->_fp._static_fp == static_cast<const StaticPointer *>(&rhs)->_fp._static_fp);
+    }
+    FunctionPointerInterface<R()> & operator = (const FunctionPointerInterface<R()> & rhs) {
+        return *this = static_cast<const StaticPointer &>(rhs);
+    }
+    StaticPointer & operator = (const StaticPointer & rhs) {
+        this->_fp._static_fp = rhs._fp._static_fp;
+        return *this;
+    }
+    void copy_to(void * storage) const {
+        new(storage) StaticPointer(*this);
+    }
+};
+
+template<typename R, typename C>
+class MethodPointer<R(), C> : public FunctionPointerImpl<R()>{
+public:
+    MethodPointer(C *object, R (C::*member)(void))
+    {
+        attach(object, member);
+    }
+    MethodPointer(const MethodPointer& fp) {
+        *this = fp;
+    }
+    void attach(C *object, R (C::*member)(void)) {
+        this->_fp._method._object = (void *) object;
+        *reinterpret_cast<R (C::**)(void)>(this->_fp._method._member) = member;
+    }
+    R call() const{
+        C* o = static_cast<C*>(this->_fp._method._object);
+        R (C::**m)(void) = reinterpret_cast<R (C::**)(void)>(const_cast<char *>(this->_fp._method._member));
+        return (o->**m)();
+    }
+    R (*get_function() const)(){
+        return NULL;
+    }
+    operator bool() const {
+        return (this->_fp._method._object != NULL);
+    }
+    bool operator ==(const FunctionPointerInterface<R()> & rhs) const {
+        return (this->_fp._method._object == static_cast<const MethodPointer *>(&rhs)->_fp._method._object) &&
+            (0 == memcmp(this->_fp._method._member, static_cast<const MethodPointer *>(&rhs)->_fp._method._member, sizeof(this->_fp._method._member)));
+    }
+    MethodPointer & operator = (const MethodPointer & rhs) {
+        this->_fp._method._object = rhs._fp._method._object;
+        memcpy(this->_fp._method._member, rhs._fp._method._member, sizeof(this->_fp._method._member));
+        return *this;
+    }
+    FunctionPointerInterface<R()> & operator = (const FunctionPointerInterface<R()> & rhs) {
+        return *this = *static_cast<const MethodPointer *>(&rhs);
+    }
+    void copy_to(void * storage) const {
+        new(storage) MethodPointer(*this);
+    }
+};
+
+template<typename R, typename F>
+class FunctorPointer<R(), F> : public FunctionPointerImpl<R()>{
+public:
+    FunctorPointer(const F & f)
+    {
+        attach(f);
+    }
+    FunctorPointer(const FunctorPointer & fp) {
+        *this = fp;
+    }
+    void attach(const F & f) {
+        new(this->_fp._functor_storage)F(f);
+    }
+    R call() const{
+        return reinterpret_cast<const F &>(this->_fp._functor_storage)();
+    }
+    R (*get_function() const)(){
+        return NULL;
+    }
+    operator bool() const {
+        return (bool)reinterpret_cast<const F &>(this->_fp._functor_storage);
+    }
+    bool operator ==(const FunctionPointerInterface<R()> & rhs) const {
+        return (reinterpret_cast<const F &>(this->_fp._functor_storage) ==
+                reinterpret_cast<const F &>(static_cast<const FunctorPointer &>(rhs)._fp._functor_storage));
+    }
+    FunctionPointerInterface<R()> & operator = (const FunctionPointerInterface<R()> & rhs) {
+        return *this = *static_cast<const FunctorPointer *>(&rhs);
+    }
+    FunctorPointer & operator = (const FunctorPointer & rhs) {
+        new(this->_fp._functor_storage) F(reinterpret_cast<const F &>(rhs._fp._functor_storage));
+        return *this;
+    }
+
+    void copy_to(void * storage) const {
+        new(storage) FunctorPointer(*this);
+    }
+    ~FunctorPointer() {
+        reinterpret_cast<F*>(this->_fp._functor_storage)->~F();
+    }
+};
+#endif
diff --git a/core-util/v2/impl/FP1.hpp b/core-util/v2/impl/FP1.hpp
new file mode 100644
index 0000000..c732090
--- /dev/null
+++ b/core-util/v2/impl/FP1.hpp
@@ -0,0 +1,209 @@
+/* mbed Microcontroller Library
+ * Copyright (c) 2006-2015 ARM Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef __FUNCTIONPOINTER_IMPL_FP1_HPP__
+#define __FUNCTIONPOINTER_IMPL_FP1_HPP__
+#ifndef __FUNCTIONPOINTER_HPP__
+#error FP1.hpp is an internal file that should only be called from inside FunctionPointer.hpp
+#endif
+
+template <typename R, typename A1>
+class FunctionPointerInterface<R(A1)> : protected FunctionPointerStorage {
+public:
+    virtual operator bool() const = 0;
+    virtual bool operator ==(const FunctionPointerInterface &) const = 0;
+    virtual FunctionPointerInterface & operator =(const FunctionPointerInterface &) = 0;
+    virtual R call(A1&&) const = 0;
+    virtual ~FunctionPointerInterface(){};
+protected:
+    virtual void copy_to(void *) const = 0;
+};
+
+template <typename R, typename A1>
+class FPAlignmentAndSize<R(A1)> : public FunctionPointerImpl<R(A1)> {
+    operator bool() const {return false;}
+    bool operator ==(const FunctionPointerInterface<R(A1)> & rhs) const { return false;}
+    FunctionPointerInterface<R(A1)> & operator =(const FunctionPointerInterface<R(A1)> &) { return *this; }
+    R call (A1&&) const { return R();}
+    ~FPAlignmentAndSize() {}
+protected:
+    void copy_to(void *target) const {
+        new(target) FPAlignmentAndSize(*this);
+    }
+};
+
+
+template <typename R, typename A1>
+class FunctionPointer<R(A1)> {
+public:
+    typedef struct arg_struct{
+    } ArgStruct;
+    typedef R(*static_fp)(A1);
+    FunctionPointer(R (*fp)(A1)) {
+        new(_storage) StaticPointer<R(A1)>(fp);
+    }
+    template <typename C>
+    FunctionPointer(C *c, R (C::*member)(A1)) {
+        new(_storage) MethodPointer<R(A1), C>(c, member);
+    }
+    template <typename F>
+    FunctionPointer(const F & f) {
+        new(_storage) FunctorPointer<R(A1), F>(f);
+    }
+    operator bool() const {
+        return *reinterpret_cast<FunctionPointerImpl<R(A1)> *>(const_cast<char *>(_storage));
+    }
+    bool operator ==(const FunctionPointerInterface<R(A1)> & rhs) const {
+        return *reinterpret_cast<FunctionPointerImpl<R(A1)> *>(const_cast<char *>(_storage)) == rhs;
+    }
+    inline R operator ()(A1&& a1) const {
+        return call(forward<A1&&>(a1));
+    }
+    R call(A1&& a1) const {
+        return reinterpret_cast<FunctionPointerImpl<R(A1)>*>(_storage)->call(forward<A1&&>(a1));
+    }
+    ~FunctionPointer() {
+        reinterpret_cast<FunctionPointerImpl<R(A1)>*>(_storage)->~FunctionPointerImpl<R(A1)>();
+    }
+protected:
+    union {
+        char _storage[sizeof(FPAlignmentAndSize<R(A1)>)];
+        FPAlignmentAndSize<R(A1)> _alignementAndSizeGuarantees;
+    };
+};
+
+/** A class for storing and calling a pointer to a static or member void function without arguments
+ */
+template <typename R, typename A1>
+class StaticPointer<R(A1)> : public FunctionPointerImpl<R(A1)>{
+public:
+    StaticPointer(R (*function)(A1) = 0)
+    {
+        attach(function);
+    }
+    StaticPointer(const StaticPointer& fp) {
+        *this = fp;
+    }
+    void attach(R (*function)(A1)) {
+        this->_fp._static_fp = (void*)function;
+    }
+    R call(A1&& a1) const{
+        R (*f)(A1) = reinterpret_cast<R (*)(A1)>(this->_fp._static_fp);
+        return f(forward<A1>(a1));
+    }
+    R (*get_function() const)(A1) {
+        return this->_fp._static_fp;
+    }
+    operator bool() const {
+        return (this->_fp._static_fp != NULL);
+    }
+    bool operator==(const FunctionPointerInterface<R(A1)> & rhs) const {
+        return (this->_fp._static_fp == static_cast<const StaticPointer *>(&rhs)->_fp._static_fp);
+    }
+    FunctionPointerInterface<R(A1)> & operator = (const FunctionPointerInterface<R(A1)> & rhs) {
+        return *this = static_cast<const StaticPointer &>(rhs);
+    }
+    StaticPointer & operator = (const StaticPointer & rhs) {
+        this->_fp._static_fp = rhs._fp._static_fp;
+        return *this;
+    }
+    void copy_to(void * storage) const {
+        new(storage) StaticPointer(*this);
+    }
+};
+
+template<typename R, typename A1, typename C>
+class MethodPointer<R(A1), C> : public FunctionPointerImpl<R(A1)>{
+public:
+    MethodPointer(C *object, R (C::*member)(A1))
+    {
+        attach(object, member);
+    }
+    MethodPointer(const MethodPointer& fp) {
+        MethodPointer::operator=(fp);
+    }
+    void attach(C *object, R (C::*member)(A1)) {
+        this->_fp._method._object = (void *) object;
+        *reinterpret_cast<R (C::**)(A1)>(this->_fp._method._member) = member;
+    }
+    R call(A1&& a1) const{
+        C* o = static_cast<C*>(this->_fp._method._object);
+        R (C::**m)(A1) = reinterpret_cast<R (C::**)(A1)>(const_cast<char *>(this->_fp._method._member));
+        return (o->**m)(forward<A1>(a1));
+    }
+    R (*get_function() const)(){
+        return NULL;
+    }
+    operator bool() const {
+        return (this->_fp._method._object != NULL);
+    }
+    bool operator ==(const FunctionPointerInterface<R(A1)> & rhs) const {
+        return (this->_fp._method._object == static_cast<const MethodPointer *>(&rhs)->_method._object) &&
+            (0 == memcmp(this->_fp._method._member, static_cast<const MethodPointer *>(&rhs)->_method._member, sizeof(this->_fp._method._member)));
+    }
+    MethodPointer & operator = (const MethodPointer & rhs) {
+        this->_fp._method._object = rhs._fp._method._object;
+        memcpy(this->_fp._method._member, rhs._fp._method._member, sizeof(this->_fp._method._member));
+        return *this;
+    }
+    FunctionPointerInterface<R(A1)> & operator = (const FunctionPointerInterface<R(A1)> & rhs) {
+        return *this = *static_cast<const MethodPointer *>(&rhs);
+    }
+    void copy_to(void * storage) const {
+        new(storage) MethodPointer(*this);
+    }
+};
+
+template<typename R, typename A1, typename F>
+class FunctorPointer<R(A1), F> : public FunctionPointerImpl<R(A1)>{
+public:
+    FunctorPointer(const F & f)
+    {
+        attach(f);
+    }
+    FunctorPointer(const FunctorPointer & fp) {
+        *this = fp;
+    }
+    void attach(const F & f) {
+        new(this->_fp._functor_storage)F(f);
+    }
+    R call(A1&& a1) const{
+        return reinterpret_cast<const F &>(this->_fp._functor_storage)(forward<A1>(a1));
+    }
+    R (*get_function() const)(){
+        return NULL;
+    }
+    operator bool() const {
+        return (bool)reinterpret_cast<const F &>(this->_fp._functor_storage);
+    }
+    bool operator ==(const FunctionPointerInterface<R(A1)> & rhs) const {
+        return (reinterpret_cast<const F &>(this->_fp._functor_storage) ==
+                reinterpret_cast<const F &>(static_cast<const FunctorPointer *>(&rhs)->_fp._functor_storage));
+    }
+    FunctionPointerInterface<R(A1)> & operator = (const FunctionPointerInterface<R(A1)> & rhs) {
+        return *this = *static_cast<const FunctorPointer *>(&rhs);
+    }
+    FunctorPointer & operator = (const FunctorPointer & rhs) {
+        new(this->_fp._functor_storage) F(reinterpret_cast<const F &>(rhs._fp._functor_storage));
+        return *this;
+    }
+    void copy_to(void * storage) const {
+        new(storage) FunctorPointer(*this);
+    }
+    ~FunctorPointer() {
+        reinterpret_cast<F*>(this->_fp._functor_storage)->~F();
+    }
+};
+#endif

From 974cd4e78842c0a268fdbb7fad3411a836614dad Mon Sep 17 00:00:00 2001
From: Brendan Moran <brendan.moran@arm.com>
Date: Thu, 12 Nov 2015 09:25:34 +0000
Subject: [PATCH 2/3] Improvements to support bind Remove templates from size
 guarantee object Move implementation details into an impl namespace Support
 large functors

---
 core-util/v2/FunctionPointer.hpp |  25 +++---
 core-util/v2/impl/FP0.hpp        | 139 ++++++++++++++++++-------------
 core-util/v2/impl/FP1.hpp        | 122 +++++++++++++++++----------
 3 files changed, 170 insertions(+), 116 deletions(-)

diff --git a/core-util/v2/FunctionPointer.hpp b/core-util/v2/FunctionPointer.hpp
index 63edb89..d2797ee 100644
--- a/core-util/v2/FunctionPointer.hpp
+++ b/core-util/v2/FunctionPointer.hpp
@@ -23,10 +23,13 @@
 #include <new>
 #include <utility>
 #include <cstdio>
+#include <type_traits>
 
 namespace mbed {
 namespace util {
 
+
+namespace impl{
 template <typename FunctionType>
 class FunctionPointerInterface;
 
@@ -43,6 +46,7 @@ class FunctionPointerStorage {
     typedef void (UnknownClass::*UnknownFunctionMember_t)();
 
     union {
+
         void * _static_fp;
         struct {
             union {
@@ -56,15 +60,15 @@ class FunctionPointerStorage {
     };
 };
 
-template <typename FunctionType>
-class FunctionPointerImpl : public FunctionPointerInterface<FunctionType> {
+class FunctionPointerSize0 {
 public:
     FunctionPointerStorage _fp;
+    virtual void nullmethod()=0;
+};
+class FunctionPointerSize : public FunctionPointerSize0 {
+public:
+    void nullmethod() {}
 };
-
-template <typename FunctionType>
-class FPAlignmentAndSize;
-
 template<class T>
 T&& forward(typename std::remove_reference<T>::type& a) noexcept
 {
@@ -76,12 +80,6 @@ T&& forward(typename std::remove_reference<T>::type&& a) noexcept
     return static_cast<T&&>(a);
 }
 
-template<typename FunctionType>
-class FunctionPointer;
-
-template<typename CallableType, size_t>
-class FunctionPointerBind;
-
 template<typename FunctionType>
 class StaticPointer;
 
@@ -90,7 +88,10 @@ class MethodPointer;
 
 template<typename FunctionType, typename F>
 class FunctorPointer;
+}
 
+template<typename FunctionType>
+class FunctionPointer;
 
 
 #include "impl/FP0.hpp"
diff --git a/core-util/v2/impl/FP0.hpp b/core-util/v2/impl/FP0.hpp
index 5819bee..c42d33d 100644
--- a/core-util/v2/impl/FP0.hpp
+++ b/core-util/v2/impl/FP0.hpp
@@ -19,80 +19,69 @@
 #error FP0.hpp is an internal file that should only be called from inside FunctionPointer.hpp
 #endif
 
-template <typename R>
-class FunctionPointerInterface<R()>{
-public:
-    virtual operator bool() const = 0;
-    virtual bool operator ==(const FunctionPointerInterface &) const = 0;
-    virtual FunctionPointerInterface & operator =(const FunctionPointerInterface &) = 0;
-    virtual R call(void) const = 0;
-    virtual ~FunctionPointerInterface(){};
-    virtual void copy_to(void *) const = 0;
-};
-template <typename R>
-class FPAlignmentAndSize<R()> : public FunctionPointerImpl<R()> {
-    operator bool() const {return false;}
-    bool operator ==(const FunctionPointerInterface<R()> & rhs) const { return false;}
-    FunctionPointerInterface<R()> & operator =(const FunctionPointerInterface<R()> &) { return *this; }
-    R call (void) const { return R();}
-    ~FPAlignmentAndSize() {}
-    void copy_to(void *target) const {
-        new(target) FPAlignmentAndSize(*this);
-    }
-};
-
 template<typename R>
-class FunctionPointer<R()> : FunctionPointerInterface<R()> {
+class FunctionPointer<R()> {
 public:
     typedef struct arg_struct{
     } ArgStruct;
     typedef R(*static_fp)(void);
 
     FunctionPointer(R (*fp)()) {
-        new(_storage) StaticPointer<R()>(fp);
+        new(_storage) impl::StaticPointer<R()>(fp);
     }
     template <typename C>
     FunctionPointer(C *c, R (C::*member)()) {
-        new(_storage) MethodPointer<R(), C>(c, member);
+        new(_storage) impl::MethodPointer<R(), C>(c, member);
     }
     template <typename F>
     FunctionPointer(const F & f) {
-        new(_storage) FunctorPointer<R(), F>(f);
+        new(_storage) impl::FunctorPointer<R(), F>(f);
     }
     operator bool() const {
-        return *reinterpret_cast<FunctionPointerImpl<R()> *>(&_storage);
+        return *reinterpret_cast<impl::FunctionPointerInterface<R()> *>(&_storage);
     }
-    bool operator ==(const FunctionPointerInterface<R()> & rhs) const {
-        return *reinterpret_cast<FunctionPointerImpl<R()> *>(&_storage) == rhs;
+    bool operator ==(const FunctionPointer<R()> & rhs) const {
+        return *reinterpret_cast<impl::FunctionPointerInterface<R()> *>(&_storage) ==
+            *reinterpret_cast<impl::FunctionPointerInterface<R()> *>(rhs.storage);
     }
-    FunctionPointerInterface<R()> & operator=(const FunctionPointerInterface<R()> & rhs) {
-        reinterpret_cast<FunctionPointerImpl<R()>*>(_storage)->~FunctionPointerImpl<R()>();
+    FunctionPointer<R()> & operator=(const FunctionPointer<R()> & rhs) {
+        reinterpret_cast<impl::FunctionPointerInterface<R()>*>(_storage)->~FunctionPointerInterface<R()>();
         rhs.copy_to(_storage);
         return *this;
     }
-    void copy_to(void *storage) const {
-        reinterpret_cast<FunctionPointerImpl<R()>*>(_storage)->copy_to(storage);
-    }
     inline R operator ()() const {
         return call();
     }
     R call() const {
-        return reinterpret_cast<FunctionPointerImpl<R()>*>(_storage)->call();
+        return reinterpret_cast<impl::FunctionPointerInterface<R()>*>(_storage)->call();
     }
     ~FunctionPointer() {
-        reinterpret_cast<FunctionPointerImpl<R()>*>(_storage)->~FunctionPointerImpl<R()>();
+        reinterpret_cast<impl::FunctionPointerInterface<R()>*>(_storage)->~FunctionPointerInterface<R()>();
     }
 protected:
     union {
-        char _storage[sizeof(FPAlignmentAndSize<R()>)];
-        FPAlignmentAndSize<R()> _alignementAndSizeGuarantees;
+        char _storage[sizeof(impl::FunctionPointerSize)];
+        impl::FunctionPointerSize _alignementAndSizeGuarantees;
     };
 };
 
+namespace impl {
+template <typename R>
+class FunctionPointerInterface<R()>{
+public:
+    virtual operator bool() const = 0;
+    virtual bool operator ==(const FunctionPointerInterface &) const = 0;
+    virtual R call(void) const = 0;
+    virtual ~FunctionPointerInterface(){};
+    virtual void copy_to(void *) const = 0;
+protected:
+    FunctionPointerStorage _fp;
+};
+
 /** A class for storing and calling a pointer to a static or member void function without arguments
  */
 template<typename R>
-class StaticPointer<R()> : public FunctionPointerImpl<R()>{
+class StaticPointer<R()> : public FunctionPointerInterface<R()>{
 public:
     StaticPointer(R (*function)() = 0)
     {
@@ -116,9 +105,6 @@ class StaticPointer<R()> : public FunctionPointerImpl<R()>{
     bool operator==(const FunctionPointerInterface<R()> & rhs) const {
         return (this->_fp._static_fp == static_cast<const StaticPointer *>(&rhs)->_fp._static_fp);
     }
-    FunctionPointerInterface<R()> & operator = (const FunctionPointerInterface<R()> & rhs) {
-        return *this = static_cast<const StaticPointer &>(rhs);
-    }
     StaticPointer & operator = (const StaticPointer & rhs) {
         this->_fp._static_fp = rhs._fp._static_fp;
         return *this;
@@ -129,7 +115,7 @@ class StaticPointer<R()> : public FunctionPointerImpl<R()>{
 };
 
 template<typename R, typename C>
-class MethodPointer<R(), C> : public FunctionPointerImpl<R()>{
+class MethodPointer<R(), C> : public FunctionPointerInterface<R()>{
 public:
     MethodPointer(C *object, R (C::*member)(void))
     {
@@ -162,16 +148,16 @@ class MethodPointer<R(), C> : public FunctionPointerImpl<R()>{
         memcpy(this->_fp._method._member, rhs._fp._method._member, sizeof(this->_fp._method._member));
         return *this;
     }
-    FunctionPointerInterface<R()> & operator = (const FunctionPointerInterface<R()> & rhs) {
-        return *this = *static_cast<const MethodPointer *>(&rhs);
-    }
     void copy_to(void * storage) const {
         new(storage) MethodPointer(*this);
     }
 };
 
+
+
 template<typename R, typename F>
-class FunctorPointer<R(), F> : public FunctionPointerImpl<R()>{
+class FunctorPointer<R(), F> : public FunctionPointerInterface<R()>{
+    constexpr static const bool Internal = sizeof(F) <= sizeof(impl::FunctionPointerStorage);
 public:
     FunctorPointer(const F & f)
     {
@@ -180,35 +166,72 @@ class FunctorPointer<R(), F> : public FunctionPointerImpl<R()>{
     FunctorPointer(const FunctorPointer & fp) {
         *this = fp;
     }
-    void attach(const F & f) {
+    template <typename T = F>
+    typename std::enable_if<Internal && std::is_same<T,F>::value>::type
+    attach(const F & f)
+    {
         new(this->_fp._functor_storage)F(f);
     }
+    template <typename T = F>
+    typename std::enable_if<!Internal && std::is_same<T,F>::value>::type
+    attach(const F & f) {
+        this->_fp._external_functor = new F(f);
+    }
     R call() const{
-        return reinterpret_cast<const F &>(this->_fp._functor_storage)();
+        return const_ref()();
     }
     R (*get_function() const)(){
         return NULL;
     }
     operator bool() const {
-        return (bool)reinterpret_cast<const F &>(this->_fp._functor_storage);
+        return true;
     }
     bool operator ==(const FunctionPointerInterface<R()> & rhs) const {
-        return (reinterpret_cast<const F &>(this->_fp._functor_storage) ==
-                reinterpret_cast<const F &>(static_cast<const FunctorPointer &>(rhs)._fp._functor_storage));
-    }
-    FunctionPointerInterface<R()> & operator = (const FunctionPointerInterface<R()> & rhs) {
-        return *this = *static_cast<const FunctorPointer *>(&rhs);
+        return false;
     }
     FunctorPointer & operator = (const FunctorPointer & rhs) {
-        new(this->_fp._functor_storage) F(reinterpret_cast<const F &>(rhs._fp._functor_storage));
+        deallocate();
+        attach(*reinterpret_cast<const F *>(rhs._fp._functor_storage));
         return *this;
     }
-
+    ~FunctorPointer() {
+        deallocate();
+    }
     void copy_to(void * storage) const {
         new(storage) FunctorPointer(*this);
     }
-    ~FunctorPointer() {
+protected:
+    template <typename T = F>
+    typename std::enable_if<Internal && std::is_same<T,F>::value, const F &>::type
+    const_ref() const{
+        return *reinterpret_cast<const F *>(this->_fp._functor_storage);
+    }
+    template <typename T = F>
+    typename std::enable_if<Internal && std::is_same<T,F>::value, F &>::type
+    ref() {
+        return *reinterpret_cast<F *>(this->_fp._functor_storage);
+    }
+    template <typename T = F>
+    typename std::enable_if<Internal && std::is_same<T,F>::value>::type
+    deallocate() {
         reinterpret_cast<F*>(this->_fp._functor_storage)->~F();
     }
+
+    template <typename T = F>
+    typename std::enable_if<!Internal && std::is_same<T,F>::value, const F &>::type
+    const_ref() const{
+        return *reinterpret_cast<const F *>(this->_fp._external_functor);
+    }
+    template <typename T = F>
+    typename std::enable_if<!Internal && std::is_same<T,F>::value, F &>::type
+    ref() {
+        return *reinterpret_cast<F *>(this->_fp._external_functor);
+    }
+    template <typename T = F>
+    typename std::enable_if<!Internal && std::is_same<T,F>::value>::type
+    deallocate() {
+        reinterpret_cast<F*>(this->_fp._external_functor)->~F();
+    }
 };
+}
 #endif
diff --git a/core-util/v2/impl/FP1.hpp b/core-util/v2/impl/FP1.hpp
index c732090..900df58 100644
--- a/core-util/v2/impl/FP1.hpp
+++ b/core-util/v2/impl/FP1.hpp
@@ -19,32 +19,6 @@
 #error FP1.hpp is an internal file that should only be called from inside FunctionPointer.hpp
 #endif
 
-template <typename R, typename A1>
-class FunctionPointerInterface<R(A1)> : protected FunctionPointerStorage {
-public:
-    virtual operator bool() const = 0;
-    virtual bool operator ==(const FunctionPointerInterface &) const = 0;
-    virtual FunctionPointerInterface & operator =(const FunctionPointerInterface &) = 0;
-    virtual R call(A1&&) const = 0;
-    virtual ~FunctionPointerInterface(){};
-protected:
-    virtual void copy_to(void *) const = 0;
-};
-
-template <typename R, typename A1>
-class FPAlignmentAndSize<R(A1)> : public FunctionPointerImpl<R(A1)> {
-    operator bool() const {return false;}
-    bool operator ==(const FunctionPointerInterface<R(A1)> & rhs) const { return false;}
-    FunctionPointerInterface<R(A1)> & operator =(const FunctionPointerInterface<R(A1)> &) { return *this; }
-    R call (A1&&) const { return R();}
-    ~FPAlignmentAndSize() {}
-protected:
-    void copy_to(void *target) const {
-        new(target) FPAlignmentAndSize(*this);
-    }
-};
-
-
 template <typename R, typename A1>
 class FunctionPointer<R(A1)> {
 public:
@@ -52,42 +26,56 @@ class FunctionPointer<R(A1)> {
     } ArgStruct;
     typedef R(*static_fp)(A1);
     FunctionPointer(R (*fp)(A1)) {
-        new(_storage) StaticPointer<R(A1)>(fp);
+        new(_storage) impl::StaticPointer<R(A1)>(fp);
     }
     template <typename C>
     FunctionPointer(C *c, R (C::*member)(A1)) {
-        new(_storage) MethodPointer<R(A1), C>(c, member);
+        new(_storage) impl::MethodPointer<R(A1), C>(c, member);
     }
     template <typename F>
     FunctionPointer(const F & f) {
-        new(_storage) FunctorPointer<R(A1), F>(f);
+        new(_storage) impl::FunctorPointer<R(A1), F>(f);
     }
     operator bool() const {
-        return *reinterpret_cast<FunctionPointerImpl<R(A1)> *>(const_cast<char *>(_storage));
+        return *reinterpret_cast<impl::FunctionPointerInterface<R(A1)> *>(const_cast<char *>(_storage));
     }
-    bool operator ==(const FunctionPointerInterface<R(A1)> & rhs) const {
-        return *reinterpret_cast<FunctionPointerImpl<R(A1)> *>(const_cast<char *>(_storage)) == rhs;
+    bool operator ==(const impl::FunctionPointerInterface<R(A1)> & rhs) const {
+        return *reinterpret_cast<impl::FunctionPointerInterface<R(A1)> *>(const_cast<char *>(_storage)) == rhs;
     }
     inline R operator ()(A1&& a1) const {
-        return call(forward<A1&&>(a1));
+        return call(impl::forward<A1&&>(a1));
     }
     R call(A1&& a1) const {
-        return reinterpret_cast<FunctionPointerImpl<R(A1)>*>(_storage)->call(forward<A1&&>(a1));
+        return reinterpret_cast<impl::FunctionPointerInterface<R(A1)>*>(_storage)->call(impl::forward<A1&&>(a1));
     }
     ~FunctionPointer() {
-        reinterpret_cast<FunctionPointerImpl<R(A1)>*>(_storage)->~FunctionPointerImpl<R(A1)>();
+        reinterpret_cast<impl::FunctionPointerInterface<R(A1)>*>(_storage)->~FunctionPointerInterface<R(A1)>();
     }
 protected:
     union {
-        char _storage[sizeof(FPAlignmentAndSize<R(A1)>)];
-        FPAlignmentAndSize<R(A1)> _alignementAndSizeGuarantees;
+        char _storage[sizeof(impl::FunctionPointerSize)];
+        impl::FunctionPointerSize _alignementAndSizeGuarantees;
     };
 };
 
+namespace impl {
+template <typename R, typename A1>
+class FunctionPointerInterface<R(A1)> : protected impl::FunctionPointerStorage {
+public:
+    virtual operator bool() const = 0;
+    virtual bool operator ==(const FunctionPointerInterface &) const = 0;
+    virtual FunctionPointerInterface & operator =(const FunctionPointerInterface &) = 0;
+    virtual R call(A1&&) const = 0;
+    virtual ~FunctionPointerInterface(){};
+    virtual void copy_to(void *) const = 0;
+protected:
+    impl::FunctionPointerStorage _fp;
+};
+
 /** A class for storing and calling a pointer to a static or member void function without arguments
  */
 template <typename R, typename A1>
-class StaticPointer<R(A1)> : public FunctionPointerImpl<R(A1)>{
+class StaticPointer<R(A1)> : public FunctionPointerInterface<R(A1)>{
 public:
     StaticPointer(R (*function)(A1) = 0)
     {
@@ -125,7 +113,7 @@ class StaticPointer<R(A1)> : public FunctionPointerImpl<R(A1)>{
 };
 
 template<typename R, typename A1, typename C>
-class MethodPointer<R(A1), C> : public FunctionPointerImpl<R(A1)>{
+class MethodPointer<R(A1), C> : public FunctionPointerInterface<R(A1)>{
 public:
     MethodPointer(C *object, R (C::*member)(A1))
     {
@@ -167,7 +155,8 @@ class MethodPointer<R(A1), C> : public FunctionPointerImpl<R(A1)>{
 };
 
 template<typename R, typename A1, typename F>
-class FunctorPointer<R(A1), F> : public FunctionPointerImpl<R(A1)>{
+class FunctorPointer<R(A1), F> : public FunctionPointerInterface<R(A1)>{
+    constexpr static const bool Internal = sizeof(F) <= sizeof(impl::FunctionPointerStorage);
 public:
     FunctorPointer(const F & f)
     {
@@ -176,34 +165,75 @@ class FunctorPointer<R(A1), F> : public FunctionPointerImpl<R(A1)>{
     FunctorPointer(const FunctorPointer & fp) {
         *this = fp;
     }
-    void attach(const F & f) {
+    template <typename T = F>
+    typename std::enable_if<Internal && std::is_same<T,F>::value>::type
+    attach(const F & f)
+    {
         new(this->_fp._functor_storage)F(f);
     }
+    template <typename T = F>
+    typename std::enable_if<!Internal && std::is_same<T,F>::value>::type
+    attach(const F & f) {
+        this->_fp._external_functor = new F(f);
+    }
     R call(A1&& a1) const{
-        return reinterpret_cast<const F &>(this->_fp._functor_storage)(forward<A1>(a1));
+        return const_ref()(forward<A1>(a1));
     }
     R (*get_function() const)(){
         return NULL;
     }
     operator bool() const {
-        return (bool)reinterpret_cast<const F &>(this->_fp._functor_storage);
+        return true;
     }
     bool operator ==(const FunctionPointerInterface<R(A1)> & rhs) const {
-        return (reinterpret_cast<const F &>(this->_fp._functor_storage) ==
-                reinterpret_cast<const F &>(static_cast<const FunctorPointer *>(&rhs)->_fp._functor_storage));
+        return false;
     }
     FunctionPointerInterface<R(A1)> & operator = (const FunctionPointerInterface<R(A1)> & rhs) {
         return *this = *static_cast<const FunctorPointer *>(&rhs);
     }
     FunctorPointer & operator = (const FunctorPointer & rhs) {
-        new(this->_fp._functor_storage) F(reinterpret_cast<const F &>(rhs._fp._functor_storage));
+        deallocate();
+        attach(rhs.const_ref());
         return *this;
     }
     void copy_to(void * storage) const {
         new(storage) FunctorPointer(*this);
     }
     ~FunctorPointer() {
+        deallocate();
+    }
+protected:
+    template <typename T = F>
+    typename std::enable_if<Internal && std::is_same<T,F>::value, const F &>::type
+    const_ref() const{
+        return *reinterpret_cast<const F *>(this->_fp._functor_storage);
+    }
+    template <typename T = F>
+    typename std::enable_if<Internal && std::is_same<T,F>::value, F &>::type
+    ref() {
+        return *reinterpret_cast<F *>(this->_fp._functor_storage);
+    }
+    template <typename T = F>
+    typename std::enable_if<Internal && std::is_same<T,F>::value>::type
+    deallocate() {
         reinterpret_cast<F*>(this->_fp._functor_storage)->~F();
     }
+
+    template <typename T = F>
+    typename std::enable_if<!Internal && std::is_same<T,F>::value, const F &>::type
+    const_ref() const{
+        return *reinterpret_cast<const F *>(this->_fp._external_functor);
+    }
+    template <typename T = F>
+    typename std::enable_if<!Internal && std::is_same<T,F>::value, F &>::type
+    ref() {
+        return *reinterpret_cast<F *>(this->_fp._external_functor);
+    }
+    template <typename T = F>
+    typename std::enable_if<!Internal && std::is_same<T,F>::value>::type
+    deallocate() {
+        reinterpret_cast<F*>(this->_fp._external_functor)->~F();
+    }
 };
+}
 #endif

From 1278d532b619e703433cb8e37f04f9ab134f30ae Mon Sep 17 00:00:00 2001
From: Brendan Moran <brendan.moran@arm.com>
Date: Tue, 17 Nov 2015 22:12:24 +0000
Subject: [PATCH 3/3] Updates to allow binding in Function Pointer Add padding
 size as a template parameter to Function Pointer Add some utility methods to
 FunctionPointer Add a FPFunctor class, which acts like FunctionPointerBind
 Remove erroneous inheritance from FunctionPointerStorage

---
 core-util/v2/FunctionPointer.hpp |  28 ++++---
 core-util/v2/impl/FP0.hpp        |  49 +++++++------
 core-util/v2/impl/FP1.hpp        | 121 ++++++++++++++++++++-----------
 3 files changed, 120 insertions(+), 78 deletions(-)

diff --git a/core-util/v2/FunctionPointer.hpp b/core-util/v2/FunctionPointer.hpp
index d2797ee..3bedb5b 100644
--- a/core-util/v2/FunctionPointer.hpp
+++ b/core-util/v2/FunctionPointer.hpp
@@ -30,9 +30,8 @@ namespace util {
 
 
 namespace impl{
-template <typename FunctionType>
-class FunctionPointerInterface;
 
+template<size_t I = 0>
 class FunctionPointerStorage {
 public:
     // Forward declaration of an unknown class
@@ -46,7 +45,6 @@ class FunctionPointerStorage {
     typedef void (UnknownClass::*UnknownFunctionMember_t)();
 
     union {
-
         void * _static_fp;
         struct {
             union {
@@ -55,19 +53,24 @@ class FunctionPointerStorage {
             };
             void * _object;
         } _method;
-        char _functor_storage[sizeof(UnknownFunctionMember_t) + sizeof(void *)];
+        char _raw_storage[sizeof(void*) + sizeof(UnknownFunctionMember_t) + I];
         void * _external_functor;
     };
 };
 
+template<size_t I = 0>
 class FunctionPointerSize0 {
 public:
-    FunctionPointerStorage _fp;
+    FunctionPointerStorage<I> _fp;
     virtual void nullmethod()=0;
 };
-class FunctionPointerSize : public FunctionPointerSize0 {
+
+template<size_t I = 0>
+class FunctionPointerSize : public FunctionPointerSize0<I> {
 public:
     void nullmethod() {}
+    FunctionPointerSize(){}
+    FunctionPointerSize(const FunctionPointerSize &){}
 };
 template<class T>
 T&& forward(typename std::remove_reference<T>::type& a) noexcept
@@ -79,18 +82,23 @@ T&& forward(typename std::remove_reference<T>::type&& a) noexcept
 {
     return static_cast<T&&>(a);
 }
+template <typename FunctionType, size_t I = 0>
+class FunctionPointerInterface;
 
-template<typename FunctionType>
+template<typename FunctionType, size_t I = 0>
 class StaticPointer;
 
-template<typename FunctionType, typename C>
+template<typename FunctionType, typename C, size_t I = 0>
 class MethodPointer;
 
-template<typename FunctionType, typename F>
+template<typename FunctionType, typename F, size_t I = 0>
 class FunctorPointer;
 }
 
-template<typename FunctionType>
+template <typename OutputSignature, typename InputSignature, size_t I>
+class FPFunctor;
+
+template<typename FunctionType, size_t I = 0>
 class FunctionPointer;
 
 
diff --git a/core-util/v2/impl/FP0.hpp b/core-util/v2/impl/FP0.hpp
index c42d33d..46b29a7 100644
--- a/core-util/v2/impl/FP0.hpp
+++ b/core-util/v2/impl/FP0.hpp
@@ -19,23 +19,23 @@
 #error FP0.hpp is an internal file that should only be called from inside FunctionPointer.hpp
 #endif
 
-template<typename R>
-class FunctionPointer<R()> {
+template<typename R, size_t I>
+class FunctionPointer<R(), I> {
 public:
     typedef struct arg_struct{
     } ArgStruct;
     typedef R(*static_fp)(void);
 
     FunctionPointer(R (*fp)()) {
-        new(_storage) impl::StaticPointer<R()>(fp);
+        new(_storage) impl::StaticPointer<R(), I>(fp);
     }
     template <typename C>
     FunctionPointer(C *c, R (C::*member)()) {
-        new(_storage) impl::MethodPointer<R(), C>(c, member);
+        new(_storage) impl::MethodPointer<R(), C, I>(c, member);
     }
     template <typename F>
     FunctionPointer(const F & f) {
-        new(_storage) impl::FunctorPointer<R(), F>(f);
+        new(_storage) impl::FunctorPointer<R(), F, I>(f);
     }
     operator bool() const {
         return *reinterpret_cast<impl::FunctionPointerInterface<R()> *>(&_storage);
@@ -60,14 +60,14 @@ class FunctionPointer<R()> {
     }
 protected:
     union {
-        char _storage[sizeof(impl::FunctionPointerSize)];
-        impl::FunctionPointerSize _alignementAndSizeGuarantees;
+        char _storage[sizeof(impl::FunctionPointerSize<I>)];
+        impl::FunctionPointerSize<I> _alignementAndSizeGuarantees;
     };
 };
 
 namespace impl {
-template <typename R>
-class FunctionPointerInterface<R()>{
+template <typename R, size_t I>
+class FunctionPointerInterface<R(),I>{
 public:
     virtual operator bool() const = 0;
     virtual bool operator ==(const FunctionPointerInterface &) const = 0;
@@ -75,13 +75,13 @@ class FunctionPointerInterface<R()>{
     virtual ~FunctionPointerInterface(){};
     virtual void copy_to(void *) const = 0;
 protected:
-    FunctionPointerStorage _fp;
+    FunctionPointerStorage<I> _fp;
 };
 
 /** A class for storing and calling a pointer to a static or member void function without arguments
  */
-template<typename R>
-class StaticPointer<R()> : public FunctionPointerInterface<R()>{
+template<typename R, size_t I>
+class StaticPointer<R(), I> : public FunctionPointerInterface<R(), I>{
 public:
     StaticPointer(R (*function)() = 0)
     {
@@ -114,8 +114,8 @@ class StaticPointer<R()> : public FunctionPointerInterface<R()>{
     }
 };
 
-template<typename R, typename C>
-class MethodPointer<R(), C> : public FunctionPointerInterface<R()>{
+template<typename R, typename C, size_t I>
+class MethodPointer<R(), C, I> : public FunctionPointerInterface<R(), I>{
 public:
     MethodPointer(C *object, R (C::*member)(void))
     {
@@ -155,22 +155,23 @@ class MethodPointer<R(), C> : public FunctionPointerInterface<R()>{
 
 
 
-template<typename R, typename F>
-class FunctorPointer<R(), F> : public FunctionPointerInterface<R()>{
-    constexpr static const bool Internal = sizeof(F) <= sizeof(impl::FunctionPointerStorage);
+template<typename R, typename F, size_t I>
+class FunctorPointer<R(), F, I> : public FunctionPointerInterface<R(), I>{
+    constexpr static const bool Internal = sizeof(F) <= sizeof(impl::FunctionPointerStorage<I>);
 public:
     FunctorPointer(const F & f)
     {
         attach(f);
     }
-    FunctorPointer(const FunctorPointer & fp) {
+    FunctorPointer(const FunctorPointer & fp)
+    {
         *this = fp;
     }
     template <typename T = F>
     typename std::enable_if<Internal && std::is_same<T,F>::value>::type
     attach(const F & f)
     {
-        new(this->_fp._functor_storage)F(f);
+        new(this->_fp._raw_storage)F(f);
     }
     template <typename T = F>
     typename std::enable_if<!Internal && std::is_same<T,F>::value>::type
@@ -186,12 +187,12 @@ class FunctorPointer<R(), F> : public FunctionPointerInterface<R()>{
     operator bool() const {
         return true;
     }
-    bool operator ==(const FunctionPointerInterface<R()> & rhs) const {
+    bool operator ==(const FunctionPointerInterface<R(), I> & rhs) const {
         return false;
     }
     FunctorPointer & operator = (const FunctorPointer & rhs) {
         deallocate();
-        attach(*reinterpret_cast<const F *>(rhs._fp._functor_storage));
+        attach(*reinterpret_cast<const F *>(rhs._fp._raw_storage));
         return *this;
     }
     ~FunctorPointer() {
@@ -204,17 +205,17 @@ class FunctorPointer<R(), F> : public FunctionPointerInterface<R()>{
     template <typename T = F>
     typename std::enable_if<Internal && std::is_same<T,F>::value, const F &>::type
     const_ref() const{
-        return *reinterpret_cast<const F *>(this->_fp._functor_storage);
+        return *reinterpret_cast<const F *>(this->_fp._raw_storage);
     }
     template <typename T = F>
     typename std::enable_if<Internal && std::is_same<T,F>::value, F &>::type
     ref() {
-        return *reinterpret_cast<F *>(this->_fp._functor_storage);
+        return *reinterpret_cast<F *>(this->_fp._raw_storage);
     }
     template <typename T = F>
     typename std::enable_if<Internal && std::is_same<T,F>::value>::type
     deallocate() {
-        reinterpret_cast<F*>(this->_fp._functor_storage)->~F();
+        reinterpret_cast<F*>(this->_fp._raw_storage)->~F();
     }
 
     template <typename T = F>
diff --git a/core-util/v2/impl/FP1.hpp b/core-util/v2/impl/FP1.hpp
index 900df58..a9e2889 100644
--- a/core-util/v2/impl/FP1.hpp
+++ b/core-util/v2/impl/FP1.hpp
@@ -19,59 +19,82 @@
 #error FP1.hpp is an internal file that should only be called from inside FunctionPointer.hpp
 #endif
 
-template <typename R, typename A1>
-class FunctionPointer<R(A1)> {
+template <typename R, typename A1, size_t I>
+class FunctionPointer<R(A1), I> {
 public:
-    typedef struct arg_struct{
-    } ArgStruct;
+    FunctionPointer(const FunctionPointer &fp) {
+        fp.const_ref().copy_to(_storage);
+    }
     typedef R(*static_fp)(A1);
     FunctionPointer(R (*fp)(A1)) {
-        new(_storage) impl::StaticPointer<R(A1)>(fp);
+        new(_storage) impl::StaticPointer<R(A1), I>(fp);
     }
     template <typename C>
     FunctionPointer(C *c, R (C::*member)(A1)) {
-        new(_storage) impl::MethodPointer<R(A1), C>(c, member);
+        new(_storage) impl::MethodPointer<R(A1), C, I>(c, member);
     }
     template <typename F>
     FunctionPointer(const F & f) {
-        new(_storage) impl::FunctorPointer<R(A1), F>(f);
+        new(_storage) impl::FunctorPointer<R(A1), F, I>(f);
     }
     operator bool() const {
-        return *reinterpret_cast<impl::FunctionPointerInterface<R(A1)> *>(const_cast<char *>(_storage));
+        return const_ref();
     }
     bool operator ==(const impl::FunctionPointerInterface<R(A1)> & rhs) const {
-        return *reinterpret_cast<impl::FunctionPointerInterface<R(A1)> *>(const_cast<char *>(_storage)) == rhs;
+        return const_ref() == rhs;
     }
-    inline R operator ()(A1&& a1) const {
-        return call(impl::forward<A1&&>(a1));
+    inline R operator ()(const A1&& a1) const {
+        return call(impl::forward<const A1&&>(a1));
     }
-    R call(A1&& a1) const {
-        return reinterpret_cast<impl::FunctionPointerInterface<R(A1)>*>(_storage)->call(impl::forward<A1&&>(a1));
+    R call(const A1&& a1) const {
+        return const_ref().call(impl::forward<const A1&&>(a1));
+    }
+    FPFunctor<R(), R(A1), I> bind(const A1 &a1) const {
+        return FPFunctor<R(), R(A1), I>(*this, a1);
     }
     ~FunctionPointer() {
-        reinterpret_cast<impl::FunctionPointerInterface<R(A1)>*>(_storage)->~FunctionPointerInterface<R(A1)>();
+        (&ref())->~FunctionPointerInterface<R(A1)>();
     }
 protected:
     union {
-        char _storage[sizeof(impl::FunctionPointerSize)];
-        impl::FunctionPointerSize _alignementAndSizeGuarantees;
+        char _storage[sizeof(impl::FunctionPointerSize<I>)];
+        impl::FunctionPointerSize<I> _alignementAndSizeGuarantees;
     };
+    impl::FunctionPointerInterface<R(A1), I> & ref() {
+        return *reinterpret_cast<impl::FunctionPointerInterface<R(A1), I>*>(_storage);
+    }
+    const impl::FunctionPointerInterface<R(A1), I> & const_ref() const {
+        return *reinterpret_cast<const impl::FunctionPointerInterface<R(A1), I>*>(_storage);
+    }
+};
+
+template <typename R, typename A1, size_t I>
+class FPFunctor<R(), R(A1), I> {
+public:
+    FPFunctor(const FunctionPointer<R(A1), I> & fp, const A1 & a1) : _fp(fp), _a1(a1) {}
+    FPFunctor(const FPFunctor &other) : _fp(other._fp),_a1(other._a1) {}
+    R operator ()() const {
+        return _fp.call(impl::forward<const A1 &&>(_a1));
+    }
+protected:
+    FunctionPointer<R(A1), I> _fp;
+    A1 _a1;
 };
 
 namespace impl {
-template <typename R, typename A1>
-class FunctionPointerInterface<R(A1)> : protected impl::FunctionPointerStorage {
+template <typename R, typename A1, size_t I>
+class FunctionPointerInterface<R(A1), I> {
 public:
     virtual operator bool() const = 0;
     virtual bool operator ==(const FunctionPointerInterface &) const = 0;
-    virtual FunctionPointerInterface & operator =(const FunctionPointerInterface &) = 0;
-    virtual R call(A1&&) const = 0;
+    virtual R call(const A1&&) const = 0;
     virtual ~FunctionPointerInterface(){};
     virtual void copy_to(void *) const = 0;
 protected:
-    impl::FunctionPointerStorage _fp;
+    impl::FunctionPointerStorage<I> _fp;
 };
 
+
 /** A class for storing and calling a pointer to a static or member void function without arguments
  */
 template <typename R, typename A1>
@@ -87,9 +110,13 @@ class StaticPointer<R(A1)> : public FunctionPointerInterface<R(A1)>{
     void attach(R (*function)(A1)) {
         this->_fp._static_fp = (void*)function;
     }
-    R call(A1&& a1) const{
+    template <size_t I>
+    FunctionPointer<R(), I> bind (A1&& a1) const {
+        return FunctionPointer<R(), I>(StaticFunctor(get_function(),forward(a1)));
+    }
+    R call(const A1&& a1) const{
         R (*f)(A1) = reinterpret_cast<R (*)(A1)>(this->_fp._static_fp);
-        return f(forward<A1>(a1));
+        return f(A1(forward<const A1 &>(a1)));
     }
     R (*get_function() const)(A1) {
         return this->_fp._static_fp;
@@ -112,6 +139,7 @@ class StaticPointer<R(A1)> : public FunctionPointerInterface<R(A1)>{
     }
 };
 
+
 template<typename R, typename A1, typename C>
 class MethodPointer<R(A1), C> : public FunctionPointerInterface<R(A1)>{
 public:
@@ -126,10 +154,14 @@ class MethodPointer<R(A1), C> : public FunctionPointerInterface<R(A1)>{
         this->_fp._method._object = (void *) object;
         *reinterpret_cast<R (C::**)(A1)>(this->_fp._method._member) = member;
     }
-    R call(A1&& a1) const{
+    template <size_t I>
+    FunctionPointer<R(), I> bind (A1&& a1) const {
+        return FunctionPointer<R(), I>();
+    }
+    R call(const A1&& a1) const{
         C* o = static_cast<C*>(this->_fp._method._object);
         R (C::**m)(A1) = reinterpret_cast<R (C::**)(A1)>(const_cast<char *>(this->_fp._method._member));
-        return (o->**m)(forward<A1>(a1));
+        return (o->**m)(A1(forward<const A1 &>(a1)));
     }
     R (*get_function() const)(){
         return NULL;
@@ -138,8 +170,8 @@ class MethodPointer<R(A1), C> : public FunctionPointerInterface<R(A1)>{
         return (this->_fp._method._object != NULL);
     }
     bool operator ==(const FunctionPointerInterface<R(A1)> & rhs) const {
-        return (this->_fp._method._object == static_cast<const MethodPointer *>(&rhs)->_method._object) &&
-            (0 == memcmp(this->_fp._method._member, static_cast<const MethodPointer *>(&rhs)->_method._member, sizeof(this->_fp._method._member)));
+        return (this->_fp._method._object == static_cast<const MethodPointer *>(&rhs)->_fp._method._object) &&
+            (0 == memcmp(this->_fp._method._member, static_cast<const MethodPointer *>(&rhs)->_fp._method._member, sizeof(this->_fp._method._member)));
     }
     MethodPointer & operator = (const MethodPointer & rhs) {
         this->_fp._method._object = rhs._fp._method._object;
@@ -154,9 +186,9 @@ class MethodPointer<R(A1), C> : public FunctionPointerInterface<R(A1)>{
     }
 };
 
-template<typename R, typename A1, typename F>
-class FunctorPointer<R(A1), F> : public FunctionPointerInterface<R(A1)>{
-    constexpr static const bool Internal = sizeof(F) <= sizeof(impl::FunctionPointerStorage);
+template<typename R, typename A1, typename F, size_t I>
+class FunctorPointer<R(A1), F, I> : public FunctionPointerInterface<R(A1), I>{
+    constexpr static const bool Internal = sizeof(F) <= sizeof(impl::FunctionPointerStorage<I>);
 public:
     FunctorPointer(const F & f)
     {
@@ -169,15 +201,15 @@ class FunctorPointer<R(A1), F> : public FunctionPointerInterface<R(A1)>{
     typename std::enable_if<Internal && std::is_same<T,F>::value>::type
     attach(const F & f)
     {
-        new(this->_fp._functor_storage)F(f);
+        new(this->_fp._raw_storage)F(f);
     }
     template <typename T = F>
     typename std::enable_if<!Internal && std::is_same<T,F>::value>::type
     attach(const F & f) {
         this->_fp._external_functor = new F(f);
     }
-    R call(A1&& a1) const{
-        return const_ref()(forward<A1>(a1));
+    R call(const A1&& a1) const{
+        return const_ref()(A1(forward<const A1 &>(a1)));
     }
     R (*get_function() const)(){
         return NULL;
@@ -185,10 +217,10 @@ class FunctorPointer<R(A1), F> : public FunctionPointerInterface<R(A1)>{
     operator bool() const {
         return true;
     }
-    bool operator ==(const FunctionPointerInterface<R(A1)> & rhs) const {
+    bool operator ==(const FunctionPointerInterface<R(A1), I> & rhs) const {
         return false;
     }
-    FunctionPointerInterface<R(A1)> & operator = (const FunctionPointerInterface<R(A1)> & rhs) {
+    FunctionPointerInterface<R(A1), I> & operator = (const FunctionPointerInterface<R(A1), I> & rhs) const {
         return *this = *static_cast<const FunctorPointer *>(&rhs);
     }
     FunctorPointer & operator = (const FunctorPointer & rhs) {
@@ -202,28 +234,29 @@ class FunctorPointer<R(A1), F> : public FunctionPointerInterface<R(A1)>{
     ~FunctorPointer() {
         deallocate();
     }
-protected:
     template <typename T = F>
     typename std::enable_if<Internal && std::is_same<T,F>::value, const F &>::type
     const_ref() const{
-        return *reinterpret_cast<const F *>(this->_fp._functor_storage);
+        return *reinterpret_cast<const F *>(this->_fp._raw_storage);
     }
+    template <typename T = F>
+    typename std::enable_if<!Internal && std::is_same<T,F>::value, const F &>::type
+    const_ref() const{
+        return *reinterpret_cast<const F *>(this->_fp._external_functor);
+    }
+
+protected:
     template <typename T = F>
     typename std::enable_if<Internal && std::is_same<T,F>::value, F &>::type
     ref() {
-        return *reinterpret_cast<F *>(this->_fp._functor_storage);
+        return *reinterpret_cast<F *>(this->_fp._raw_storage);
     }
     template <typename T = F>
     typename std::enable_if<Internal && std::is_same<T,F>::value>::type
     deallocate() {
-        reinterpret_cast<F*>(this->_fp._functor_storage)->~F();
+        reinterpret_cast<F*>(this->_fp._raw_storage)->~F();
     }
 
-    template <typename T = F>
-    typename std::enable_if<!Internal && std::is_same<T,F>::value, const F &>::type
-    const_ref() const{
-        return *reinterpret_cast<const F *>(this->_fp._external_functor);
-    }
     template <typename T = F>
     typename std::enable_if<!Internal && std::is_same<T,F>::value, F &>::type
     ref() {