macros.hpp

 
//
// 版权所有 2024 Realm Inc.
//
// 根据 Apache 许可证 2.0 版（“许可证”）获得许可；
// 除非符合合规，否则不得使用此文件。
// 您可以在以下网址获取许可证副本：
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// 除非适用法律要求或书面同意，否则软件
// 根据许可证分发是按“原样”分发的，
// 不提供任何类型的Express或暗示的保证或条件。
// 请参阅管理权限的特定语言的许可证和
// 许可证下的限制。
//
 
#ifndef CPPREALM_MACROS_HPP
#define CPPREALM_MACROS_HPP
 
#define FE_ 0 (WHAT, cls)
#define FE_ 1 (WHAT, cls, X) WHAT(cls, X)
#define FE_ 2 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 1 (WHAT, cls, __VA_ARGS__)
#define FE_ 3 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 2 (WHAT, cls, __VA_ARGS__)
#define FE_ 4 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 3 (WHAT, cls, __VA_ARGS__)
#define FE_ 5 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 4 (WHAT, cls, __VA_ARGS__)
#define FE_ 6 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 5 (WHAT, cls, __VA_ARGS__)
#define FE_ 7 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 6 (WHAT, cls, __VA_ARGS__)
#define FE_ 8 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 7 (WHAT, cls, __VA_ARGS__)
#define FE_ 9 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 8 (WHAT, cls, __VA_ARGS__)
#define FE_ 10 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 9 (WHAT, cls, __VA_ARGS__)
#define FE_ 11 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 10 (WHAT, cls, __VA_ARGS__)
#define FE_ 12 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 11 (WHAT, cls, __VA_ARGS__)
#define FE_ 13 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 12 (WHAT, cls, __VA_ARGS__)
#define FE_ 14 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 13 (WHAT, cls, __VA_ARGS__)
#define FE_ 15 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 14 (WHAT, cls, __VA_ARGS__)
#define FE_ 16 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 15 (WHAT, cls, __VA_ARGS__)
#define FE_ 17 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 16 (WHAT, cls, __VA_ARGS__)
#define FE_ 18 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 17 (WHAT, cls, __VA_ARGS__)
#define FE_ 19 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 18 (WHAT, cls, __VA_ARGS__)
#define FE_ 20 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 19 (WHAT, cls, __VA_ARGS__)
#define FE_ 21 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 20 (WHAT, cls, __VA_ARGS__)
#define FE_ 22 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 21 (WHAT, cls, __VA_ARGS__)
#define FE_ 23 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 22 (WHAT, cls, __VA_ARGS__)
#define FE_ 24 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 23 (WHAT, cls, __VA_ARGS__)
#define FE_ 25 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 24 (WHAT, cls, __VA_ARGS__)
#define FE_ 26 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 25 (WHAT, cls, __VA_ARGS__)
#define FE_ 27 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 26 (WHAT, cls, __VA_ARGS__)
#define FE_ 28 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 27 (WHAT, cls, __VA_ARGS__)
#define FE_ 29 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 28 (WHAT, cls, __VA_ARGS__)
#define FE_ 30 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 29 (WHAT, cls, __VA_ARGS__)
#define FE_ 31 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 30 (WHAT, cls, __VA_ARGS__)
#define FE_ 32 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 31 (WHAT, cls, __VA_ARGS__)
#define FE_ 33 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 32 (WHAT, cls, __VA_ARGS__)
#define FE_ 34 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 33 (WHAT, cls, __VA_ARGS__)
#define FE_ 35 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 34 (WHAT, cls, __VA_ARGS__)
#define FE_ 36 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 35 (WHAT, cls, __VA_ARGS__)
#define FE_ 37 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 36 (WHAT, cls, __VA_ARGS__)
#define FE_ 38 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 37 (WHAT, cls, __VA_ARGS__)
#define FE_ 39 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 38 (WHAT, cls, __VA_ARGS__)
#define FE_ 40 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 39 (WHAT, cls, __VA_ARGS__)
#define FE_ 41 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 40 (WHAT, cls, __VA_ARGS__)
#define FE_ 42 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 41 (WHAT, cls, __VA_ARGS__)
#define FE_ 43 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 42 (WHAT, cls, __VA_ARGS__)
#define FE_ 44 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 43 (WHAT, cls, __VA_ARGS__)
#define FE_ 45 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 44 (WHAT, cls, __VA_ARGS__)
#define FE_ 46 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 45 (WHAT, cls, __VA_ARGS__)
#define FE_ 47 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 46 (WHAT, cls, __VA_ARGS__)
#define FE_ 48 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 47 (WHAT, cls, __VA_ARGS__)
#define FE_ 49 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 48 (WHAT, cls, __VA_ARGS__)
#define FE_ 50 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 49 (WHAT, cls, __VA_ARGS__)
#define FE_ 51 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 50 (WHAT, cls, __VA_ARGS__)
#define FE_ 52 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 51 (WHAT, cls, __VA_ARGS__)
#define FE_ 53 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 52 (WHAT, cls, __VA_ARGS__)
#define FE_ 54 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 53 (WHAT, cls, __VA_ARGS__)
#define FE_ 55 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 54 (WHAT, cls, __VA_ARGS__)
#define FE_ 56 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 55 (WHAT, cls, __VA_ARGS__)
#define FE_ 57 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 56 (WHAT, cls, __VA_ARGS__)
#define FE_ 58 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 57 (WHAT, cls, __VA_ARGS__)
#define FE_ 59 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 58 (WHAT, cls, __VA_ARGS__)
#define FE_ 60 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 59 (WHAT, cls, __VA_ARGS__)
#define FE_ 61 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 60 (WHAT, cls, __VA_ARGS__)
#define FE_ 62 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 61 (WHAT, cls, __VA_ARGS__)
#define FE_ 63 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 62 (WHAT, cls, __VA_ARGS__)
#define FE_ 64 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 63 (WHAT, cls, __VA_ARGS__)
#define FE_ 65 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 64 (WHAT, cls, __VA_ARGS__)
#define FE_ 66 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 65 (WHAT, cls, __VA_ARGS__)
#define FE_ 67 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 66 (WHAT, cls, __VA_ARGS__)
#define FE_ 68 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 67 (WHAT, cls, __VA_ARGS__)
#define FE_ 69 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 68 (WHAT, cls, __VA_ARGS__)
#define FE_ 70 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 69 (WHAT, cls, __VA_ARGS__)
#define FE_ 71 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 70 (WHAT, cls, __VA_ARGS__)
#define FE_ 72 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 71 (WHAT, cls, __VA_ARGS__)
#define FE_ 73 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 72 (WHAT, cls, __VA_ARGS__)
#define FE_ 74 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 73 (WHAT, cls, __VA_ARGS__)
#define FE_ 75 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 74 (WHAT, cls, __VA_ARGS__)
#define FE_ 76 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 75 (WHAT, cls, __VA_ARGS__)
#define FE_ 77 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 76 (WHAT, cls, __VA_ARGS__)
#define FE_ 78 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 77 (WHAT, cls, __VA_ARGS__)
#define FE_ 79 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 78 (WHAT, cls, __VA_ARGS__)
#define FE_ 80 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 79 (WHAT, cls, __VA_ARGS__)
#define FE_ 81 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 80 (WHAT, cls, __VA_ARGS__)
#define FE_ 82 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 81 (WHAT, cls, __VA_ARGS__)
#define FE_ 83 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 82 (WHAT, cls, __VA_ARGS__)
#define FE_ 84 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 83 (WHAT, cls, __VA_ARGS__)
#define FE_ 85 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 84 (WHAT, cls, __VA_ARGS__)
#define FE_ 86 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 85 (WHAT, cls, __VA_ARGS__)
#define FE_ 87 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 86 (WHAT, cls, __VA_ARGS__)
#define FE_ 88 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 87 (WHAT, cls, __VA_ARGS__)
#define FE_ 89 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 88 (WHAT, cls, __VA_ARGS__)
#define FE_ 90 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 89 (WHAT, cls, __VA_ARGS__)
#define FE_ 91 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 90 (WHAT, cls, __VA_ARGS__)
#define FE_ 92 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 91 (WHAT, cls, __VA_ARGS__)
#define FE_ 93 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 92 (WHAT, cls, __VA_ARGS__)
#define FE_ 94 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 93 (WHAT, cls, __VA_ARGS__)
#define FE_ 95 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 94 (WHAT, cls, __VA_ARGS__)
#define FE_ 96 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 95 (WHAT, cls, __VA_ARGS__)
#define FE_ 97 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 96 (WHAT, cls, __VA_ARGS__)
#define FE_ 98 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 97 (WHAT, cls, __VA_ARGS__)
#define FE_ 99 (WHAT, cls, X, ...) WHAT(cls, X)FE_ 98 (WHAT, cls, __VA_ARGS__)
#define FE_ 100 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 99 (WHAT, cls, __VA_ARGS__)
#define FE_ 101 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 100 (WHAT, cls, __VA_ARGS__)
#define FE_ 102 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 101 (WHAT, cls, __VA_ARGS__)
#define FE_ 103 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 102 (WHAT, cls, __VA_ARGS__)
#define FE_ 104 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 103 (WHAT, cls, __VA_ARGS__)
#define FE_ 105 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 104 (WHAT, cls, __VA_ARGS__)
#define FE_ 106 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 105 (WHAT, cls, __VA_ARGS__)
#define FE_ 107 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 106 (WHAT, cls, __VA_ARGS__)
#define FE_ 108 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 107 (WHAT, cls, __VA_ARGS__)
#define FE_ 109 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 108 (WHAT, cls, __VA_ARGS__)
#define FE_ 110 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 109 (WHAT, cls, __VA_ARGS__)
#define FE_ 111 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 110 (WHAT, cls, __VA_ARGS__)
#define FE_ 112 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 111 (WHAT, cls, __VA_ARGS__)
#define FE_ 113 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 112 (WHAT, cls, __VA_ARGS__)
#define FE_ 114 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 113 (WHAT, cls, __VA_ARGS__)
#define FE_ 115 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 114 (WHAT, cls, __VA_ARGS__)
#define FE_ 116 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 115 (WHAT, cls, __VA_ARGS__)
#define FE_ 117 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 116 (WHAT, cls, __VA_ARGS__)
#define FE_ 118 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 117 (WHAT, cls, __VA_ARGS__)
#define FE_ 119 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 118 (WHAT, cls, __VA_ARGS__)
#define FE_ 120 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 119 (WHAT, cls, __VA_ARGS__)
#define FE_ 121 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 120 (WHAT, cls, __VA_ARGS__)
#define FE_ 122 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 121 (WHAT, cls, __VA_ARGS__)
#define FE_ 123 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 122 (WHAT, cls, __VA_ARGS__)
#define FE_ 124 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 123 (WHAT, cls, __VA_ARGS__)
#define FE_ 125 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 124 (WHAT, cls, __VA_ARGS__)
#define FE_ 126 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 125 (WHAT, cls, __VA_ARGS__)
#define FE_ 127 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 126 (WHAT, cls, __VA_ARGS__)
#define FE_ 128 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 127 (WHAT, cls, __VA_ARGS__)
#define FE_ 129 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 128 (WHAT, cls, __VA_ARGS__)
#define FE_ 130 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 129 (WHAT, cls, __VA_ARGS__)
#define FE_ 131 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 130 (WHAT, cls, __VA_ARGS__)
#define FE_ 132 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 131 (WHAT, cls, __VA_ARGS__)
#define FE_ 133 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 132 (WHAT, cls, __VA_ARGS__)
#define FE_ 134 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 133 (WHAT, cls, __VA_ARGS__)
#define FE_ 135 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 134 (WHAT, cls, __VA_ARGS__)
#define FE_ 136 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 135 (WHAT, cls, __VA_ARGS__)
#define FE_ 137 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 136 (WHAT, cls, __VA_ARGS__)
#define FE_ 138 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 137 (WHAT, cls, __VA_ARGS__)
#define FE_ 139 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 138 (WHAT, cls, __VA_ARGS__)
#define FE_ 140 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 139 (WHAT, cls, __VA_ARGS__)
#define FE_ 141 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 140 (WHAT, cls, __VA_ARGS__)
#define FE_ 142 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 141 (WHAT, cls, __VA_ARGS__)
#define FE_ 143 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 142 (WHAT, cls, __VA_ARGS__)
#define FE_ 144 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 143 (WHAT, cls, __VA_ARGS__)
#define FE_ 145 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 144 (WHAT, cls, __VA_ARGS__)
#define FE_ 146 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 145 (WHAT, cls, __VA_ARGS__)
#define FE_ 147 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 146 (WHAT, cls, __VA_ARGS__)
#define FE_ 148 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 147 (WHAT, cls, __VA_ARGS__)
#define FE_ 149 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 148 (WHAT, cls, __VA_ARGS__)
#define FE_ 150 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 149 (WHAT, cls, __VA_ARGS__)
#define FE_ 151 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 150 (WHAT, cls, __VA_ARGS__)
#define FE_ 152 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 151 (WHAT, cls, __VA_ARGS__)
#define FE_ 153 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 152 (WHAT, cls, __VA_ARGS__)
#define FE_ 154 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 153 (WHAT, cls, __VA_ARGS__)
#define FE_ 155 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 154 (WHAT, cls, __VA_ARGS__)
#define FE_ 156 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 155 (WHAT, cls, __VA_ARGS__)
#define FE_ 157 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 156 (WHAT, cls, __VA_ARGS__)
#define FE_ 158 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 157 (WHAT, cls, __VA_ARGS__)
#define FE_ 159 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 158 (WHAT, cls, __VA_ARGS__)
#define FE_ 160 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 159 (WHAT, cls, __VA_ARGS__)
#define FE_ 161 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 160 (WHAT, cls, __VA_ARGS__)
#define FE_ 162 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 161 (WHAT, cls, __VA_ARGS__)
#define FE_ 163 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 162 (WHAT, cls, __VA_ARGS__)
#define FE_ 164 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 163 (WHAT, cls, __VA_ARGS__)
#define FE_ 165 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 164 (WHAT, cls, __VA_ARGS__)
#define FE_ 166 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 165 (WHAT, cls, __VA_ARGS__)
#define FE_ 167 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 166 (WHAT, cls, __VA_ARGS__)
#define FE_ 168 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 167 (WHAT, cls, __VA_ARGS__)
#define FE_ 169 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 168 (WHAT, cls, __VA_ARGS__)
#define FE_ 170 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 169 (WHAT, cls, __VA_ARGS__)
#define FE_ 171 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 170 (WHAT, cls, __VA_ARGS__)
#define FE_ 172 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 171 (WHAT, cls, __VA_ARGS__)
#define FE_ 173 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 172 (WHAT, cls, __VA_ARGS__)
#define FE_ 174 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 173 (WHAT, cls, __VA_ARGS__)
#define FE_ 175 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 174 (WHAT, cls, __VA_ARGS__)
#define FE_ 176 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 175 (WHAT, cls, __VA_ARGS__)
#define FE_ 177 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 176 (WHAT, cls, __VA_ARGS__)
#define FE_ 178 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 177 (WHAT, cls, __VA_ARGS__)
#define FE_ 179 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 178 (WHAT, cls, __VA_ARGS__)
#define FE_ 180 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 179 (WHAT, cls, __VA_ARGS__)
#define FE_ 181 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 180 (WHAT, cls, __VA_ARGS__)
#define FE_ 182 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 181 (WHAT, cls, __VA_ARGS__)
#define FE_ 183 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 182 (WHAT, cls, __VA_ARGS__)
#define FE_ 184 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 183 (WHAT, cls, __VA_ARGS__)
#define FE_ 185 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 184 (WHAT, cls, __VA_ARGS__)
#define FE_ 186 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 185 (WHAT, cls, __VA_ARGS__)
#define FE_ 187 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 186 (WHAT, cls, __VA_ARGS__)
#define FE_ 188 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 187 (WHAT, cls, __VA_ARGS__)
#define FE_ 189 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 188 (WHAT, cls, __VA_ARGS__)
#define FE_ 190 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 189 (WHAT, cls, __VA_ARGS__)
#define FE_ 191 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 190 (WHAT, cls, __VA_ARGS__)
#define FE_ 192 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 191 (WHAT, cls, __VA_ARGS__)
#define FE_ 193 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 192 (WHAT, cls, __VA_ARGS__)
#define FE_ 194 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 193 (WHAT, cls, __VA_ARGS__)
#define FE_ 195 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 194 (WHAT, cls, __VA_ARGS__)
#define FE_ 196 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 195 (WHAT, cls, __VA_ARGS__)
#define FE_ 197 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 196 (WHAT, cls, __VA_ARGS__)
#define FE_ 198 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 197 (WHAT, cls, __VA_ARGS__)
#define FE_ 199 (WHAT, cls, X, ...) WHAT(cls, X) FE_ 198 (WHAT, cls, __VA_ARGS__)
 
#define GET_MACRO(_ 0 , _ 1 , _ 2 , _ 3 , _ 4 , _ 5 , _ 6 , _ 7 , _ 8 , _ 9 , _ 10 , _ 11 , _ 12 , \
    _ 13 , _ 14 , _ 15 , _ 16 , _ 17 , _ 18 , _ 19 , _ 20 , _ 21 , _ 22 , _ 23 、 _ 24 、 _ 25 、 _ 26 、\
    _ 27 , _ 28 , _ 29 , _ 30 , _ 31 , _ 32 , _ 33 , _ 34 , _ 35 , _ 36 , _ 37 、 _ 38 、 _ 39 、 _ 40 、\
    _ 41 , _ 42 , _ 43 , _ 44 , _ 45 , _ 46 , _ 47 , _ 48 , _ 49 , _ 50 , _ 51 、 _ 52 、 _ 53 、 _ 54 、\
    _ 55 , _ 56 , _ 57 , _ 58 , _ 59 , _ 60 , _ 61 , _ 62 , _ 63 , _ 64 , _ 65 、 _ 66 、 _ 67 、 _ 68 、\
    _ 69 , _ 70 , _ 71 , _ 72 , _ 73 , _ 74 , _ 75 , _ 76 , _ 77 , _ 78 , _ 79 、 _ 80 、 _ 81 、 _ 82 、\
    _83, _84, _85, _86, _87, _88, _89, _90, _91, _92, _93, _94, _95, _96, \
    _ 97 , _ 98 , _ 99 , _ 100 , _ 101 , _ 102 , _ 103 , _ 104 , _ 105 , _ 106 , _ 107 , _ 108 , _ 109 , \
    _110, _111, _112, _113, _114, _115, _116, _117, _118, _119, _120, _121, \
    _122, _123, _124, _125, _126, _127, _128, _129, _130, _131, _132, _133, \
    _134, _135, _136, _137, _138, _139, _140, _141, _142, _143, _144, _145, \
    _146, _147, _148, _149, _150, _151, _152, _153, _154, _155, _156, _157, \
    _158, _159, _160, _161, _162, _163, _164, _165, _166, _167, _168, _169, \
    _170, _171, _172, _173, _174, _175, _176, _177, _178, _179, _180, _181, \
    _182, _183, _184, _185, _186, _187, _188, _189, _190, _191, _192, _193, \
    _ 194 , _ 195 , _ 196 , _ 197 , _ 198 , _ 199 , NAME, ...) NAME\
 
#define FOR_EACH(动作, cls, ...) \
  GET_MACRO(_0, __VA_ARGS__, \
        FE_ 199 、FE_ 198 、FE_ 197 、FE_ 196 、FE_ 195 、FE_ 194 、FE_ 193 、FE_ 192 、FE_ 191 、FE_ 190 、 \
        FE_ 189 、FE_ 188 、FE_ 187 、FE_ 186 、FE_ 185 、FE_ 184 、FE_ 183 、FE_ 182 、FE_ 181 、FE_ 180 、 \
        FE_ 179 、FE_ 178 、FE_ 177 、FE_ 176 、FE_ 175 、FE_ 174 、FE_ 173 、FE_ 172 、FE_ 171 、FE_ 170 、 \
        FE_ 169 、FE_ 168 、FE_ 167 、FE_ 166 、FE_ 165 、FE_ 164 、FE_ 163 、FE_ 162 、FE_ 161 、FE_ 160 、 \
        FE_ 159 、FE_ 158 、FE_ 157 、FE_ 156 、FE_ 155 、FE_ 154 、FE_ 153 、FE_ 152 、FE_ 151 、FE_ 150 、 \
        FE_ 149 、FE_ 148 、FE_ 147 、FE_ 146 、FE_ 145 、FE_ 144 、FE_ 143 、FE_ 142 、FE_ 141 、FE_ 140 、 \
        FE_ 139 、FE_ 138 、FE_ 137 、FE_ 136 、FE_ 135 、FE_ 134 、FE_ 133 、FE_ 132 、FE_ 131 、FE_ 130 、 \
        FE_ 129 、FE_ 128 、FE_ 127 、FE_ 126 、FE_ 125 、FE_ 124 、FE_ 123 、FE_ 122 、FE_ 121 、FE_ 120 、 \
        FE_ 119 、FE_ 118 、FE_ 117 、FE_ 116 、FE_ 115 、FE_ 114 、FE_ 113 、FE_ 112 、FE_ 111 、FE_ 110 、 \
        FE_ 109 、FE_ 108 、FE_ 107 、FE_ 106 、FE_ 105 、FE_ 104 、FE_ 103 、FE_ 102 、FE_ 101 、FE_ 100 、 \
        FE_ 99 、FE_ 98 、FE_ 97 、FE_ 96 、FE_ 95 、FE_ 94 、FE_ 93 、FE_ 92 、FE_ 91 、FE_ 90 、 \
        FE_ 89 、FE_ 88 、FE_ 87 、FE_ 86 、FE_ 85 、FE_ 84 、FE_ 83 、FE_ 82 、FE_ 81 、FE_ 80 、 \
        FE_ 79 、FE_ 78 、FE_ 77 、FE_ 76 、FE_ 75 、FE_ 74 、FE_ 73 、FE_ 72 、FE_ 71 、FE_ 70 、 \
        FE_ 69 、FE_ 68 、FE_ 67 、FE_ 66 、FE_ 65 、FE_ 64 、FE_ 63 、FE_ 62 、FE_ 61 、FE_ 60 、 \
        FE_ 59 、FE_ 58 、FE_ 57 、FE_ 56 、FE_ 55 、FE_ 54 、FE_ 53 、FE_ 52 、FE_ 51 、FE_ 50 、 \
        FE_ 49 、FE_ 48 、FE_ 47 、FE_ 46 、FE_ 45 、FE_ 44 、FE_ 43 、FE_ 42 、FE_ 41 、FE_ 40 、 \
        FE_ 39 、FE_ 38 、FE_ 37 、FE_ 36 、FE_ 35 、FE_ 34 、FE_ 33 、FE_ 32 、FE_ 31 、FE_ 30 、 \
        FE_ 29 、FE_ 28 、FE_ 27 、FE_ 26 、FE_ 25 、FE_ 24 、FE_ 23 、FE_ 22 、FE_ 21 、FE_ 20 、 \
        FE_ 19 、FE_ 18 、FE_ 17 、FE_ 16 、FE_ 15 、FE_ 14 、FE_ 13 、FE_ 12 、FE_ 11 、FE_ 10 、 \
        FE_ 9 、FE_ 8 、FE_ 7 、FE_ 6 、FE_ 5 、FE_ 4 、FE_ 3 、FE_ 2 、FE_ 1 、FE_ 0 ） (action, cls, __VA_ARGS__)
 
命名空间域 {
    template < typename T, typename = void >
    struct 托管；
 }
 
#define DECLARE_PERSISTED(cls, property) Managed<decltype(cls::property)> property;
#define DECLARE_PROPERTY(cls, p) 域:: 属性<&cls::p>(#p),
#define DECLARE_MANAGED_PROPERTY(cls, p) &realm:: 托管<cls>::p,
#define DECLARE_MANAGED_PROPERTY_NAME(cls, p) #p,
#define DECLARE_COND_UNMANAGED_TO_MANAGED(cls, p) if constexpr (std::is_same_v<decltype(ptr), decltype(&cls::p)>) { return &managed<cls>::p; } }
 
#include <utility>
 
#include <cpprealm/internal/bridge/col_key.hpp>
#include <cpprealm/internal/bridge/obj.hpp>
#include <cpprealm/internal/bridge/ 对象.hpp>
#include <cpprealm/internal/bridge/ 属性>
#include <cpprealm/internal/bridge/ 查询.hpp>
#include <cpprealm/internal/bridge/realm.hpp>
 
命名空间域 {
    class rbool;
 
    struct Managed_base {
    protected ：
        Managed_base () = 默认 ;
        Managed_base ( const Managed_base & other) {
 m_obj = other.m_obj;
 m_realm = other.m_realm;
 m_key = other.m_key;
 m_rbool_query = other.m_rbool_query;
 }
        Managed_base & Operator=( const Managed_base & other) {
 m_obj = other.m_obj;
 m_realm = other.m_realm;
 m_key = other.m_key;
 m_rbool_query = other.m_rbool_query;
            return * this ;
 }
        managed_base ( managed_base && other) {
 m_obj = std::move(other.m_obj);
 m_realm = std::move(other.m_realm);
 m_key = std::move(other.m_key);
 m_rbool_query = std::move(other.m_rbool_query);
 }
        Managed_base & Operator=( managed_base && other) {
 m_obj = std::move(other.m_obj);
 m_realm = std::move(other.m_realm);
 m_key = std::move(other.m_key);
 m_rbool_query = std::move(other.m_rbool_query);
            return * this ;
 }
        ~managed_base () {
 m_obj = nullptr;
 m_realm = nullptr;
 m_rbool_query = nullptr ;
 m_key.~col_key();
 }
    public :
        静态 constexpr bool is_object = false ;
        Internal::bridge::obj *m_obj = nullptr ；
        Internal::bridge:: Realm *m_realm = nullptr ;
        Internal::bridge::col_key m_key;
        // MARK: 查询
        rbool * m_rbool_query = nullptr ;
 
        void assign( internal::bridge::obj *obj,
                    Internal::bridge:: 域 * 域，
                    Internal::bridge::col_key &&key) {
 this->m_obj = obj;
 this->m_realm = 域;
 this->m_key = key;
 }
 
        void assign( internal::bridge::obj *obj,
                    Internal::bridge:: 域 * 域，
                    const Internal::bridge::col_key &key) {
 this->m_obj = obj;
 this->m_realm = 域;
 this->m_key = key;
 }
 
        template < typename T>
        Managed_base & Operator =( const T& v) {
            if constexpr (std::is_same_v<T, std::nullopt_t>) {
 m_obj->set_null(m_key);
 } else {
 m_obj->template 设立<typenameinternal::type_info::type_info<T, void>::internal_type>(m_key, v);
 }
            return * this ;
 }
 
        void prepare_for_query( Internal::bridge:: 域 * 域，
                               const 内部::桥::表和表，
                               const std::string_view& col_name,
                               域::rbool * query_builder) {
 this->m_realm = 域;
 this->m_key =table.get_column_key(col_name);
 this->m_rbool_query = query_builder;
 }
 }；
 
    template < typename T, typename >
    struct 托管；
 }
 
#define __cpprealm_build_query(op, name, type) \
rbool 托管<type>:: 操作符 op(const type& rhs) const noException { \
    if (this->m_rbool_query) { \
        return this->m_rbool_query->name(m_key, rhs); \
    } \
    返回序列化（分离（）） op序列化（rhs）; \
} \
 
#define __cpprealm_build_Optional_query(op, name, type) \
rbool 托管<std::Optional<type>>:: 操作符 op(const std::Optional<type>& rhs) const noException { \
    if (this->m_rbool_query) { \
        return this->m_rbool_query->name(m_key, rhs); \
    } \
    返回序列化（分离（）） op序列化（rhs）; \
} \
 
#define REALM_SCHEMA(cls, ...) \
    DECLARE_REALM_SCHEMA(cls, false, false, ObjectType::TopLevel, __VA_ARGS__) \
 
#define REALM_EMBEDDED_SCHEMA(cls, ...) \
    DECLARE_REALM_SCHEMA(cls, true, false, ObjectType::Embedded, __VA_ARGS__)
 
#define REALM_ASYMMETRIC_SCHEMA(cls, ...) \
    DECLARE_REALM_SCHEMA(cls, false, true, ObjectType::Asymmetric, __VA_ARGS__)
 
#define DECLARE_REALM_SCHEMA(cls, is_embedded_object, is_asymmetric_object, obj_type, ...) \
    template <> 托管<cls> { \
        托管() = 默认; \
        static constexpr ObjectType object_type = obj_type; \
        FOR_EACH(DECLARE_PERSISTED, cls, __VA_ARGS__) \
        static constexpr auto 模式 = 域:: 模式(#cls, object_type, std::tuple{ FOR_EACH(DECLARE_PROPERTY, cls, __VA_ARGS__) } ); \
        static constexpr automanaged_pointers() { \
            return std::tuple{FOR_EACH(DECLARE_MANAGED_PROPERTY, cls, __VA_ARGS__)}; \
        } \
        template <typename PtrType> static constexpr auto unmanaged_to_managed_pointer(PtrType ptr) { \
           FOR_EACH(DECLARE_COND_UNMANAGED_TO_MANAGED, cls, __VA_ARGS__); \
        } \
        static constexpr automanaged_pointers_names() { \
            constexpr auto Managed_pointers_names = std:: 大量<std::string_view, std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value>{FOR_EACH(DECLARE_MANAGED_PROPERTY_NAME, cls, __VA_ARGS__)}; \
            returninternal::array_to_tuple(managed_pointers_names); \
        } \
                                                                                                                \
        static constexpr bool is_object = true; \
        显式托管（const内部::bridge::obj& obj，\
                         Internal::bridge:: 域 域) \
        : m_obj(std::move(obj)) \
        , m_realm(std::move(域)) \
        {\
            auto zipped =Internal::zip_tuples(managed_pointers(), Managed_pointers_names()); \
            std:: 应用([&](auto& ...pair) { \
                ((*this.*pair.first). assign(&m_obj, &m_realm, m_obj.get_table().get_column_key(pair.second)), ...); \
            }, zipped); \
        } \
        托管(const Managed& other) { \
            m_obj = other.m_obj; \
            m_realm = other.m_realm; \
            m_rbool_query = other.m_rbool_query; \
            auto zipped =Internal::zip_tuples(managed_pointers(), Managed_pointers_names()); \
            if (m_rbool_query) { \
                auto 模式 = m_realm。 模式().find(other. 模式.name); \
                auto 群组 = m_realm.read_group(); \
                auto tab_ref = 群组.get_table(模式.table_key()); \
                std:: 应用([&](auto& ...pair) { \
                    ((*this.*pair.first).prepare_for_query(&m_realm, Table_ref,pair.second, m_rbool_query), ...); \
                }, zipped); \
            } else { \
                std:: 应用([&](auto& ...pair) { \
                    ((*this.*pair.first). assign(&m_obj, &m_realm, m_obj.get_table().get_column_key(pair.second)), ...); \
                }, zipped); \
            } \
        } \
        Managed& Operator=(const Managed& other) { \
            m_obj = other.m_obj; \
            m_realm = other.m_realm; \
            m_rbool_query = other.m_rbool_query; \
            auto zipped =Internal::zip_tuples(managed_pointers(), Managed_pointers_names()); \
            if (m_rbool_query) { \
                auto 模式 = m_realm。 模式().find(other. 模式.name); \
                auto 群组 = m_realm.read_group(); \
                auto tab_ref = 群组.get_table(模式.table_key()); \
                std:: 应用([&](auto& ...pair) { \
                    ((*this.*pair.first).prepare_for_query(&m_realm, Table_ref,pair.second, m_rbool_query), ...); \
                }, zipped); \
            } else { \
                std:: 应用([&](auto& ...pair) { \
                    ((*this.*pair.first). assign(&m_obj, &m_realm, m_obj.get_table().get_column_key(pair.second)), ...); \
                }, zipped); \
            } \
            return *this; \
        } \
        托管（托管&&其他）{\
            m_obj = std::move(other.m_obj); \
            m_realm = std::move(other.m_realm); \
            m_rbool_query = std::move(other.m_rbool_query); \
            auto zipped =Internal::zip_tuples(managed_pointers(), Managed_pointers_names()); \
            if (m_rbool_query) { \
                auto 模式 = m_realm。 模式().find(other. 模式.name); \
                auto 群组 = m_realm.read_group(); \
                auto tab_ref = 群组.get_table(模式.table_key()); \
                std:: 应用([&](auto& ...pair) { \
                    ((*this.*pair.first).prepare_for_query(&m_realm, Table_ref,pair.second, m_rbool_query), ...); \
                }, zipped); \
             } else { \
                std:: 应用([&](auto& ...pair) { \
                    ((*this.*pair.first). assign(&m_obj, &m_realm, m_obj.get_table().get_column_key(pair.second)), ...); \
                }, zipped); \
             } \
        } \
        Managed& Operator=(managed&& other) { \
            m_obj = std::move(other.m_obj); \
            m_realm = std::move(other.m_realm); \
            m_rbool_query = std::move(other.m_rbool_query); \
            auto zipped =Internal::zip_tuples(managed_pointers(), Managed_pointers_names()); \
            if (m_rbool_query) { \
                auto 模式 = m_realm。 模式().find(other. 模式.name); \
                auto 群组 = m_realm.read_group(); \
                auto tab_ref = 群组.get_table(模式.table_key()); \
                std:: 应用([&](auto& ...pair) { \
                    ((*this.*pair.first).prepare_for_query(&m_realm, Table_ref,pair.second, m_rbool_query), ...); \
                }, zipped); \
            } else { \
                std:: 应用([&](auto& ...pair) { \
                    ((*this.*pair.first). assign(&m_obj, &m_realm, m_obj.get_table().get_column_key(pair.second)), ...); \
                }, zipped); \
            } \
            return *this; \
        } \
        static 托管 prepare_for_query(constinternal::bridge::realm&r, 域::rbool*q) { \
            托管<cls> m; \
            m.m_realm = r; \
            m.m_rbool_query = q; \
            auto schema = m.m_realm.schema().find(m.schema.name); \
            auto 群组 = m.m_realm.read_group(); \
            auto tab_ref = 群组.get_table(模式.table_key()); \
            auto zipped =Internal::zip_tuples(managed_pointers(), Managed_pointers_names()); \
            std:: 应用([&m, &table_ref](auto& ...pair) { \
                ((m.*pair.first).prepare_for_query(&m.m_realm,table_ref,pair.second, m.m_rbool_query), ...); \
            }, zipped); \
            return m; \
        } \
        cls detach() const { \
            cls v; \
            auto assign = [&v, this](auto&pair) { \
                v.*(std::decay_t<decltype(pair.first)>::ptr) = ((*this).*(pair.second)).detach(); \
            }; \
            auto zipped =Internal::zip_tuples(托管<cls>:: 模式.ps, 托管<cls>::managed_pointers()); \
            std:: 应用([&Assign](auto& ...pair) { \
                (分配(对)，...); \
            }, zipped); \
            return v; \
        } \
        auto watch(std::function<void(域::object_change<managed> &&)>&& fn) { \
            auto m_object = std::make_shared(m_realm,<internal::bridge::object> m_obj); \
            autowrapper =<managed> 域::object_change_callback_wrapper{\
            std::move(fn), this, m_object}; \
            return m_object->add_notification_callback( \
            std::make_shared< 域::object_change_callback_wrapper<managed> >(wrapper)); \
        } \
        bool is_invalidated() { \
            return !m_obj.is_valid(); \
        } \
        bool is_frozen() { \
            return m_realm.is_frozen(); \
        } \
        托管<cls> Freeze() { \
            auto 域 = m_realm.freeze(); \
            return 托管<cls>(域.import_copy_of(m_obj), 域); \
        } \
        托管<cls> thaw() { \
            if (is_invalidated()) { \
throw std::runtime_error("无效的对象无法解冻。" ); \
 } \
 if (!is_frozen()) { \
 return *this; \
 } \
 auto thawed_realm = m_realm.thaw(); \
 return 托管<cls>(thawed_realm.import_copy_of(m_obj), thawed_realm); \
 } \
 db get_realm() { \
 return db(m_realm); \
 } \
 bool Operator ==(const Managed<cls>& other) const { \
 if (m_rbool_query != nullptr) \
 throw std::runtime_error("This比较操作符在 `where` 内无效"); \
 auto& a = m_obj; \
 auto& b = other.m_obj; \
 if (m_realm != other.m_realm) {\
返回 false； \
 } \
 return a.get_table() == b.get_table() \
 && a.get_key() == b.get_key(); \
 } \
 bool 操作符 ==(const 托管<cls*>& other) const { \
 if (m_rbool_query != nullptr) \
 throw std::runtime_error("This比较操作符在 `where` 内无效"); \
 auto& a = m_obj; \
 auto& b = other.m_obj; \
 if (m_realm != other->m_realm) { \
返回 false； \
 } \
 return a.get_table() == b->get_table() \
 && a.get_key() == b->get_key(); \
 } \
 bool Operator !=(const Managed<cls>& other) const { \
 return !this-> 操作符 ==(other); \
 } \
 bool 操作符 !=(const 托管<cls*>& other) const { \
 return !this-> 操作符 ==(other); \
 } \
 bool Operator < (const Managed<cls>& rhs) const { \
 return m_obj.get_key() < rhs.m_obj.get_key(); \
 } \
 void to_json(std::ostream& out) const noException { \
 m_obj.to_json(out); \
 } \
 private: \
内部::桥::obj m_obj; \
 internal::bridge::realm m_realm; \
 rbool* m_rbool_query = nullptr; \
 Friend struct db; \
模板  友元结构托管； \
 template <typename, typename>Friend struct Box; \
 template <typename>Friend struct:: 域::thread_Safe_reference; \
 template <typename T>Friend rbool*:: 域::Internal::get_rbool(const T&); \
 \
 }; \
 struct meta_schema_##cls { \
 meta_schema_##cls() { \
 auto s = 托管<cls>:: 模式.to_core_schema(); \
 auto it = std::find(std::begin(realm::db::schemas), std::end(realm::db::schemas), s); \
 if (it == std::end(realm::db::schemas)) \
 realm::db::schemas.push_back(s); \
 } \
 }; \
 static inline meta_schema_##cls _meta_schema_##cls{};
 
命名空间realm::internal {
    /*
     * 用于提取私有“m_rbool_query”的辅助方法
     *托管<T>对象上的属性。
     */
    template < typename T>
 rbool* get_rbool(const T& o) {
        return o.m_rbool_query;
 }
 }
 
#endif //CPREALM_MACROS_HPP