From f6f2d388212d4e22f0f73d0bd982be41b57f3b60 Mon Sep 17 00:00:00 2001
From: Mathew Sutcliffe <oktal3700@gmail.com>
Date: Tue, 25 Oct 2016 22:41:10 +0100
Subject: [PATCH] refs #784 Added helper class for using CMemoTable with
 containers of value objects.

---
 src/blackmisc/memotable.h  | 52 ++++++++++++++++++++++++++++++++++++++
 src/blackmisc/typetraits.h | 12 +++++++++
 2 files changed, 64 insertions(+)

diff --git a/src/blackmisc/memotable.h b/src/blackmisc/memotable.h
index d976cc919..456a6681b 100644
--- a/src/blackmisc/memotable.h
+++ b/src/blackmisc/memotable.h
@@ -46,6 +46,58 @@ namespace BlackMisc
         CSequence<T> m_list;
         CDictionary<T, int, QMap> m_dict;
     };
+
+    /*!
+     * Helper class for memoizing members of a value object.
+     */
+    template <typename... Ts>
+    struct CMemoHelper
+    {
+        //! Memoizer for Ts. Other types are passed through.
+        class CMemoizer : private CMemoTable<Ts>...
+        {
+        public:
+            //! If T is in Ts, return the index of member in the memo table.
+            template <typename T, std::enable_if_t<TIsOneOf<T, Ts...>::value, int> = 0>
+            int maybeMemoize(const T &member) { return this->CMemoTable<T>::getIndex(member); }
+
+            //! If T is not in Ts, return member.
+            template <typename T, std::enable_if_t<! TIsOneOf<T, Ts...>::value, int> = 0>
+            const T &maybeMemoize(const T &member) { return member; }
+
+            //! Return the values in the T table as a flat list.
+            template <typename T>
+            const CSequence<T> &getTable() const { return this->CMemoTable<T>::getTable(); }
+        };
+
+        //! Unmemoizer for Ts. Other types are passed through.
+        class CUnmemoizer : private CSequence<Ts>...
+        {
+        public:
+            //! Return reference to the flat list T table.
+            template <typename T>
+            CSequence<T> &getTable() { return *this; }
+
+            //! If T is in Ts, return proxy that will assign to member through the value at the given index in the flat list.
+            template <typename T, std::enable_if_t<TIsOneOf<T, Ts...>::value, int> = 0>
+            auto maybeUnmemoize(T &member) const
+            {
+                struct Memo
+                {
+                    int index;
+                    T &member;
+                    const CSequence<T> &list;
+                    int &get() { return index; }
+                    ~Memo() { if (index >= 0) { member = list[index]; } }
+                };
+                return Memo { -1, member, static_cast<const CSequence<T> &>(*this) };
+            }
+
+            //! If T is not in Ts, return member as std::reference_wrapper.
+            template <typename T, std::enable_if_t<! TIsOneOf<T, Ts...>::value, int> = 0>
+            auto maybeUnmemoize(T &member) const { return std::ref(member); }
+        };
+    };
 }
 
 #endif
diff --git a/src/blackmisc/typetraits.h b/src/blackmisc/typetraits.h
index 268f2f57a..9ed1236fc 100644
--- a/src/blackmisc/typetraits.h
+++ b/src/blackmisc/typetraits.h
@@ -162,6 +162,18 @@ namespace BlackMisc
     struct TIsEqualityComparable<T, U, void_t<decltype(std::declval<T>() == std::declval<U>())>> : public std::true_type {};
     //! \endcond
 
+    /*!
+     * Trait that detects if a type is a member of a parameter pack.
+     */
+    template <typename T, typename... Ts>
+    struct TIsOneOf : public std::false_type {};
+    //! \cond
+    template <typename T, typename... Ts>
+    struct TIsOneOf<T, T, Ts...> : public std::true_type {};
+    template <typename T, typename T2, typename... Ts>
+    struct TIsOneOf<T, T2, Ts...> : public TIsOneOf<T, Ts...> {};
+    //! \endcond
+
     /*!
      * Trait that detects if a type is QPrivateSignal.
      */