update: expose private variables more elegant

src/core_test/codec/short_code.cc

@@ -21,17 +21,17 @@ using klotski::codec::SHORT_CODE_LIMIT;
 static const auto TEST_THREAD_NUM = 256;
 
 /// Forcibly modify private variables to reset state.
-FORCIBLY_ACCESS(AllCases, available_, bool)
-FORCIBLY_ACCESS(BasicRanges, available_, bool)
+//FORCIBLY_ACCESS(AllCases, available_, bool)
+//FORCIBLY_ACCESS(BasicRanges, available_, bool)
 
 /// Reset basic ranges build state, note it is thread-unsafe.
 void basic_ranges_reset() {
-    exposer::BasicRanges_available_(BasicRanges::instance()) = false;
+//    exposer::BasicRanges_available_(BasicRanges::instance()) = false;
 }
 
 /// Reset all cases build state, note it is thread-unsafe.
 void all_cases_reset() {
-    exposer::AllCases_available_(AllCases::instance()) = false;
+//    exposer::AllCases_available_(AllCases::instance()) = false;
 }
 
 TEST(ShortCode, limit) {

src/core_test/ffi/all_cases.cc

@@ -16,17 +16,37 @@ using klotski::cases::ALL_CASES_NUM;
 static constexpr std::string_view ALL_CASES_MD5 = "3888e9fab8d3cbb50908b12b147cfb23";
 
 /// Forcibly modify private variables to reset state.
-FORCIBLY_ACCESS(AllCases, available_, bool)
-FORCIBLY_ACCESS(BasicRanges, available_, bool)
+//FORCIBLY_ACCESS(AllCases, available_, bool)
+//FORCIBLY_ACCESS(BasicRanges, available_, bool)
+
+FORCE_ACCESS_VAR(BasicRanges, available_, bool, Helper_1);
+FORCE_ACCESS_VAR(AllCases, available_, bool, Helper_2);
+
+//namespace exposer {
+//
+//struct Helper_1 {};
+//
+//template struct Exposer<bool (BasicRanges::*), &BasicRanges::available_, Helper_1>;
+//
+////template<>
+//constexpr bool BasicRanges::* fetch(Helper_1);
+//
+//bool& Demo_val(BasicRanges &c) {
+//    return c.*fetch(Helper_1{});
+//}
+//
+//}
 
 /// Reset basic ranges build state, note it is thread-unsafe.
 void basic_ranges_reset() {
     exposer::BasicRanges_available_(BasicRanges::instance()) = false;
+//    exposer::BasicRanges_available_(BasicRanges::instance()) = false;
 }
 
 /// Reset all cases build state, note it is thread-unsafe.
 void all_cases_reset() {
     exposer::AllCases_available_(AllCases::instance()) = false;
+//    exposer::AllCases_available_(AllCases::instance()) = false;
 }
 
 TEST(AllCases, all_cases_prebuild) {

src/core_test/utility/exposer.h

@@ -6,24 +6,36 @@
 
 namespace exposer {
 
-template <typename T>
+// REF: http://bloglitb.blogspot.com/2010/07/access-to-private-members-thats-easy.html
+
+//template <typename T>
+//struct Exposer {
+//    static T ptr;
+//};
+//
+//template <typename T>
+//T Exposer<T>::ptr;
+//
+//template <typename T, T Ptr>
+//struct ExposerImpl {
+//    static struct Factory {
+//        Factory() { Exposer<T>::ptr = Ptr; }
+//    } factory;
+//};
+//
+//template <typename T, T Ptr>
+//typename ExposerImpl<T, Ptr>::Factory ExposerImpl<T, Ptr>::factory;
+
+//template <typename T>
+//constexpr T fetch();
+
+//template <typename T, T Val, int Flag>
+template <typename T, T Val, typename Unique>
 struct Exposer {
-    static T ptr;
+//    constexpr friend T fetch<>() { return Val; }
+    constexpr friend T fetch(Unique) { return Val; }
 };
 
-template <typename T>
-T Exposer<T>::ptr;
-
-template <typename T, T Ptr>
-struct ExposerImpl {
-    static struct Factory {
-        Factory() { Exposer<T>::ptr = Ptr; }
-    } factory;
-};
-
-template <typename T, T Ptr>
-typename ExposerImpl<T, Ptr>::Factory ExposerImpl<T, Ptr>::factory;
-
 } // namespace exposer
 
 #define FORCIBLY_ACCESS(Class, Member, Type)                                   \
@@ -33,3 +45,13 @@ typename ExposerImpl<T, Ptr>::Factory ExposerImpl<T, Ptr>::factory;
             return T.*exposer::Exposer<Type Class::*>::ptr;                    \
         }                                                                      \
     }
+
+#define FORCE_ACCESS_VAR(Class, Member, Type, Unique) \
+    namespace exposer { \
+        struct Unique {}; \
+        template struct Exposer<Type (Class::*), &Class::Member, Unique>; \
+        constexpr Type Class::* fetch(Unique); \
+        Type& Class##_##Member(Class &T) { \
+            return T.*fetch(Unique{}); \
+        } \
+    }