macros.hpp

 
//
// Autores 2024 Realm Inc.
//
// Licenciado sob a Licença Apache, Versão 2.0 (a "Licença");
// você não pode usar este arquivo, exceto em conformidade com a Licença.
// Você pode obter uma cópia da Licença em
//
// http://www.apache.org/license/LICENSE-2.0
//
// A menos que exigido pela lei aplicável ou acordado por escrito, o software
// distribuído sob a Licença é distribuído "Como está",
// sem garantias ou condições de qualquer tipo, Express ou implícitas.
// Consulte a Licença para obter as permissões específicas de domínio do idioma e
// limitações da Licença.
//
 
#ifndef CPPREALM_MACROS_HPP
#define CPPREALM_MACROS_HPP
 
#define fe_0(o que, cls)
#define fe_1(O que, cls, X) O QUE(cls, X)
#define fe_2(quet, cls, X, ...) what(cls, X)FE_1(quem, cls, __VA_ARGS__)
#define fe_3(quet, cls, X, ...) what(cls, X)FE_2(quem, cls, __VA_ARGS__)
#define fe_4(quet, cls, X, ...) what(cls, X)FE_3(quem, cls, __VA_ARGS__)
#define fe_5(quet, cls, X, ...) what(cls, X)FE_4(quem, cls, __VA_ARGS__)
#define fe_6(quet, cls, X, ...) what(cls, X)FE_5(quem, cls, __VA_ARGS__)
#define fe_7(quet, cls, X, ...) what(cls, X)FE_6(quem, cls, __VA_ARGS__)
#define fe_8(quet, cls, X, ...) what(cls, X)FE_7(quem, cls, __VA_ARGS__)
#define fe_9(quet, cls, X, ...) what(cls, X)FE_8(quem, cls, __VA_ARGS__)
#define fe_10(quet, cls, X, ...) what(cls, X)FE_9(quem, cls, __VA_ARGS__)
#define fe_11(quet, cls, X, ...) what(cls, X)FE_10(quem, cls, __VA_ARGS__)
#define fe_12(quet, cls, X, ...) what(cls, X)FE_11(quem, cls, __VA_ARGS__)
#define fe_13(quet, cls, X, ...) what(cls, X)FE_12(quem, cls, __VA_ARGS__)
#define fe_14(quet, cls, X, ...) what(cls, X)FE_13(quem, cls, __VA_ARGS__)
#define fe_15(quet, cls, X, ...) what(cls, X)FE_14(quem, cls, __VA_ARGS__)
#define fe_16(quet, cls, X, ...) what(cls, X)FE_15(quem, cls, __VA_ARGS__)
#define fe_17(quet, cls, X, ...) what(cls, X)FE_16(quem, cls, __VA_ARGS__)
#define fe_18(quet, cls, X, ...) what(cls, X)FE_17(quem, cls, __VA_ARGS__)
#define fe_19(quet, cls, X, ...) what(cls, X)FE_18(quem, cls, __VA_ARGS__)
#define fe_20(quet, cls, X, ...) what(cls, X)FE_19(quem, cls, __VA_ARGS__)
#define fe_21(quet, cls, X, ...) what(cls, X)FE_20(quem, cls, __VA_ARGS__)
#define fe_22(quet, cls, X, ...) what(cls, X)FE_21(quem, cls, __VA_ARGS__)
#define fe_23(quet, cls, X, ...) what(cls, X)FE_22(quem, cls, __VA_ARGS__)
#define fe_24(quet, cls, X, ...) what(cls, X)FE_23(quem, cls, __VA_ARGS__)
#define fe_25(quet, cls, X, ...) what(cls, X)FE_24(quem, cls, __VA_ARGS__)
#define fe_26(quet, cls, X, ...) what(cls, X)FE_25(quem, cls, __VA_ARGS__)
#define fe_27(quet, cls, X, ...) what(cls, X)FE_26(quem, cls, __VA_ARGS__)
#define fe_28(quet, cls, X, ...) what(cls, X)FE_27(quem, cls, __VA_ARGS__)
#define fe_29(quet, cls, X, ...) what(cls, X)FE_28(quem, cls, __VA_ARGS__)
#define fe_30(quet, cls, X, ...) what(cls, X)FE_29(quem, cls, __VA_ARGS__)
#define fe_31(quet, cls, X, ...) what(cls, X)FE_30(quem, cls, __VA_ARGS__)
#define fe_32(quet, cls, X, ...) what(cls, X)FE_31(quem, cls, __VA_ARGS__)
#define fe_33(quet, cls, X, ...) what(cls, X)FE_32(quem, cls, __VA_ARGS__)
#define fe_34(quet, cls, X, ...) what(cls, X)FE_33(quem, cls, __VA_ARGS__)
#define fe_35(quet, cls, X, ...) what(cls, X)FE_34(quem, cls, __VA_ARGS__)
#define fe_36(quet, cls, X, ...) what(cls, X)FE_35(quem, cls, __VA_ARGS__)
#define fe_37(quet, cls, X, ...) what(cls, X)FE_36(quem, cls, __VA_ARGS__)
#define fe_38(quet, cls, X, ...) what(cls, X)FE_37(quem, cls, __VA_ARGS__)
#define fe_39(quet, cls, X, ...) what(cls, X)FE_38(quem, cls, __VA_ARGS__)
#define fe_40(quet, cls, X, ...) what(cls, X)FE_39(quem, cls, __VA_ARGS__)
#define fe_41(quet, cls, X, ...) what(cls, X)FE_40(quem, cls, __VA_ARGS__)
#define fe_42(quet, cls, X, ...) what(cls, X)FE_41(quem, cls, __VA_ARGS__)
#define fe_43(quet, cls, X, ...) what(cls, X)FE_42(quem, cls, __VA_ARGS__)
#define fe_44(quet, cls, X, ...) what(cls, X)FE_43(quem, cls, __VA_ARGS__)
#define fe_45(quet, cls, X, ...) what(cls, X)FE_44(quem, cls, __VA_ARGS__)
#define fe_46(quet, cls, X, ...) what(cls, X)FE_45(quem, cls, __VA_ARGS__)
#define fe_47(quet, cls, X, ...) what(cls, X)FE_46(quem, cls, __VA_ARGS__)
#define fe_48(quet, cls, X, ...) what(cls, X)FE_47(quem, cls, __VA_ARGS__)
#define fe_49(quet, cls, X, ...) what(cls, X)FE_48(quem, cls, __VA_ARGS__)
#define fe_50(quet, cls, X, ...) what(cls, X)FE_49(quem, cls, __VA_ARGS__)
#define fe_51(quet, cls, X, ...) what(cls, X)FE_50(quem, cls, __VA_ARGS__)
#define fe_52(quet, cls, X, ...) what(cls, X)FE_51(quem, cls, __VA_ARGS__)
#define fe_53(quet, cls, X, ...) what(cls, X)FE_52(quem, cls, __VA_ARGS__)
#define fe_54(quet, cls, X, ...) what(cls, X)FE_53(quem, cls, __VA_ARGS__)
#define fe_55(quet, cls, X, ...) what(cls, X)FE_54(quem, cls, __VA_ARGS__)
#define fe_56(quet, cls, X, ...) what(cls, X)FE_55(quem, cls, __VA_ARGS__)
#define fe_57(quet, cls, X, ...) what(cls, X)FE_56(quem, cls, __VA_ARGS__)
#define fe_58(quet, cls, X, ...) what(cls, X)FE_57(quem, cls, __VA_ARGS__)
#define fe_59(quet, cls, X, ...) what(cls, X)FE_58(quem, cls, __VA_ARGS__)
#define fe_60(quet, cls, X, ...) what(cls, X)FE_59(quem, cls, __VA_ARGS__)
#define fe_61(quet, cls, X, ...) what(cls, X)FE_60(quem, cls, __VA_ARGS__)
#define fe_62(quet, cls, X, ...) what(cls, X)FE_61(quem, cls, __VA_ARGS__)
#define fe_63(quet, cls, X, ...) what(cls, X)FE_62(quem, cls, __VA_ARGS__)
#define fe_64(quet, cls, X, ...) what(cls, X)FE_63(quem, cls, __VA_ARGS__)
#define fe_65(quet, cls, X, ...) what(cls, X)FE_64(quem, cls, __VA_ARGS__)
#define fe_66(quet, cls, X, ...) what(cls, X)FE_65(quem, cls, __VA_ARGS__)
#define fe_67(quet, cls, X, ...) what(cls, X)FE_66(quem, cls, __VA_ARGS__)
#define fe_68(quet, cls, X, ...) what(cls, X)FE_67(quem, cls, __VA_ARGS__)
#define fe_69(quet, cls, X, ...) what(cls, X)FE_68(quem, cls, __VA_ARGS__)
#define fe_70(quet, cls, X, ...) what(cls, X)FE_69(quem, cls, __VA_ARGS__)
#define fe_71(quet, cls, X, ...) what(cls, X)FE_70(quem, cls, __VA_ARGS__)
#define fe_72(quet, cls, X, ...) what(cls, X)FE_71(quem, cls, __VA_ARGS__)
#define fe_73(quet, cls, X, ...) what(cls, X)FE_72(quem, cls, __VA_ARGS__)
#define fe_74(quet, cls, X, ...) what(cls, X)FE_73(quem, cls, __VA_ARGS__)
#define fe_75(quet, cls, X, ...) what(cls, X)FE_74(quem, cls, __VA_ARGS__)
#define fe_76(quet, cls, X, ...) what(cls, X)FE_75(quem, cls, __VA_ARGS__)
#define fe_77(quet, cls, X, ...) what(cls, X)FE_76(quem, cls, __VA_ARGS__)
#define fe_78(quet, cls, X, ...) what(cls, X)FE_77(quem, cls, __VA_ARGS__)
#define fe_79(quet, cls, X, ...) what(cls, X)FE_78(quem, cls, __VA_ARGS__)
#define fe_80(quet, cls, X, ...) what(cls, X)FE_79(quem, cls, __VA_ARGS__)
#define fe_81(quet, cls, X, ...) what(cls, X)FE_80(quem, cls, __VA_ARGS__)
#define fe_82(quet, cls, X, ...) what(cls, X)FE_81(quem, cls, __VA_ARGS__)
#define fe_83(quet, cls, X, ...) what(cls, X)FE_82(quem, cls, __VA_ARGS__)
#define fe_84(quet, cls, X, ...) what(cls, X)FE_83(quem, cls, __VA_ARGS__)
#define fe_85(quet, cls, X, ...) what(cls, X)FE_84(quem, cls, __VA_ARGS__)
#define fe_86(quet, cls, X, ...) what(cls, X)FE_85(quem, cls, __VA_ARGS__)
#define fe_87(quet, cls, X, ...) what(cls, X)FE_86(quem, cls, __VA_ARGS__)
#define fe_88(quet, cls, X, ...) what(cls, X)FE_87(quem, cls, __VA_ARGS__)
#define fe_89(quet, cls, X, ...) what(cls, X)FE_88(quem, cls, __VA_ARGS__)
#define fe_90(quet, cls, X, ...) what(cls, X)FE_89(quem, cls, __VA_ARGS__)
#define fe_91(quet, cls, X, ...) what(cls, X)FE_90(quem, cls, __VA_ARGS__)
#define fe_92(quet, cls, X, ...) what(cls, X)FE_91(quem, cls, __VA_ARGS__)
#define fe_93(quet, cls, X, ...) what(cls, X)FE_92(quem, cls, __VA_ARGS__)
#define fe_94(quet, cls, X, ...) what(cls, X)FE_93(quem, cls, __VA_ARGS__)
#define fe_95(quet, cls, X, ...) what(cls, X)FE_94(quem, cls, __VA_ARGS__)
#define fe_96(quet, cls, X, ...) what(cls, X)FE_95(quem, cls, __VA_ARGS__)
#define fe_97(quet, cls, X, ...) what(cls, X)FE_96(quem, cls, __VA_ARGS__)
#define fe_98(quet, cls, X, ...) what(cls, X)FE_97(quem, cls, __VA_ARGS__)
#define fe_99(quet, cls, X, ...) what(cls, X)FE_98(quem, cls, __VA_ARGS__)
#define fe_100(quente, cls, X, ...) QUE(cls, X) fe_99(quente, cls, __VA_ARGS__)
#define fe_101(quente, cls, X, ...) QUE(cls, X) fe_100(quente, cls, __VA_ARGS__)
#define fe_102(quente, cls, X, ...) QUE(cls, X) fe_101(quente, cls, __VA_ARGS__)
#define fe_103(quente, cls, X, ...) QUE(cls, X) fe_102(quente, cls, __VA_ARGS__)
#define fe_104(quente, cls, X, ...) QUE(cls, X) fe_103(quente, cls, __VA_ARGS__)
#define fe_105(quente, cls, X, ...) QUE(cls, X) fe_104(quente, cls, __VA_ARGS__)
#define fe_106(quente, cls, X, ...) QUE(cls, X) fe_105(quente, cls, __VA_ARGS__)
#define fe_107(quente, cls, X, ...) QUE(cls, X) fe_106(quente, cls, __VA_ARGS__)
#define fe_108(quente, cls, X, ...) QUE(cls, X) fe_107(quente, cls, __VA_ARGS__)
#define fe_109(quente, cls, X, ...) QUE(cls, X) fe_108(quente, cls, __VA_ARGS__)
#define fe_110(quente, cls, X, ...) QUE(cls, X) fe_109(quente, cls, __VA_ARGS__)
#define fe_111(quente, cls, X, ...) QUE(cls, X) fe_110(quente, cls, __VA_ARGS__)
#define fe_112(quente, cls, X, ...) QUE(cls, X) fe_111(quente, cls, __VA_ARGS__)
#define fe_113(quente, cls, X, ...) QUE(cls, X) fe_112(quente, cls, __VA_ARGS__)
#define fe_114(quente, cls, X, ...) QUE(cls, X) fe_113(quente, cls, __VA_ARGS__)
#define fe_115(quente, cls, X, ...) QUE(cls, X) fe_114(quente, cls, __VA_ARGS__)
#define fe_116(quente, cls, X, ...) QUE(cls, X) fe_115(quente, cls, __VA_ARGS__)
#define fe_117(quente, cls, X, ...) QUE(cls, X) fe_116(quente, cls, __VA_ARGS__)
#define fe_118(quente, cls, X, ...) QUE(cls, X) fe_117(quente, cls, __VA_ARGS__)
#define fe_119(quente, cls, X, ...) QUE(cls, X) fe_118(quente, cls, __VA_ARGS__)
#define fe_120(quente, cls, X, ...) QUE(cls, X) fe_119(quente, cls, __VA_ARGS__)
#define fe_121(quente, cls, X, ...) QUE(cls, X) fe_120(quente, cls, __VA_ARGS__)
#define fe_122(quente, cls, X, ...) QUE(cls, X) fe_121(quente, cls, __VA_ARGS__)
#define fe_123(quente, cls, X, ...) QUE(cls, X) fe_122(quente, cls, __VA_ARGS__)
#define fe_124(quente, cls, X, ...) QUE(cls, X) fe_123(quente, cls, __VA_ARGS__)
#define fe_125(quente, cls, X, ...) QUE(cls, X) fe_124(quente, cls, __VA_ARGS__)
#define fe_126(quente, cls, X, ...) QUE(cls, X) fe_125(quente, cls, __VA_ARGS__)
#define fe_127(quente, cls, X, ...) QUE(cls, X) fe_126(quente, cls, __VA_ARGS__)
#define fe_128(quente, cls, X, ...) QUE(cls, X) fe_127(quente, cls, __VA_ARGS__)
#define fe_129(quente, cls, X, ...) QUE(cls, X) fe_128(quente, cls, __VA_ARGS__)
#define fe_130(quente, cls, X, ...) QUE(cls, X) fe_129(quente, cls, __VA_ARGS__)
#define fe_131(quente, cls, X, ...) QUE(cls, X) fe_130(quente, cls, __VA_ARGS__)
#define fe_132(quente, cls, X, ...) QUE(cls, X) fe_131(quente, cls, __VA_ARGS__)
#define fe_133(quente, cls, X, ...) QUE(cls, X) fe_132(quente, cls, __VA_ARGS__)
#define fe_134(quente, cls, X, ...) QUE(cls, X) fe_133(quente, cls, __VA_ARGS__)
#define fe_135(quente, cls, X, ...) QUE(cls, X) fe_134(quente, cls, __VA_ARGS__)
#define fe_136(quente, cls, X, ...) QUE(cls, X) fe_135(quente, cls, __VA_ARGS__)
#define fe_137(quente, cls, X, ...) QUE(cls, X) fe_136(quente, cls, __VA_ARGS__)
#define fe_138(quente, cls, X, ...) QUE(cls, X) fe_137(quente, cls, __VA_ARGS__)
#define fe_139(quente, cls, X, ...) QUE(cls, X) fe_138(quente, cls, __VA_ARGS__)
#define fe_140(quente, cls, X, ...) QUE(cls, X) fe_139(quente, cls, __VA_ARGS__)
#define fe_141(quente, cls, X, ...) QUE(cls, X) fe_140(quente, cls, __VA_ARGS__)
#define fe_142(quente, cls, X, ...) QUE(cls, X) fe_141(quente, cls, __VA_ARGS__)
#define fe_143(quente, cls, X, ...) QUE(cls, X) fe_142(quente, cls, __VA_ARGS__)
#define fe_144(quente, cls, X, ...) QUE(cls, X) fe_143(quente, cls, __VA_ARGS__)
#define fe_145(quente, cls, X, ...) QUE(cls, X) fe_144(quente, cls, __VA_ARGS__)
#define fe_146(quente, cls, X, ...) QUE(cls, X) fe_145(quente, cls, __VA_ARGS__)
#define fe_147(quente, cls, X, ...) QUE(cls, X) fe_146(quente, cls, __VA_ARGS__)
#define fe_148(quente, cls, X, ...) QUE(cls, X) fe_147(quente, cls, __VA_ARGS__)
#define fe_149(quente, cls, X, ...) QUE(cls, X) fe_148(quente, cls, __VA_ARGS__)
#define fe_150(quente, cls, X, ...) QUE(cls, X) fe_149(quente, cls, __VA_ARGS__)
#define fe_151(quente, cls, X, ...) QUE(cls, X) fe_150(quente, cls, __VA_ARGS__)
#define fe_152(quente, cls, X, ...) QUE(cls, X) fe_151(quente, cls, __VA_ARGS__)
#define fe_153(quente, cls, X, ...) QUE(cls, X) fe_152(quente, cls, __VA_ARGS__)
#define fe_154(quente, cls, X, ...) QUE(cls, X) fe_153(quente, cls, __VA_ARGS__)
#define fe_155(quente, cls, X, ...) QUE(cls, X) fe_154(quente, cls, __VA_ARGS__)
#define fe_156(quente, cls, X, ...) QUE(cls, X) fe_155(quente, cls, __VA_ARGS__)
#define fe_157(quente, cls, X, ...) QUE(cls, X) fe_156(quente, cls, __VA_ARGS__)
#define fe_158(quente, cls, X, ...) QUE(cls, X) fe_157(quente, cls, __VA_ARGS__)
#define fe_159(quente, cls, X, ...) QUE(cls, X) fe_158(quente, cls, __VA_ARGS__)
#define fe_160(quente, cls, X, ...) QUE(cls, X) fe_159(quente, cls, __VA_ARGS__)
#define fe_161(quente, cls, X, ...) QUE(cls, X) fe_160(quente, cls, __VA_ARGS__)
#define fe_162(quente, cls, X, ...) QUE(cls, X) fe_161(quente, cls, __VA_ARGS__)
#define fe_163(quente, cls, X, ...) QUE(cls, X) fe_162(quente, cls, __VA_ARGS__)
#define fe_164(quente, cls, X, ...) QUE(cls, X) fe_163(quente, cls, __VA_ARGS__)
#define fe_165(quente, cls, X, ...) QUE(cls, X) fe_164(quente, cls, __VA_ARGS__)
#define fe_166(quente, cls, X, ...) QUE(cls, X) fe_165(quente, cls, __VA_ARGS__)
#define fe_167(quente, cls, X, ...) QUE(cls, X) fe_166(quente, cls, __VA_ARGS__)
#define fe_168(quente, cls, X, ...) QUE(cls, X) fe_167(quente, cls, __VA_ARGS__)
#define fe_169(quente, cls, X, ...) QUE(cls, X) fe_168(quente, cls, __VA_ARGS__)
#define fe_170(quente, cls, X, ...) QUE(cls, X) fe_169(quente, cls, __VA_ARGS__)
#define fe_171(quente, cls, X, ...) QUE(cls, X) fe_170(quente, cls, __VA_ARGS__)
#define fe_172(quente, cls, X, ...) QUE(cls, X) fe_171(quente, cls, __VA_ARGS__)
#define fe_173(quente, cls, X, ...) QUE(cls, X) fe_172(quente, cls, __VA_ARGS__)
#define fe_174(quente, cls, X, ...) QUE(cls, X) fe_173(quente, cls, __VA_ARGS__)
#define fe_175(quente, cls, X, ...) QUE(cls, X) fe_174(quente, cls, __VA_ARGS__)
#define fe_176(quente, cls, X, ...) QUE(cls, X) fe_175(quente, cls, __VA_ARGS__)
#define fe_177(quente, cls, X, ...) QUE(cls, X) fe_176(quente, cls, __VA_ARGS__)
#define fe_178(quente, cls, X, ...) QUE(cls, X) fe_177(quente, cls, __VA_ARGS__)
#define fe_179(quente, cls, X, ...) QUE(cls, X) fe_178(quente, cls, __VA_ARGS__)
#define fe_180(quente, cls, X, ...) QUE(cls, X) fe_179(quente, cls, __VA_ARGS__)
#define fe_181(quente, cls, X, ...) QUE(cls, X) fe_180(quente, cls, __VA_ARGS__)
#define fe_182(quente, cls, X, ...) QUE(cls, X) fe_181(quente, cls, __VA_ARGS__)
#define fe_183(quente, cls, X, ...) QUE(cls, X) fe_182(quente, cls, __VA_ARGS__)
#define fe_184(quente, cls, X, ...) QUE(cls, X) fe_183(quente, cls, __VA_ARGS__)
#define fe_185(quente, cls, X, ...) QUE(cls, X) fe_184(quente, cls, __VA_ARGS__)
#define fe_186(quente, cls, X, ...) QUE(cls, X) fe_185(quente, cls, __VA_ARGS__)
#define fe_187(quente, cls, X, ...) QUE(cls, X) fe_186(quente, cls, __VA_ARGS__)
#define fe_188(quente, cls, X, ...) QUE(cls, X) fe_187(quente, cls, __VA_ARGS__)
#define fe_189(quente, cls, X, ...) QUE(cls, X) fe_188(quente, cls, __VA_ARGS__)
#define fe_190(quente, cls, X, ...) QUE(cls, X) fe_189(quente, cls, __VA_ARGS__)
#define fe_191(quente, cls, X, ...) QUE(cls, X) fe_190(quente, cls, __VA_ARGS__)
#define fe_192(quente, cls, X, ...) QUE(cls, X) fe_191(quente, cls, __VA_ARGS__)
#define fe_193(quente, cls, X, ...) QUE(cls, X) fe_192(quente, cls, __VA_ARGS__)
#define fe_194(quente, cls, X, ...) QUE(cls, X) fe_193(quente, cls, __VA_ARGS__)
#define fe_195(quente, cls, X, ...) QUE(cls, X) fe_194(quente, cls, __VA_ARGS__)
#define fe_196(quente, cls, X, ...) QUE(cls, X) fe_195(quente, cls, __VA_ARGS__)
#define fe_197(quente, cls, X, ...) QUE(cls, X) fe_196(quente, cls, __VA_ARGS__)
#define fe_198(quente, cls, X, ...) QUE(cls, X) fe_197(quente, cls, __VA_ARGS__)
#define fe_199(quente, cls, X, ...) QUE(cls, X) fe_198(quente, 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, NOME, ...) NOME \
 
#define FOR_EACH(ação, 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) (ação, cls, __VA_ARGS__)
 
namespace Realm {
    template<typename T, typename = null>
    estrutura managed;
}
 
#define DECLORE_PERSISTED(cls, propriedade) managed<decltype(cls::property)> propriedade;
#define DECLORE_PROPERTY(cls, p) Realm:: propriedade<&cls::p>(#p),
#define DECLORE_MANAGED_PROPERTY(cls, p) &realm::managed<cls>::p,
#define DECLORE_MANAGED_PROPERTY_NAME(cls, p) #p,
<cls>. }
 
#include <utility>
 
#include <cpprealm/internal/bridge/col_key.hpp>
#include <cpprealm/internal/bridge/obj.hpp>
#include <cpprealm/internal/bridge/ objeto.hpp>
#include <cpprealm/internal/bridge/ Property propriedade>
#include <cpprealm/internal/bridge/query.hpp>
#include <cprealm/internal/bridge/realm.hpp>
 
namespace Realm {
    classe rbool;
 
    estrutura, estrutura managed_base {
    protegido:
        managed_base() = default;
        managed_base(const managed_basee outros) {
 m_obj = outro.m_obj;
 m_realm = outro.m_realm;
 m_key = outro.m_key;
 m_rbool_query = outro.m_rbool_query;
 }
        managed_base& operator=(const managed_base& other) {
 m_obj = outro.m_obj;
 m_realm = outro.m_realm;
 m_key = outro.m_key;
 m_rbool_query = outro.m_rbool_query;
            devolva *isto;
 }
        managed_base(managed_base&& outro) {
 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);
            devolva *isto;
 }
        ~managed_base() {
 m_obj = nullptr;
 m_realm = nullptr;
 m_rbool_query = nullptr;
 m_key.~col_key();
 }
    público:
        estático constexpr bool is_object = false;
        internal::bridge::obj *m_obj = nullptr;
        internal::bridge::realm *m_realm = nullptr;
        internal::bridge::col_key m_key;
        // Marcar: queries
        rbool* m_rbool_query = nullptr;
 
        atribuição vazia (interna::ponte::obj *obj,
                    internal::bridge:: Realm* Realm,
                    internal::bridge::col_key &&key) {
 esta->m_obj = obj;
 isto->m_realm = Realm;
 esta->m_key = key;
 }
 
        atribuição vazia (interna::ponte::obj *obj,
                    internal::bridge:: Realm* Realm,
                    const internal::bridge::col_key &key) {
 esta->m_obj = obj;
 isto->m_realm = Realm;
 esta->m_key = key;
 }
 
        modelo<typename T>
        managed_base& operator =(const T& v) {
            se constexpr (std::is_same_v<T, std::nullopt_t>) {
 m_obj->set_null(m_key);
 } mais {
 m_obj->template set<typename internal::type_info::type_info<T, null>::internal_type>(m_key, v);
 }
            devolva *isto;
 }
 
        vazio prepare_for_query(interno::bridge:: Realm* Realm,
                               const internal::bridge::table& table,
                               const std::string_view& col_name,
                               Realm::rbool* query_builder) {
 isto->m_realm = Realm;
 esta->m_key = table.get_column_key(col_name);
 esta->m_rbool_query = query_builder;
 }
 };
 
    template<typename T, typename>
    estrutura, estrutura managed;
}
 
#define __cpprealm_build_query(op, name, type) \
rbool managed<type>::operator op(const type& rhs) const noexceto { \
    if (This->m_rbool_query) { \
        return this->m_rbool_query->name(m_key, rhs); \
    } \
    return serialize(detach()) op serialize(rhs); \
} \
 
#define __cpprealm_build_optional_query(op, name, type) \
3<type><type>
    if (This->m_rbool_query) { \
        return this->m_rbool_query->name(m_key, rhs); \
    } \
    return serialize(detach()) op serialize(rhs); \
} \
 
#define Realm_SCHEMA(cls, ...) \
    DECLORE_REALM_SCHEMA(cls, false, false, ObjectType::TopLevel, __VA_ARGS__) \
 
#define Realm_EMBEDDED_SCHEMA(cls, ...) \
    DECLORE_REALM_SCHEMA(cls, true, false, ObjectType::Embedded, __VA_ARGS__)
 
#define Realm_ASYMMETRIC_SCHEMA(cls, ...) \
    DECLORE_REALM_SCHEMA(cls, false, true, ObjectType::Asymmetric, __VA_ARGS__)
 
#define DECLORE_REALM_SCHEMA(cls, is_embedded_object, is_asymmetric_object, obj_type, ...) \
    modelo <> estrutura gerenciada<cls> { \
        managed() = padrão; \
        estático constexpr ObjectType object_type = obj_type; \
        FOR_EACH(DECLARE_PERSISTED, cls, __VA_ARGS__) \
        estático constexpr auto schema = Realm::schema(#cls, object_type, std::tuple{ FOR_EACH(DECLARE_PROPERTY, cls, __VA_ARGS__) }); \
        estática constexpr auto managed_pointers() { \
            return std::tuple{FOR_EACH(DECLARE_MANAGED_PROPERTY, cls, __VA_ARGS__)}; \
        } \
        modelo <typename PtrType> estático constexpr auto unmanaged_to_managed_pointer(PtrType ptr) { \
           FOR_EACH(DECLARE_COND_UNMANAGED_TO_MANAGED, cls, __VA_ARGS__); \
        } \
        estática constexpr auto managed_pointers_names() { \
            constexpr auto managed_pointers_names = std::array<std::string_view, std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value>{FOR_EACH(DECLARE_MANAGED_PROPERTY_NAME, cls, __VA_ARGS__)}; \
            return internal::array_to_tuple(managed_pointers_names); \
        } \
                                                                                                                \
        estático constexpr bool is_object = true; \
        gerenciado explicitamente(const internal::bridge::obj& obj, \
                         internal::bridge:: Realm Realm)\
        : m_obj(std::move(obj)) \
        , m_realm(std::move(Realm)) \
        { \
            auto zipped = internal::zip_tuples(managed_pointers(), managed_pointers_names()); \
            std::apply([&](auto& ...pair) { \
                ((*This.*pair.first).assign(&m_obj, &m_realm, m_obj.get_table().get_column_key(pair.second)), ...); \
            }, zipado); \
        } \
        managed(const managed& other) { \
            m_obj = outro.m_obj; \
            m_realm = outro.m_realm; \
            m_rbool_query = outro.m_rbool_query; \
            auto zipped = internal::zip_tuples(managed_pointers(), managed_pointers_names()); \
            if (m_rbool_query) { \
                auto schema = m_realm.schema().find(OTHER.schema.name); \
                auto group = m_realm.read_group(); \
                auto table_ref = group.get_table(schema.table_key()); \
                std::apply([&](auto& ...pair) { \
                    ((*This.*pair.first).prepare_for_query(&m_realm, table_ref, par.segundo, m_rbool_query), ...); \
                }, zipado); \
            } mais { \
                std::apply([&](auto& ...pair) { \
                    ((*This.*pair.first).assign(&m_obj, &m_realm, m_obj.get_table().get_column_key(pair.second)), ...); \
                }, zipado); \
            } \
        } \
        managed& operator=(const managed& other) { \
            m_obj = outro.m_obj; \
            m_realm = outro.m_realm; \
            m_rbool_query = outro.m_rbool_query; \
            auto zipped = internal::zip_tuples(managed_pointers(), managed_pointers_names()); \
            if (m_rbool_query) { \
                auto schema = m_realm.schema().find(OTHER.schema.name); \
                auto group = m_realm.read_group(); \
                auto table_ref = group.get_table(schema.table_key()); \
                std::apply([&](auto& ...pair) { \
                    ((*This.*pair.first).prepare_for_query(&m_realm, table_ref, par.segundo, m_rbool_query), ...); \
                }, zipado); \
            } mais { \
                std::apply([&](auto& ...pair) { \
                    ((*This.*pair.first).assign(&m_obj, &m_realm, m_obj.get_table().get_column_key(pair.second)), ...); \
                }, zipado); \
            } \
            retornar *isto; \
        } \
        managed(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 schema = m_realm.schema().find(OTHER.schema.name); \
                auto group = m_realm.read_group(); \
                auto table_ref = group.get_table(schema.table_key()); \
                std::apply([&](auto& ...pair) { \
                    ((*This.*pair.first).prepare_for_query(&m_realm, table_ref, par.segundo, m_rbool_query), ...); \
                }, zipado); \
             } mais { \
                std::apply([&](auto& ...pair) { \
                    ((*This.*pair.first).assign(&m_obj, &m_realm, m_obj.get_table().get_column_key(pair.second)), ...); \
                }, zipado); \
             } \
        } \
        operador& gerenciado=(gerenciado& outro) { \
            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 schema = m_realm.schema().find(OTHER.schema.name); \
                auto group = m_realm.read_group(); \
                auto table_ref = group.get_table(schema.table_key()); \
                std::apply([&](auto& ...pair) { \
                    ((*This.*pair.first).prepare_for_query(&m_realm, table_ref, par.segundo, m_rbool_query), ...); \
                }, zipado); \
            } mais { \
                std::apply([&](auto& ...pair) { \
                    ((*This.*pair.first).assign(&m_obj, &m_realm, m_obj.get_table().get_column_key(pair.second)), ...); \
                }, zipado); \
            } \
            retornar *isto; \
        } \
        estática gerenciada prepare_for_query(const internal::bridge::realm& r, Realm::rbool* q) { \
            managed<cls> m; \
            m.m_realm = r; \
            m.m_rbool_query = q; \
            auto schema = m.m_realm.schema().find(m.schema.name); \
            auto group = m.m_realm.read_group(); \
            auto table_ref = group.get_table(schema.table_key()); \
            auto zipped = internal::zip_tuples(managed_pointers(), managed_pointers_names()); \
            std::apply([&m, &table_ref](auto& ...pair) { \
                ((m.*pair.first).prepare_for_query(&m.m_realm, table_ref, par.second, m.m_rbool_query), ...); \
            }, zipado); \
            return m; \
        } \
        cls detach() const { \
            cls v; \
            auto assign = [&v, this](auto& emparelh) { \
                v.*(std::decay_t<decltype(pair.first)>::ptr) = ((*isto).*(pair.second)).detach(); \
            }; \
            auto zipped = internal::zip_tuples(managed<cls>::schema.ps, managed<cls>::managed_pointers()); \
            std::apply([&assign](auto& ...pair) { \
                (atribuir(par), ...); \
            }, zipado); \
            return v; \
        } \
        auto observe(std::function<void(Realm::object_change<managed>&&)>&& fn) { \
            auto m_object = std::make_shared(m_realm,<internal::bridge::object> m_obj); \
            auto wrapper = Realm::object_change_callback_wrapper<managed>{ \
            std::move(fn), esta, m_object}; \
            return m_object->add_notification_callback( \
            std::make_shared < Realm::object_change_callback_wrapper<managed>>(wrapper)); \
        } \
        bool is_invalidated() { \
            return !m_obj.is_valid(); \
        } \
        bool is_frozen() { \
            return m_realm.is_frozen(); \
        } \
        managed<cls> congelar() { \
            auto Realm = m_realm.freeze(); \
            return managed<cls>(Realm.import_copy_of(m_obj, Realm); \
        } \
        managed<cls> descongelamento() { \
            se (is_invalidated()) { \
 lance std::runtime_error("Objetos inválidos não podem ser descongelados."); \
 } \
 if (!is_frozen()) { \
 return *This; \
 } \
 auto thawed_realm = m_realm.thaw(); \
 retorno gerenciado<cls>(thawed_realm.import_copy_of(m_obj), desconfigurado_realm); \
 } \
 db get_realm() { \
 return db(m_realm); \
 } \
 bool operator ==(const managed<cls>& other) const { \
 if (m_rbool_query != nullptr) \
 lance std::runtime_error("Este operador de comparação não é válido dentro de `onde'"); \
 auto& a = m_obj; \
 auto& b = outro.m_obj; \
 se (m_realm != other.m_realm) { \
 retorno falso; \
 } \
 return a.get_table() == b.get_table() \
 && a.get_key() == b.get_key(); \
 } \
 bool operator ==(const managed<cls*>& other) const { \
 if (m_rbool_query != nullptr) \
 lance std::runtime_error("Este operador de comparação não é válido dentro de `onde'"); \
 auto& a = m_obj; \
 auto& b = outro.m_obj; \
 se (m_realm != outro->m_realm) { \
 retorno falso; \
 } \
 return a.get_table() == b->get_table() \
 && a.get_key() == b->get_key(); \
 } \
 operador de bool !=(const managed<cls>& other) const { \
 return !This->operator ==(outro); \
 } \
 bool operator !=(const managed<cls*>& other) const { \
 return !This->operator ==(outro); \
 } \
 operador de bool < (const managed<cls>& rhs) const { \
 return m_obj.get_key() < rhs.m_obj.get_key(); \
 } \
 to_json(std::ostream& out) const noexceto { \
 m_obj.to_json(out); \
 } \
 privado: \
 internal::bridge::obj m_obj; \
 internal::bridge::realm m_realm; \
 rbool* m_rbool_query = nullptr; \
 estrutura de amigo db; \
 modelo <typename, typename> estrutura de amigo gerenciada; \
 caixa de estrutura amigável do modelo <typename, typename}; \
 modelo <typename> user struct :: Realm::thread_safe_reference; \
 modelo <typename T> amigo rbool* :: Realm::internal::get_rbool(const T&); \
 \
 }; \
 struct meta_schema_##cls { \
 meta_schema_##cls() { \
 auto s = managed<cls>::schema.to_core_schema(); \
 auto it = std::find(std::begin(realm::db::schemas), std::end(realm::db::schemas), s); \
 se (it == std::end(realm::db::schemas)) \
 realm::db::schemas.push_back(s); \
 } \
 }; \
 estático inline meta_schema_##cls _meta_schema_##cls{};
 
namespace realm::internal {
    /*
     * Método auxiliar para extrair o `m_rbool_query' privado
     * propriedade em um objeto gerenciado<T> .
     */
    modelo<typename T>
 rbool* get_rbool(const T& o) {
        return o.m_rbool_query;
 }
}
 
#endif //CPPrealm_MACROS_HPP